Text File Operations in C

The fscanf() function reads formatted data from a file, acting as the input counterpart to fprintf(). Just as scanf() reads from the keyboard, fscanf() reads from a file stream, parsing text according to format specifiers. It is essential for reading structured text files like CSV data, configuration files, and data exports.

Understanding fscanf()

fscanf() reads input from a file stream, interpreting it according to a format string. It returns the number of items successfully read, or EOF if it reaches the end of the file before reading any items.

int fscanf(FILE *stream, const char *format, ...);

// Basic usage example
int value;
FILE *fp = fopen("numbers.txt", "r");
if (fp != NULL) {
    fscanf(fp, "%d", &value);  // Note the & for address
    printf("Read: %d\n", value);
    fclose(fp);
}

Reading Different Data Types

#include <stdio.h>

int main() {
    FILE *fp = fopen("data.txt", "r");
    if (fp == NULL) {
        perror("Cannot open file");
        return 1;
    }
    
    int id;
    char name[50];
    float score;
    
    // Read structured data
    int items = fscanf(fp, "%d %s %f", &id, name, &score);
    
    if (items == 3) {
        printf("ID: %d, Name: %s, Score: %.2f\n", id, name, score);
    } else {
        printf("Error: Expected 3 items, got %d\n", items);
    }
    
    fclose(fp);
    return 0;
}

Reading Multiple Records in a Loop

A common pattern is reading multiple records until reaching the end of the file. Check the return value against the expected number of items to know when to stop:

#include <stdio.h>

int main() {
    FILE *fp = fopen("students.txt", "r");
    if (fp == NULL) {
        perror("Cannot open file");
        return 1;
    }
    
    char name[50];
    int age;
    float gpa;
    int count = 0;
    
    // Read until we cannot get all 3 items
    while (fscanf(fp, "%s %d %f", name, &age, &gpa) == 3) {
        printf("Student %d: %s, Age: %d, GPA: %.2f\n", 
               ++count, name, age, gpa);
    }
    
    printf("Total students read: %d\n", count);
    fclose(fp);
    return 0;
}

Reading CSV Files

CSV files use commas as delimiters. You can handle this by including the comma in the format string:

#include <stdio.h>

int main() {
    FILE *fp = fopen("products.csv", "r");
    if (fp == NULL) {
        return 1;
    }
    
    // Skip header line
    char header[256];
    fgets(header, sizeof(header), fp);
    
    // Read CSV data (id,name,price format)
    int id;
    char name[50];
    float price;
    
    while (fscanf(fp, "%d,%[^,],%f", &id, name, &price) == 3) {
        printf("Product #%d: %s - $%.2f\n", id, name, price);
    }
    
    fclose(fp);
    return 0;
}

fscanf() vs fgets() + sscanf()

While fscanf() is convenient, combining fgets() with sscanf() is often safer for real-world files:

#include <stdio.h>

int main() {
    FILE *fp = fopen("data.txt", "r");
    if (fp == NULL) return 1;
    
    char line[256];
    int lineNum = 0;
    int id;
    float value;
    
    while (fgets(line, sizeof(line), fp)) {
        lineNum++;
        
        // Try to parse the line
        if (sscanf(line, "%d %f", &id, &value) == 2) {
            printf("Line %d: ID=%d, Value=%.2f\n", lineNum, id, value);
        } else {
            printf("Line %d: Invalid format, skipping\n", lineNum);
        }
    }
    
    fclose(fp);
    return 0;
}

#include <stdio.h>

int main() {
    FILE *fp = fopen("numbers.txt", "r");
    if (fp == NULL) {
        perror("Cannot open file");
        return 1;
    }
    
    int num, sum = 0, count = 0;
    
    while (fscanf(fp, "%d", &num) == 1) {
        sum += num;
        count++;
    }
    
    printf("Read %d numbers\n", count);
    printf("Sum: %d\n", sum);
    printf("Average: %.2f\n", (float)sum / count);
    
    fclose(fp);
    return 0;
}

#include <stdio.h>
#include <string.h>

int main() {
    FILE *fp = fopen("config.txt", "r");
    if (fp == NULL) {
        perror("Cannot open config");
        return 1;
    }
    
    char line[256];
    char key[64], value[128];
    
    while (fgets(line, sizeof(line), fp)) {
        // Skip comments and empty lines
        if (line[0] == '#' || line[0] == '\n') {
            continue;
        }
        
        // Parse key=value
        if (sscanf(line, "%[^=]=%[^\n]", key, value) == 2) {
            printf("Key: '%s' -> Value: '%s'\n", key, value);
        }
    }
    
    fclose(fp);
    return 0;
}

#include <stdio.h>
#include <string.h>

#define MAX_PRODUCTS 100

typedef struct {
    int id;
    char name[50];
    float price;
} Product;

int main() {
    FILE *fp = fopen("products.csv", "r");
    if (fp == NULL) {
        perror("Cannot open CSV");
        return 1;
    }
    
    Product products[MAX_PRODUCTS];
    int count = 0;
    char line[256];
    
    // Skip header
    fgets(line, sizeof(line), fp);
    
    // Read products
    while (fgets(line, sizeof(line), fp) && count < MAX_PRODUCTS) {
        if (sscanf(line, "%d,%[^,],%f", 
                   &products[count].id,
                   products[count].name,
                   &products[count].price) == 3) {
            count++;
        }
    }
    fclose(fp);
    
    // Find most expensive
    int maxIdx = 0;
    for (int i = 1; i < count; i++) {
        if (products[i].price > products[maxIdx].price) {
            maxIdx = i;
        }
    }
    
    printf("Most expensive: %s at $%.2f\n", 
           products[maxIdx].name, products[maxIdx].price);
    return 0;
}

When working with text files, you often want to process data line by line rather than by individual values. The fgets() and fputs() functions are designed exactly for this purpose. They read and write complete lines of text, making them ideal for log files, text processing, and any situation where preserving line structure matters.

Reading Lines with fgets()

fgets() is the safest way to read a line of text in C. Unlike the dangerous gets() function (which should never be used), fgets() limits how many characters it reads, preventing buffer overflows.

char *fgets(char *str, int n, FILE *stream);

// Parameters:
// str    - buffer to store the line
// n      - maximum characters to read (including null terminator)
// stream - file to read from

// Returns:
// str on success, NULL on error or EOF

#include <stdio.h>
#include <string.h>

int main() {
    FILE *fp = fopen("poem.txt", "r");
    if (fp == NULL) {
        perror("Cannot open file");
        return 1;
    }
    
    char line[256];
    int lineNum = 0;
    
    while (fgets(line, sizeof(line), fp) != NULL) {
        // Remove trailing newline if present
        line[strcspn(line, "\n")] = '\0';
        
        printf("Line %d: %s\n", ++lineNum, line);
    }
    
    fclose(fp);
    return 0;
}

Writing Lines with fputs()

fputs() writes a string to a file. Unlike puts(), it does NOT automatically add a newline at the end, giving you complete control over the output format.

int fputs(const char *str, FILE *stream);

// Returns:
// Non-negative on success, EOF on error

#include <stdio.h>

int main() {
    FILE *fp = fopen("output.txt", "w");
    if (fp == NULL) {
        perror("Cannot create file");
        return 1;
    }
    
    fputs("First line\n", fp);
    fputs("Second line\n", fp);
    fputs("Third line", fp);  // No newline after this
    
    fclose(fp);
    printf("File written successfully!\n");
    return 0;
}

Practical Example: File Copy

A classic use case for fgets() and fputs() is copying text files line by line:

#include <stdio.h>

int copyTextFile(const char *src, const char *dest) {
    FILE *srcFile = fopen(src, "r");
    if (srcFile == NULL) {
        perror("Cannot open source");
        return -1;
    }
    
    FILE *destFile = fopen(dest, "w");
    if (destFile == NULL) {
        perror("Cannot create destination");
        fclose(srcFile);
        return -1;
    }
    
    char line[1024];
    int linesCopied = 0;
    
    while (fgets(line, sizeof(line), srcFile) != NULL) {
        fputs(line, destFile);
        linesCopied++;
    }
    
    fclose(srcFile);
    fclose(destFile);
    return linesCopied;
}

int main() {
    int result = copyTextFile("original.txt", "backup.txt");
    
    if (result >= 0) {
        printf("Copied %d lines successfully!\n", result);
    }
    return result < 0 ? 1 : 0;
}

Processing Text Files Line by Line

Here is a more advanced example that processes a file, transforming each line:

#include <stdio.h>
#include <string.h>
#include <ctype.h>

// Convert string to uppercase
void toUpperCase(char *str) {
    while (*str) {
        *str = toupper(*str);
        str++;
    }
}

int main() {
    FILE *input = fopen("input.txt", "r");
    FILE *output = fopen("output.txt", "w");
    
    if (input == NULL || output == NULL) {
        perror("File error");
        if (input) fclose(input);
        if (output) fclose(output);
        return 1;
    }
    
    char line[512];
    
    while (fgets(line, sizeof(line), input)) {
        toUpperCase(line);
        fputs(line, output);
    }
    
    fclose(input);
    fclose(output);
    printf("Conversion complete!\n");
    return 0;
}

#include <stdio.h>

int countLines(const char *filename) {
    FILE *fp = fopen(filename, "r");
    if (fp == NULL) {
        return -1;
    }
    
    char line[1024];
    int count = 0;
    
    while (fgets(line, sizeof(line), fp) != NULL) {
        count++;
    }
    
    fclose(fp);
    return count;
}

int main() {
    int lines = countLines("sample.txt");
    
    if (lines >= 0) {
        printf("File has %d lines\n", lines);
    } else {
        printf("Cannot open file\n");
    }
    return 0;
}

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
    if (argc < 2) {
        printf("Usage: %s filename\n", argv[0]);
        return 1;
    }
    
    FILE *fp = fopen(argv[1], "r");
    if (fp == NULL) {
        perror("Cannot open file");
        return 1;
    }
    
    char line[1024];
    int lineNum = 0;
    
    while (fgets(line, sizeof(line), fp)) {
        // Remove newline for cleaner output
        line[strcspn(line, "\n")] = '\0';
        printf("%6d | %s\n", ++lineNum, line);
    }
    
    fclose(fp);
    return 0;
}

#include <stdio.h>
#include <string.h>

int searchFile(const char *filename, const char *pattern) {
    FILE *fp = fopen(filename, "r");
    if (fp == NULL) {
        perror("Cannot open file");
        return -1;
    }
    
    char line[1024];
    int lineNum = 0;
    int matches = 0;
    
    while (fgets(line, sizeof(line), fp)) {
        lineNum++;
        
        if (strstr(line, pattern) != NULL) {
            // Remove newline for output
            line[strcspn(line, "\n")] = '\0';
            printf("%d: %s\n", lineNum, line);
            matches++;
        }
    }
    
    fclose(fp);
    return matches;
}

int main(int argc, char *argv[]) {
    if (argc < 3) {
        printf("Usage: %s pattern filename\n", argv[0]);
        return 1;
    }
    
    int found = searchFile(argv[2], argv[1]);
    
    if (found >= 0) {
        printf("\n%d matches found\n", found);
    }
    return 0;
}

Sometimes you need the finest level of control over file reading and writing - one character at a time. The fgetc() and fputc() functions provide this granular access, making them perfect for character counting, text transformation, encoding detection, and building your own higher-level reading functions.

Reading Characters with fgetc()

fgetc() reads a single character from a file stream. It returns the character as an int (not char) so it can return EOF (typically -1) to indicate end-of-file or an error.

int fgetc(FILE *stream);

// Returns:
// The character read as unsigned char cast to int
// EOF on end of file or error

#include <stdio.h>

int main() {
    FILE *fp = fopen("sample.txt", "r");
    if (fp == NULL) {
        perror("Cannot open file");
        return 1;
    }
    
    int ch;  // Use int, not char!
    
    while ((ch = fgetc(fp)) != EOF) {
        printf("%c", ch);  // Print each character
    }
    
    fclose(fp);
    return 0;
}

Writing Characters with fputc()

fputc() writes a single character to a file stream. It returns the character written on success, or EOF on error.

int fputc(int c, FILE *stream);

// Returns:
// The character written on success
// EOF on error

#include <stdio.h>

int main() {
    FILE *fp = fopen("alphabet.txt", "w");
    if (fp == NULL) {
        perror("Cannot create file");
        return 1;
    }
    
    // Write A-Z to file
    for (char c = 'A'; c <= 'Z'; c++) {
        fputc(c, fp);
    }
    fputc('\n', fp);  // Add newline at end
    
    fclose(fp);
    printf("Alphabet written to file!\n");
    return 0;
}

Practical Examples

Example 1: Character Counter

#include <stdio.h>
#include <ctype.h>

typedef struct {
    int letters;
    int digits;
    int spaces;
    int lines;
    int other;
} FileStats;

FileStats analyzeFile(const char *filename) {
    FileStats stats = {0, 0, 0, 0, 0};
    
    FILE *fp = fopen(filename, "r");
    if (fp == NULL) {
        return stats;
    }
    
    int ch;
    while ((ch = fgetc(fp)) != EOF) {
        if (isalpha(ch)) stats.letters++;
        else if (isdigit(ch)) stats.digits++;
        else if (isspace(ch)) {
            stats.spaces++;
            if (ch == '\n') stats.lines++;
        }
        else stats.other++;
    }
    
    fclose(fp);
    return stats;
}

int main() {
    FileStats s = analyzeFile("sample.txt");
    
    printf("File Statistics:\n");
    printf("  Letters: %d\n", s.letters);
    printf("  Digits:  %d\n", s.digits);
    printf("  Spaces:  %d\n", s.spaces);
    printf("  Lines:   %d\n", s.lines);
    printf("  Other:   %d\n", s.other);
    
    return 0;
}

Example 2: Simple Character Encryption

#include <stdio.h>

// Simple Caesar cipher - shift each letter by key positions
void encryptFile(const char *input, const char *output, int key) {
    FILE *in = fopen(input, "r");
    FILE *out = fopen(output, "w");
    
    if (in == NULL || out == NULL) {
        if (in) fclose(in);
        if (out) fclose(out);
        return;
    }
    
    int ch;
    while ((ch = fgetc(in)) != EOF) {
        if (ch >= 'A' && ch <= 'Z') {
            ch = 'A' + (ch - 'A' + key) % 26;
        } else if (ch >= 'a' && ch <= 'z') {
            ch = 'a' + (ch - 'a' + key) % 26;
        }
        fputc(ch, out);
    }
    
    fclose(in);
    fclose(out);
}

int main() {
    encryptFile("message.txt", "encrypted.txt", 3);
    printf("File encrypted!\n");
    return 0;
}

Example 3: Binary File Copy (Character by Character)

#include <stdio.h>

long copyFile(const char *src, const char *dest) {
    FILE *srcFile = fopen(src, "rb");   // Binary mode
    FILE *destFile = fopen(dest, "wb");
    
    if (srcFile == NULL || destFile == NULL) {
        if (srcFile) fclose(srcFile);
        if (destFile) fclose(destFile);
        return -1;
    }
    
    int ch;
    long bytesCopied = 0;
    
    while ((ch = fgetc(srcFile)) != EOF) {
        fputc(ch, destFile);
        bytesCopied++;
    }
    
    fclose(srcFile);
    fclose(destFile);
    return bytesCopied;
}

int main() {
    long bytes = copyFile("image.png", "image_copy.png");
    
    if (bytes >= 0) {
        printf("Copied %ld bytes\n", bytes);
    } else {
        printf("Copy failed!\n");
    }
    return 0;
}

getc() vs fgetc() and putc() vs fputc()

You might see getc() and putc() in some code. They are nearly identical to fgetc() and fputc():

#include <stdio.h>
#include <ctype.h>

int isVowel(int ch) {
    ch = tolower(ch);
    return ch == 'a' || ch == 'e' || ch == 'i' || 
           ch == 'o' || ch == 'u';
}

int main() {
    FILE *fp = fopen("sample.txt", "r");
    if (fp == NULL) {
        perror("Cannot open file");
        return 1;
    }
    
    int ch;
    int vowelCount = 0;
    
    while ((ch = fgetc(fp)) != EOF) {
        if (isVowel(ch)) {
            vowelCount++;
        }
    }
    
    fclose(fp);
    printf("Vowel count: %d\n", vowelCount);
    return 0;
}

#include <stdio.h>
#include <ctype.h>

int main() {
    FILE *in = fopen("input.txt", "r");
    FILE *out = fopen("cleaned.txt", "w");
    
    if (in == NULL || out == NULL) {
        perror("File error");
        if (in) fclose(in);
        if (out) fclose(out);
        return 1;
    }
    
    int ch;
    int lastWasSpace = 0;
    
    while ((ch = fgetc(in)) != EOF) {
        if (ch == ' ') {
            if (!lastWasSpace) {
                fputc(ch, out);
                lastWasSpace = 1;
            }
            // Skip additional spaces
        } else {
            fputc(ch, out);
            lastWasSpace = 0;
        }
    }
    
    fclose(in);
    fclose(out);
    printf("Whitespace cleaned!\n");
    return 0;
}

#include <stdio.h>
#include <ctype.h>

int main() {
    FILE *fp = fopen("document.txt", "r");
    if (fp == NULL) {
        perror("Cannot open file");
        return 1;
    }
    
    int ch;
    int wordCount = 0;
    int inWord = 0;  // Are we inside a word?
    
    while ((ch = fgetc(fp)) != EOF) {
        if (isspace(ch)) {
            if (inWord) {
                wordCount++;  // Word ended
                inWord = 0;
            }
        } else {
            inWord = 1;  // We're in a word
        }
    }
    
    // Count last word if file doesn't end with whitespace
    if (inWord) {
        wordCount++;
    }
    
    fclose(fp);
    printf("Word count: %d\n", wordCount);
    return 0;
}

Now that you know the individual functions, let us combine them into practical patterns you will use repeatedly in real programs. These patterns handle common scenarios like processing log files, managing configuration, filtering data, and creating reports. Mastering these patterns will make you productive with file handling in C.

Pattern 1: Read-Process-Write Pipeline

This pattern reads from one file, transforms the data, and writes to another. It is the foundation of many data processing utilities:

#include <stdio.h>
#include <string.h>
#include <ctype.h>

// Transform function - customize as needed
void processLine(char *line) {
    // Example: convert to uppercase
    for (int i = 0; line[i]; i++) {
        line[i] = toupper(line[i]);
    }
}

int processFile(const char *input, const char *output) {
    FILE *in = fopen(input, "r");
    FILE *out = fopen(output, "w");
    
    if (in == NULL || out == NULL) {
        if (in) fclose(in);
        if (out) fclose(out);
        return -1;
    }
    
    char line[1024];
    int linesProcessed = 0;
    
    while (fgets(line, sizeof(line), in)) {
        processLine(line);
        fputs(line, out);
        linesProcessed++;
    }
    
    fclose(in);
    fclose(out);
    return linesProcessed;
}

Pattern 2: Filter Lines by Criteria

Extract lines matching specific criteria - like grep but customized for your needs:

#include <stdio.h>
#include <string.h>

// Filter function - return 1 to keep line, 0 to skip
int shouldKeepLine(const char *line) {
    // Example: keep lines containing "ERROR" or "WARNING"
    return strstr(line, "ERROR") != NULL || 
           strstr(line, "WARNING") != NULL;
}

int filterFile(const char *input, const char *output) {
    FILE *in = fopen(input, "r");
    FILE *out = fopen(output, "w");
    
    if (in == NULL || out == NULL) {
        if (in) fclose(in);
        if (out) fclose(out);
        return -1;
    }
    
    char line[1024];
    int kept = 0, total = 0;
    
    while (fgets(line, sizeof(line), in)) {
        total++;
        if (shouldKeepLine(line)) {
            fputs(line, out);
            kept++;
        }
    }
    
    fclose(in);
    fclose(out);
    
    printf("Kept %d of %d lines\n", kept, total);
    return kept;
}

Pattern 3: Configuration File Reader

Parse key-value configuration files - a pattern used in countless applications:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_KEY 64
#define MAX_VALUE 256
#define MAX_CONFIG 50

typedef struct {
    char key[MAX_KEY];
    char value[MAX_VALUE];
} ConfigEntry;

typedef struct {
    ConfigEntry entries[MAX_CONFIG];
    int count;
} Config;

int loadConfig(const char *filename, Config *config) {
    FILE *fp = fopen(filename, "r");
    if (fp == NULL) return -1;
    
    config->count = 0;
    char line[512];
    
    while (fgets(line, sizeof(line), fp) && config->count < MAX_CONFIG) {
        // Skip comments and empty lines
        if (line[0] == '#' || line[0] == '\n' || line[0] == ';') {
            continue;
        }
        
        char *eq = strchr(line, '=');
        if (eq == NULL) continue;
        
        // Split at '='
        *eq = '\0';
        char *key = line;
        char *value = eq + 1;
        
        // Remove newline from value
        value[strcspn(value, "\n")] = '\0';
        
        // Trim spaces (simplified)
        while (*key == ' ') key++;
        while (*value == ' ') value++;
        
        strncpy(config->entries[config->count].key, key, MAX_KEY - 1);
        strncpy(config->entries[config->count].value, value, MAX_VALUE - 1);
        config->count++;
    }
    
    fclose(fp);
    return config->count;
}

const char* getConfigValue(Config *config, const char *key) {
    for (int i = 0; i < config->count; i++) {
        if (strcmp(config->entries[i].key, key) == 0) {
            return config->entries[i].value;
        }
    }
    return NULL;
}

int main() {
    Config config;
    
    if (loadConfig("app.conf", &config) < 0) {
        printf("Cannot load config\n");
        return 1;
    }
    
    printf("Loaded %d settings\n", config.count);
    
    const char *host = getConfigValue(&config, "host");
    const char *port = getConfigValue(&config, "port");
    
    printf("Host: %s\n", host ? host : "(not set)");
    printf("Port: %s\n", port ? port : "(not set)");
    
    return 0;
}

Pattern 4: Log File Analyzer

Analyze log files to extract statistics - useful for monitoring and debugging:

#include <stdio.h>
#include <string.h>

typedef struct {
    int errors;
    int warnings;
    int info;
    int total;
} LogStats;

LogStats analyzeLog(const char *filename) {
    LogStats stats = {0, 0, 0, 0};
    
    FILE *fp = fopen(filename, "r");
    if (fp == NULL) return stats;
    
    char line[1024];
    
    while (fgets(line, sizeof(line), fp)) {
        stats.total++;
        
        if (strstr(line, "ERROR") || strstr(line, "[E]")) {
            stats.errors++;
        } else if (strstr(line, "WARNING") || strstr(line, "[W]")) {
            stats.warnings++;
        } else if (strstr(line, "INFO") || strstr(line, "[I]")) {
            stats.info++;
        }
    }
    
    fclose(fp);
    return stats;
}

int main() {
    LogStats s = analyzeLog("application.log");
    
    printf("=== Log Analysis ===\n");
    printf("Total lines: %d\n", s.total);
    printf("Errors:      %d (%.1f%%)\n", s.errors, 
           100.0 * s.errors / s.total);
    printf("Warnings:    %d (%.1f%%)\n", s.warnings, 
           100.0 * s.warnings / s.total);
    printf("Info:        %d (%.1f%%)\n", s.info, 
           100.0 * s.info / s.total);
    
    return 0;
}

Pattern 5: Append-Only Log Writer

A simple but effective logging function that safely appends timestamped entries:

#include <stdio.h>
#include <time.h>
#include <stdarg.h>

typedef enum { LOG_INFO, LOG_WARNING, LOG_ERROR } LogLevel;

int writeLog(const char *filename, LogLevel level, const char *fmt, ...) {
    FILE *fp = fopen(filename, "a");  // Append mode
    if (fp == NULL) return -1;
    
    // Get timestamp
    time_t now = time(NULL);
    struct tm *t = localtime(&now);
    
    // Level string
    const char *levelStr[] = {"INFO", "WARNING", "ERROR"};
    
    // Write timestamp and level
    fprintf(fp, "[%04d-%02d-%02d %02d:%02d:%02d] [%s] ",
            t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
            t->tm_hour, t->tm_min, t->tm_sec,
            levelStr[level]);
    
    // Write message using variable arguments
    va_list args;
    va_start(args, fmt);
    vfprintf(fp, fmt, args);
    va_end(args);
    
    fprintf(fp, "\n");
    fclose(fp);
    return 0;
}

int main() {
    writeLog("app.log", LOG_INFO, "Application started");
    writeLog("app.log", LOG_INFO, "User %s logged in", "admin");
    writeLog("app.log", LOG_WARNING, "Memory usage at %d%%", 85);
    writeLog("app.log", LOG_ERROR, "Connection failed: %s", "timeout");
    
    printf("Log entries written!\n");
    return 0;
}

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
    if (argc < 2) {
        printf("Usage: %s filename\n", argv[0]);
        return 1;
    }
    
    FILE *fp = fopen(argv[1], "r");
    if (fp == NULL) {
        perror("Cannot open file");
        return 1;
    }
    
    char line[4096];
    int totalLines = 0;
    int nonEmptyLines = 0;
    int longestLine = 0;
    long totalChars = 0;
    
    while (fgets(line, sizeof(line), fp)) {
        totalLines++;
        int len = strlen(line);
        
        // Remove newline for accurate length
        if (len > 0 && line[len-1] == '\n') {
            len--;
        }
        
        totalChars += len;
        
        if (len > 0) {
            nonEmptyLines++;
        }
        
        if (len > longestLine) {
            longestLine = len;
        }
    }
    
    fclose(fp);
    
    printf("=== File Statistics: %s ===\n", argv[1]);
    printf("Total lines:     %d\n", totalLines);
    printf("Non-empty lines: %d\n", nonEmptyLines);
    printf("Longest line:    %d chars\n", longestLine);
    printf("Average length:  %.1f chars\n", 
           totalLines > 0 ? (float)totalChars / totalLines : 0);
    
    return 0;
}

#include <stdio.h>

int main() {
    FILE *f1 = fopen("sorted1.txt", "r");
    FILE *f2 = fopen("sorted2.txt", "r");
    FILE *out = fopen("merged.txt", "w");
    
    if (!f1 || !f2 || !out) {
        perror("File error");
        if (f1) fclose(f1);
        if (f2) fclose(f2);
        if (out) fclose(out);
        return 1;
    }
    
    int n1, n2;
    int have1 = (fscanf(f1, "%d", &n1) == 1);
    int have2 = (fscanf(f2, "%d", &n2) == 1);
    
    while (have1 && have2) {
        if (n1 <= n2) {
            fprintf(out, "%d\n", n1);
            have1 = (fscanf(f1, "%d", &n1) == 1);
        } else {
            fprintf(out, "%d\n", n2);
            have2 = (fscanf(f2, "%d", &n2) == 1);
        }
    }
    
    // Write remaining from file 1
    while (have1) {
        fprintf(out, "%d\n", n1);
        have1 = (fscanf(f1, "%d", &n1) == 1);
    }
    
    // Write remaining from file 2
    while (have2) {
        fprintf(out, "%d\n", n2);
        have2 = (fscanf(f2, "%d", &n2) == 1);
    }
    
    fclose(f1);
    fclose(f2);
    fclose(out);
    
    printf("Files merged successfully!\n");
    return 0;
}