← Arrays & Strings

Select a question from the sidebar

15 questions in this topic

Question 1 / 15

How do you declare and initialize a 1D array in C?

Array declaration: type name[SIZE]; creates a fixed-size contiguous block of memory.

Initialization methods:

int arr[5] = {1, 2, 3, 4, 5}; -- explicit values.
int arr[5] = {1, 2}; -- partial init, rest is zero: {1, 2, 0, 0, 0}.
int arr[5] = {0}; -- all zeros.
int arr[] = {1, 2, 3}; -- size deduced from initializer (3 elements).
int arr[5]; -- uninitialized (garbage values for local arrays).
C99 designated initializers: int arr[5] = {[2] = 42, [4] = 99};.

Key facts:

Array size must be a compile-time constant in C89 (VLAs allowed in C99).
Array indices start at 0.
No bounds checking -- accessing out-of-bounds is undefined behavior.
Arrays cannot be assigned to each other: arr2 = arr1; is illegal.

Pseudo Code

1. int arr[5];               // uninitialized
2. int arr[5] = {1,2,3,4,5}; // explicit
3. int arr[5] = {0};          // all zeros
4. int arr[] = {1,2,3};       // size = 3 (deduced)
5. int arr[5] = {[2]=42};     // designated init (C99)
6. Access: arr[i], indices 0 to SIZE-1
7. No bounds checking in C

Code

#include <stdio.h>

int main(void) {
    /* Full initialization */
    int a[5] = {10, 20, 30, 40, 50};

    /* Partial: rest is zero */
    int b[5] = {1, 2};
    /* b = {1, 2, 0, 0, 0} */

    /* Size deduced from initializer */
    int c[] = {100, 200, 300};
    printf("c has %zu elements\n", sizeof(c) / sizeof(c[0])); /* 3 */

    /* All zeros */
    int d[5] = {0};

    /* C99 designated initializers */
    int e[5] = {[1] = 10, [3] = 30};
    /* e = {0, 10, 0, 30, 0} */

    /* Print arrays */
    for (int i = 0; i < 5; i++) {
        printf("a[%d]=%d  b[%d]=%d  d[%d]=%d  e[%d]=%d\n",
               i, a[i], i, b[i], i, d[i], i, e[i]);
    }

    return 0;
}

c has 3 elements
a[0]=10  b[0]=1  d[0]=0  e[0]=0
a[1]=20  b[1]=2  d[1]=0  e[1]=10
a[2]=30  b[2]=0  d[2]=0  e[2]=0
a[3]=40  b[3]=0  d[3]=0  e[3]=30
a[4]=50  b[4]=0  d[4]=0  e[4]=0

Key Points

•Array indices start at 0; last valid index is SIZE-1
•Partial initialization zero-fills remaining elements
•int arr[] = {...} deduces size from initializer
•No bounds checking -- out-of-bounds access is UB
•Arrays cannot be assigned: arr2 = arr1 is illegal

Gotchas

•Local uninitialized arrays contain garbage values
•Accessing arr[SIZE] (one past the end) is undefined behavior
•arr = arr2 does not copy arrays; use memcpy() instead
•VLAs (int arr[n] where n is a variable) are optional in C11 and not allowed in C89

Declare: int arr[5]. Initialize: = {1,2,3,4,5}, = {0} for all zeros, or = {1,2} (rest zero). Size deduced with int arr[] = {1,2,3}. No bounds checking. Cannot assign arrays.

•= {0} zeros all elements
•sizeof(arr)/sizeof(arr[0]) gives element count

#include <stdio.h>
int main(void) {
    int arr[] = {10, 20, 30};
    int n = sizeof(arr) / sizeof(arr[0]); /* 3 */
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

10 20 30

Out-of-bounds access is undefined behavior, not an error

Question 2 / 15

How are 2D arrays stored in memory (row-major order)?

In C, 2D arrays are stored in row-major order: all elements of row 0 come first, then row 1, then row 2, etc.

For int m[3][4], the memory layout is: m[0][0] m[0][1] m[0][2] m[0][3] m[1][0] m[1][1] ... m[2][3]

Address formula: &m[i][j] = base + (i * num_cols + j) * sizeof(element)

Why row-major matters:

Accessing m[i][j] with i in the outer loop and j in the inner loop is cache-friendly (sequential memory access).
Column-major traversal (j outer, i inner) causes cache misses on every access.

Initialization:

int m[2][3] = {{1,2,3}, {4,5,6}};
int m[2][3] = {1,2,3,4,5,6}; -- same thing (fills row by row).
int m[][3] = {{1,2,3}, {4,5,6}}; -- first dimension can be omitted.

Pseudo Code

Memory layout for int m[R][C]:
  Row 0: m[0][0], m[0][1], ..., m[0][C-1]
  Row 1: m[1][0], m[1][1], ..., m[1][C-1]
  ...
  Address: base + (i*C + j) * sizeof(int)

Row-major: rows stored contiguously
Cache-friendly: for(i) for(j) m[i][j]  (GOOD)
Cache-hostile: for(j) for(i) m[i][j]  (BAD)

Code

#include <stdio.h>

int main(void) {
    int m[3][4] = {
        {1,  2,  3,  4},
        {5,  6,  7,  8},
        {9, 10, 11, 12}
    };

    /* Print matrix */
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%3d", m[i][j]);
        }
        printf("\n");
    }

    /* Verify row-major layout */
    int *p = &m[0][0];
    printf("\nFlat memory: ");
    for (int k = 0; k < 12; k++) {
        printf("%d ", p[k]);
    }
    printf("\n"); /* 1 2 3 4 5 6 7 8 9 10 11 12 */

    /* Address arithmetic */
    printf("&m[0][0] = %p\n", (void *)&m[0][0]);
    printf("&m[1][0] = %p\n", (void *)&m[1][0]);
    printf("Difference: %td bytes\n",
           (char *)&m[1][0] - (char *)&m[0][0]); /* 16 = 4*sizeof(int) */

    /* First dimension can be omitted */
    int n[][3] = {{1,2,3}, {4,5,6}};
    printf("rows = %zu\n", sizeof(n) / sizeof(n[0])); /* 2 */

    return 0;
}

  1  2  3  4
  5  6  7  8
  9 10 11 12

Flat memory: 1 2 3 4 5 6 7 8 9 10 11 12 
&m[0][0] = 0x16b3a6bd8
&m[1][0] = 0x16b3a6be8
Difference: 16 bytes
rows = 2

Key Points

•C uses row-major order: rows are stored contiguously
•Traverse with outer row loop, inner column loop for cache performance
•Address: base + (i * cols + j) * sizeof(element)
•First dimension can be omitted in initialization
•2D array is really a 1D array of rows

Gotchas

•Column-major traversal can be 10x slower due to cache misses
•2D arrays and pointer-to-pointer (int**) are NOT the same thing
•Passing 2D arrays to functions requires specifying the column count: void f(int m[][COLS])
•int m[3][4] is NOT the same as int *m[3] (array of pointers vs 2D array)

C stores 2D arrays in row-major order: all of row 0, then row 1, etc. Access m[i][j] with i outer, j inner for cache performance. Address: base + (i*cols + j)*sizeof(elem).

•Row-major: rows stored contiguously
•Outer row, inner column for cache performance

#include <stdio.h>
int main(void) {
    int m[2][3] = {{1,2,3},{4,5,6}};
    int *flat = &m[0][0];
    for (int i = 0; i < 6; i++) printf("%d ", flat[i]);
    /* 1 2 3 4 5 6 (row-major) */
    printf("\n");
    return 0;
}

1 2 3 4 5 6

int m[3][4] is NOT the same as int **m

Question 3 / 15

What is array decay to pointer and when does it happen?

In most expressions, an array name decays (is implicitly converted) to a pointer to its first element.

When decay happens:

Passing an array to a function.
Using an array in arithmetic expressions.
Assigning an array to a pointer variable.

When decay does NOT happen (3 exceptions):

sizeof(arr) -- gives the array size, not the pointer size.
&arr -- gives a pointer to the entire array (int (*)[N]), not int *.
String literal used to initialize a char array: char s[] = "hello";.

Consequence: When you pass an array to a function, you lose the size information. The function receives just a pointer. That is why C functions typically require a separate size parameter.

Pseudo Code

int arr[5];
arr         -> decays to int* (pointer to arr[0])
sizeof(arr) -> 20 (no decay! gives array size)
&arr        -> int (*)[5] (no decay! pointer to whole array)

In function parameter:
  void f(int arr[]) is actually void f(int *arr)
  sizeof(arr) inside f gives pointer size, not array size

Code

#include <stdio.h>

void print_size(int arr[]) {
    /* arr has decayed to pointer */
    printf("Inside function: sizeof(arr) = %zu\n", sizeof(arr));
    /* 8 on 64-bit (pointer size, NOT array size) */
}

int main(void) {
    int arr[5] = {1, 2, 3, 4, 5};

    /* No decay: sizeof gives array size */
    printf("sizeof(arr) = %zu\n", sizeof(arr)); /* 20 */

    /* Decay: array name becomes pointer */
    int *p = arr;  /* arr decays to &arr[0] */
    printf("*p = %d\n", *p); /* 1 */

    /* No decay: &arr gives pointer to entire array */
    int (*ap)[5] = &arr;  /* pointer to array of 5 ints */
    printf("sizeof(*ap) = %zu\n", sizeof(*ap)); /* 20 */

    /* Decay in function call */
    print_size(arr); /* arr decays to pointer */

    /* arr and &arr have same address but different types */
    printf("arr    = %p\n", (void *)arr);    /* pointer to first element */
    printf("&arr   = %p\n", (void *)&arr);   /* pointer to whole array */
    printf("Same address? %d\n", (void *)arr == (void *)&arr); /* 1 (yes) */
    /* But: arr+1 advances by sizeof(int); &arr+1 advances by sizeof(arr) */

    return 0;
}

sizeof(arr) = 20
*p = 1
sizeof(*ap) = 20
Inside function: sizeof(arr) = 8
arr    = 0x16ee0ebf0
&arr   = 0x16ee0ebf0
Same address? 1

Key Points

•Array name decays to pointer to first element in most contexts
•Three exceptions: sizeof, &, and string literal initialization
•Function parameters int arr[] and int *arr are identical
•After decay, size information is lost
•arr and &arr have the same address but different types

Gotchas

•sizeof(arr) in a function parameter gives pointer size, not array size
•You cannot return an array from a function (it would return a dangling pointer)
•arr + 1 points to arr[1]; &arr + 1 points past the entire array
•void f(int arr[100]) does NOT enforce the size -- arr is still just a pointer

Array names decay to pointers to the first element in most contexts. Exceptions: sizeof(arr), &arr, and string literal initialization. In function parameters, int arr[] is just int *ptr. Size information is lost after decay.

•Array decays to pointer in most contexts
•sizeof, &, and string init are the exceptions

#include <stdio.h>
void f(int arr[]) { /* arr is just int* here */
    printf("%zu\n", sizeof(arr)); /* pointer size (8) */
}
int main(void) {
    int arr[5] = {0};
    printf("%zu\n", sizeof(arr)); /* 20 (array size) */
    f(arr); /* decay happens here */
    return 0;
}

20
8

void f(int arr[100]) -- the 100 is ignored; arr is just a pointer

Question 4 / 15

What is the difference between string literals and char arrays?

String literal: "hello" is stored in read-only memory. A pointer to it (char *s = "hello") points to this read-only data. Modifying it is undefined behavior.

Char array: char s[] = "hello" copies the string into a stack-allocated (or global) array. You CAN modify this copy.

Key differences:

Feature	`char *s = "hello"`	`char s[] = "hello"`
Storage	pointer to read-only	array on stack
Modifiable	NO (UB)	YES
sizeof(s)	pointer size (8)	6 (5 chars + null)
Reassignable	YES (s = "world")	NO (array name)

Pseudo Code

char *s = "hello";    // pointer to read-only string literal
char s[] = "hello";   // array initialized with copy of string

Pointer version: s points to read-only memory, s is reassignable
Array version: s IS the memory, s is modifiable, s is not reassignable

Modifying a string literal = undefined behavior
Modifying a char array = perfectly fine

Code

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

int main(void) {
    /* String literal: pointer to read-only memory */
    const char *literal = "hello";  /* use const for safety */
    printf("%s, sizeof(literal)=%zu\n", literal, sizeof(literal)); /* 8 (ptr) */
    /* literal[0] = 'H';  // UB! Do NOT modify string literals */

    /* Char array: modifiable copy */
    char array[] = "hello";
    printf("%s, sizeof(array)=%zu\n", array, sizeof(array)); /* 6 (5+null) */
    array[0] = 'H';  /* OK -- this is a modifiable copy */
    printf("Modified: %s\n", array); /* Hello */

    /* Pointer can be reassigned; array cannot */
    literal = "world";  /* OK -- pointer now points elsewhere */
    /* array = "world";  // ERROR: array name is not assignable */

    /* String literals may be shared by the compiler */
    const char *s1 = "hello";
    const char *s2 = "hello";
    printf("Same address? %d\n", s1 == s2); /* may be 1 (shared) */

    /* Array is always a unique copy */
    char a1[] = "hello";
    char a2[] = "hello";
    printf("Same address? %d\n", a1 == a2); /* always 0 (different) */

    return 0;
}

hello, sizeof(literal)=8
hello, sizeof(array)=6
Modified: Hello
Same address? 1
Same address? 0

Key Points

•String literals are read-only; char arrays are modifiable
•char *s = "..." is a pointer to read-only data; char s[] = "..." is a copy
•sizeof(char*) is pointer size; sizeof(char[]) includes null terminator
•Always use const char * for string literal pointers
•Two identical string literals may share the same memory (compiler optimization)

Gotchas

•Modifying a string literal (char *s = "hi"; s[0] = 'H';) is undefined behavior
•char *s = "hello" should be const char *s = "hello" for safety
•sizeof("hello") is 6 (includes null), strlen("hello") is 5 (excludes null)
•String literals persist for the entire program lifetime; stack arrays do not

char *s = "hello" points to read-only memory. char s[] = "hello" is a modifiable copy. Modifying a string literal is UB. Use const char * for literal pointers.

•Literal = read-only; array = modifiable copy
•Use const char * for string literals

#include <stdio.h>
int main(void) {
    const char *lit = "hello"; /* read-only */
    char arr[] = "hello";     /* modifiable copy */
    arr[0] = 'H';
    printf("%s %s\n", lit, arr); /* hello Hello */
    return 0;
}

hello Hello

Modifying a string literal is undefined behavior

Question 5 / 15

Why is the null terminator important in C strings?

C strings are simply arrays of char terminated by a null byte ('\0', value 0). There is no length metadata stored with the string. Every string function relies on finding '\0' to know where the string ends.

Why it matters:

strlen() counts characters until it finds '\0'.
printf("%s") prints until '\0'.
Missing null terminator: functions read past the array into unknown memory -- undefined behavior, potential security vulnerability.

The null terminator takes space: "hello" requires 6 bytes (5 characters + '\0'). A buffer for an N-character string must be at least N+1 bytes.

'\0' vs NULL vs 0:

'\0' = character with value 0 (null terminator).
NULL = null pointer constant.
0 = integer zero. All have value 0, but they are used in different contexts.

Pseudo Code

"hello" in memory: ['h', 'e', 'l', 'l', 'o', '\0']
                    0     1    2    3    4     5

strlen("hello") = 5 (does not count '\0')
sizeof("hello") = 6 (includes '\0')

Buffer for N-char string needs N+1 bytes
Missing '\0' -> strlen/printf read past the array (UB)

Code

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

int main(void) {
    /* Null terminator included automatically */
    char s[] = "hello";
    printf("strlen = %zu\n", strlen(s));  /* 5 */
    printf("sizeof = %zu\n", sizeof(s));  /* 6 */
    printf("last byte = %d\n", s[5]);     /* 0 (null terminator) */

    /* Manual string construction -- must add null terminator! */
    char manual[6];
    manual[0] = 'h';
    manual[1] = 'e';
    manual[2] = 'l';
    manual[3] = 'l';
    manual[4] = 'o';
    manual[5] = '\0';  /* CRITICAL: without this, strlen etc. are UB */
    printf("manual: %s\n", manual); /* hello */

    /* What happens without null terminator */
    char bad[5] = {'h', 'e', 'l', 'l', 'o'}; /* NO null terminator */
    printf("strlen = %zu\n", strlen(bad)); /* UNDEFINED: reads past array */
    /* May print garbage after "hello", may crash */

    /* Buffer sizing: always +1 for null terminator */
    char buf[11]; /* can hold 10 chars + null */
    strncpy(buf, "0123456789", sizeof(buf) - 1);
    buf[sizeof(buf) - 1] = '\0'; /* ensure termination */
    printf("%s\n", buf);

    return 0;
}

strlen = 5
sizeof = 6
last byte = 0
manual: hello
strlen = 11
0123456789

Key Points

•C strings are null-terminated: '\0' marks the end
•strlen counts chars before '\0'; sizeof includes it
•Buffer for N chars needs N+1 bytes
•Missing null terminator causes undefined behavior
•Always ensure null termination after manual string operations

Gotchas

•char s[5] = "hello" has no room for null terminator -- s is NOT a valid string
•strncpy does NOT guarantee null termination if source >= n chars
•memset(buf, 0, sizeof(buf)) is a safe way to ensure null termination
•String functions can read/write past the buffer if null terminator is missing

C strings end with '\0'. All string functions depend on it. Missing null terminator = UB. Buffer for N chars needs N+1 bytes. strlen excludes it; sizeof includes it.

•Null terminator marks end of string
•Buffer needs N+1 bytes for N-char string

#include <stdio.h>
#include <string.h>
int main(void) {
    char s[] = "hello"; /* {'h','e','l','l','o','\0'} */
    printf("len=%zu size=%zu\n", strlen(s), sizeof(s)); /* 5, 6 */
    return 0;
}

len=5 size=6

strncpy may not null-terminate -- always add '\0' manually

Question 6 / 15

How do the key string.h functions work (strlen, strcpy, strncpy, strcat, strcmp, strstr)?

The <string.h> library provides essential string manipulation functions:

strlen(s) -- returns length (chars before '\0'). O(n).

strcpy(dst, src) -- copies src to dst including '\0'. No bounds checking. Buffer overflow risk.

strncpy(dst, src, n) -- copies at most n chars. If src < n, pads with zeros. If src >= n, does NOT null-terminate!

strcat(dst, src) -- appends src to end of dst. dst must have enough space.

strcmp(s1, s2) -- compares lexicographically. Returns <0, 0, or >0. Use this, not == for strings.

strstr(haystack, needle) -- finds first occurrence of needle in haystack. Returns pointer or NULL.

Pseudo Code

strlen(s)           -> count chars before '\0'
strcpy(dst, src)    -> copy src into dst (including '\0')
strncpy(dst, src, n) -> copy up to n chars (may NOT null-terminate!)
strcat(dst, src)    -> append src to dst
strcmp(s1, s2)      -> <0 if s1<s2, 0 if equal, >0 if s1>s2
strstr(hay, needle) -> pointer to first occurrence, or NULL

Code

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

int main(void) {
    /* strlen */
    printf("strlen(\"hello\") = %zu\n", strlen("hello")); /* 5 */

    /* strcpy */
    char buf[20];
    strcpy(buf, "hello");
    printf("strcpy: %s\n", buf); /* hello */

    /* strncpy -- CAUTION: may not null-terminate */
    char safe[6];
    strncpy(safe, "hello world", sizeof(safe) - 1);
    safe[sizeof(safe) - 1] = '\0'; /* always null-terminate */
    printf("strncpy: %s\n", safe); /* hello */

    /* strcat */
    char greeting[30] = "Hello";
    strcat(greeting, ", ");
    strcat(greeting, "World!");
    printf("strcat: %s\n", greeting); /* Hello, World! */

    /* strcmp */
    printf("strcmp(\"abc\",\"abd\") = %d\n", strcmp("abc", "abd")); /* < 0 */
    printf("strcmp(\"abc\",\"abc\") = %d\n", strcmp("abc", "abc")); /* 0 */
    printf("strcmp(\"abd\",\"abc\") = %d\n", strcmp("abd", "abc")); /* > 0 */

    /* strstr */
    const char *text = "Hello, World!";
    const char *found = strstr(text, "World");
    if (found) {
        printf("Found at offset %td\n", found - text); /* 7 */
    }

    /* strstr not found */
    if (strstr(text, "xyz") == NULL) {
        printf("'xyz' not found\n");
    }

    return 0;
}

strlen("hello") = 5
strcpy: hello
strncpy: hello
strcat: Hello, World!
strcmp("abc","abd") = -1
strcmp("abc","abc") = 0
strcmp("abd","abc") = 1
Found at offset 7
'xyz' not found

Key Points

•Use strcmp() for string comparison, NEVER == (that compares pointers)
•strcpy has no bounds checking -- prefer strncpy or snprintf
•strncpy may NOT null-terminate -- always add '\0' manually
•strlen is O(n) -- cache the result in loops
•strstr returns NULL if not found

Gotchas

•s1 == s2 compares pointer addresses, not string contents -- always use strcmp()
•strncpy does NOT null-terminate if source length >= n -- a major pitfall
•strcpy/strcat with insufficient buffer space cause buffer overflow (security vulnerability)
•strlen does NOT count the null terminator

strlen = length. strcpy = copy (unsafe). strncpy = bounded copy (may not null-terminate!). strcat = append. strcmp = compare (use instead of ==). strstr = find substring.

•Use strcmp, not == for string comparison
•strncpy may not null-terminate

#include <stdio.h>
#include <string.h>
int main(void) {
    char buf[20];
    strcpy(buf, "hello");
    strcat(buf, " world");
    printf("%s (len=%zu)\n", buf, strlen(buf)); /* hello world (len=11) */
    printf("cmp=%d\n", strcmp("abc", "abc")); /* 0 */
    return 0;
}

hello world (len=11)
cmp=0

== compares pointers, not string content

Question 7 / 15

What are buffer overflow risks with string functions?

Buffer overflow occurs when a program writes data beyond the bounds of a buffer. In C, this is undefined behavior and a major security vulnerability.

Dangerous functions:

gets() -- reads a line with NO length limit. REMOVED in C11. Never use it.
strcpy() -- no bounds checking.
strcat() -- no bounds checking.
sprintf() -- no output limit.
scanf("%s") -- no input limit.

Safe alternatives:

fgets(buf, size, stdin) -- limits input to size - 1 characters.
strncpy(dst, src, n) + manual null termination.
snprintf(buf, size, fmt, ...) -- limits output.
strncat(dst, src, n) -- limits append.

Why it matters: Buffer overflows can overwrite return addresses on the stack, enabling attackers to execute arbitrary code (stack smashing).

Pseudo Code

DANGEROUS:                    SAFE:
gets(buf)                  -> fgets(buf, size, stdin)
strcpy(dst, src)           -> strncpy(dst, src, size); dst[size-1]='\0'
sprintf(buf, fmt, ...)     -> snprintf(buf, size, fmt, ...)
scanf("%s", buf)           -> scanf("%99s", buf)  // limit width
strcat(dst, src)           -> strncat(dst, src, remaining_space)

Code

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

int main(void) {
    char buf[10];

    /* DANGEROUS: strcpy with no bounds check */
    /* strcpy(buf, "this is way too long for buf"); // buffer overflow! */

    /* SAFE: strncpy with manual null termination */
    strncpy(buf, "this is way too long", sizeof(buf) - 1);
    buf[sizeof(buf) - 1] = '\0';
    printf("strncpy: '%s'\n", buf); /* 'this is w' */

    /* SAFE: snprintf limits output */
    snprintf(buf, sizeof(buf), "%s %s", "hello", "world");
    printf("snprintf: '%s'\n", buf); /* 'hello wor' */

    /* DANGEROUS: gets() -- NEVER use */
    /* char line[10];
       gets(line);  // removed in C11, can overflow */

    /* SAFE: fgets limits input */
    printf("Enter text: ");
    /* fgets(buf, sizeof(buf), stdin); */
    /* fgets reads at most sizeof(buf)-1 chars and null-terminates */

    /* SAFE: scanf with width specifier */
    /* scanf("%9s", buf);  // reads at most 9 chars */

    /* DANGEROUS: sprintf */
    /* sprintf(buf, "%d + %d = %d", 100000, 200000, 300000); // overflow! */

    /* SAFE: snprintf */
    int written = snprintf(buf, sizeof(buf), "%d", 123456789);
    printf("snprintf: '%s' (would need %d chars)\n", buf, written);

    return 0;
}

strncpy: 'this is w'
snprintf: 'hello wor'
Enter text: snprintf: '123456789' (would need 9 chars)

Key Points

•Never use gets() -- it was removed from C11 for a reason
•Use fgets() instead of gets() for safe input
•Use snprintf() instead of sprintf() for safe formatting
•Always pass buffer size to string functions
•Buffer overflows are the #1 security vulnerability in C programs

Gotchas

•gets() has NO way to prevent buffer overflow -- it must never be used
•strncpy does not null-terminate if source >= n characters
•snprintf returns the number of chars that WOULD have been written, not what was written
•fgets() includes the newline character in the buffer -- strip it if needed

Never use gets(), unbounded strcpy, sprintf, or scanf("%s"). Use fgets, strncpy+null-terminate, snprintf, and scanf("%Ns") instead. Buffer overflow = security vulnerability.

•Never use gets(); use fgets() instead
•snprintf is the safe sprintf

#include <stdio.h>
#include <string.h>
int main(void) {
    char buf[10];
    /* SAFE */
    snprintf(buf, sizeof(buf), "%s", "hello world");
    printf("'%s'\n", buf); /* 'hello wor' */
    return 0;
}

'hello wor'

gets() was removed from C11 -- it has no safe usage

Question 8 / 15

What is the difference between gets() and fgets()?

gets(buf): Reads a line from stdin into buf with NO size limit. Cannot prevent buffer overflow. Was deprecated in C99 and removed entirely in C11. Never use it.

fgets(buf, size, stream): Reads at most size - 1 characters from stream into buf. Always null-terminates. Stops at newline (which IS included in the buffer) or EOF.

Key differences:

gets() does not know the buffer size -- inherently unsafe.
fgets() requires the buffer size -- safe by design.
fgets() retains the newline character; gets() strips it.
fgets() works with any FILE* (stdin, files); gets() only works with stdin.

Pseudo Code

gets(buf):              // NEVER USE
  - No size limit
  - Strips newline
  - Only stdin
  - REMOVED in C11

fgets(buf, size, stream):  // ALWAYS USE
  - Reads at most size-1 chars
  - Always null-terminates
  - Keeps newline in buffer
  - Works with any FILE*

Code

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

void strip_newline(char *s) {
    size_t len = strlen(s);
    if (len > 0 && s[len - 1] == '\n') {
        s[len - 1] = '\0';
    }
}

int main(void) {
    char buf[20];

    /* NEVER: gets(buf); -- removed in C11 */

    /* CORRECT: fgets with size limit */
    printf("Enter name: ");
    if (fgets(buf, sizeof(buf), stdin) != NULL) {
        strip_newline(buf);  /* remove trailing newline */
        printf("Hello, %s!\n", buf);
    }

    /* fgets returns NULL on EOF or error */
    /* Reading from file */
    FILE *fp = fopen("/dev/null", "r");
    if (fp) {
        if (fgets(buf, sizeof(buf), fp) == NULL) {
            printf("EOF or error\n");
        }
        fclose(fp);
    }

    return 0;
}

Enter name: EOF or error

Key Points

•Never use gets() -- it was removed from C11
•fgets() limits input to size-1 characters and null-terminates
•fgets() keeps the newline -- strip it manually if needed
•fgets() returns NULL on EOF or error
•fgets() works with any FILE*, not just stdin

Gotchas

•fgets() includes the newline in the buffer -- often need to strip it
•If input exceeds size-1, fgets() leaves the rest in the input buffer for the next read
•fgets() returns NULL on EOF AND on error -- check ferror() to distinguish
•gets() cannot be made safe -- there is no version with a size parameter

gets() reads with no limit (removed in C11). fgets(buf, size, stdin) reads at most size-1 chars and null-terminates. fgets keeps the newline. Always use fgets.

•Always fgets, never gets
•strcspn trick to strip newline

#include <stdio.h>
#include <string.h>
int main(void) {
    char buf[20];
    if (fgets(buf, sizeof(buf), stdin)) {
        buf[strcspn(buf, "\n")] = '\0'; /* strip newline */
        printf("Got: '%s'\n", buf);
    }
    return 0;
}

/* Expected Output (stdin: "hello"):
Got: 'hello'
*/

fgets keeps the newline character in the buffer

Question 9 / 15

How do you reverse a string in C?

String reversal is a classic interview problem. The most efficient approach is in-place reversal using two pointers (or indices) that start at opposite ends and swap characters moving inward.

Algorithm:

Set left = 0 and right = strlen(s) - 1.
While left < right: swap s[left] and s[right], increment left, decrement right.
Time: O(n), Space: O(1).

Important: You can only reverse modifiable strings (char arrays), NOT string literals.

Pseudo Code

1. left = 0, right = len - 1
2. while (left < right):
     swap(s[left], s[right])
     left++
     right--
3. Time: O(n), Space: O(1)
4. String must be modifiable (char array, not literal)

Code

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

void reverse_string(char *s) {
    int left = 0;
    int right = (int)strlen(s) - 1;
    while (left < right) {
        char temp = s[left];
        s[left] = s[right];
        s[right] = temp;
        left++;
        right--;
    }
}

/* Recursive version */
void reverse_recursive(char *s, int left, int right) {
    if (left >= right) return;
    char temp = s[left];
    s[left] = s[right];
    s[right] = temp;
    reverse_recursive(s, left + 1, right - 1);
}

int main(void) {
    char s1[] = "hello";
    reverse_string(s1);
    printf("%s\n", s1); /* olleh */

    char s2[] = "abcdef";
    reverse_recursive(s2, 0, (int)strlen(s2) - 1);
    printf("%s\n", s2); /* fedcba */

    char s3[] = "a";
    reverse_string(s3);
    printf("%s\n", s3); /* a (single char) */

    char s4[] = "";
    reverse_string(s4);
    printf("'%s'\n", s4); /* '' (empty string) */

    return 0;
}

olleh
fedcba
a
''

Key Points

•Two-pointer swap from ends toward middle: O(n) time, O(1) space
•Works for empty strings and single characters
•Must use a modifiable char array, not a string literal
•The recursive version uses O(n) stack space
•Can also use XOR swap: a^=b; b^=a; a^=b; (but less readable)

Gotchas

•Cannot reverse a string literal: char *s = "hello"; reverse(s); is UB
•strlen returns size_t (unsigned); casting to int avoids issues with empty strings
•For UTF-8 multi-byte characters, byte-level reversal corrupts the string
•XOR swap fails if both pointers point to the same location

Swap characters from both ends moving inward. O(n) time, O(1) space. Use char array (not literal). Two-pointer approach with left/right indices.

•Two pointers, swap from ends
•O(n) time, O(1) space

#include <stdio.h>
#include <string.h>
void reverse(char *s) {
    int l = 0, r = (int)strlen(s) - 1;
    while (l < r) {
        char t = s[l]; s[l] = s[r]; s[r] = t;
        l++; r--;
    }
}
int main(void) {
    char s[] = "hello";
    reverse(s);
    printf("%s\n", s); /* olleh */
    return 0;
}

olleh

Cannot reverse a string literal (read-only memory)

Question 10 / 15

How do you check if a string is a palindrome?

A palindrome reads the same forwards and backwards (e.g., "racecar", "madam").

Algorithm:

Compare characters from both ends moving inward.
If any pair differs, it is not a palindrome.
If all pairs match (or pointers cross), it is a palindrome.

Variations:

Case-insensitive: convert to lowercase before comparing.
Ignore non-alphanumeric characters: skip spaces, punctuation.
Recursive approach: compare first and last, then check inner substring.

Pseudo Code

1. left = 0, right = len - 1
2. while (left < right):
     if s[left] != s[right]: return false
     left++, right--
3. return true

For case-insensitive: use tolower()
For ignoring non-alpha: skip with isalnum()

Code

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

/* Basic palindrome check */
int is_palindrome(const char *s) {
    int left = 0;
    int right = (int)strlen(s) - 1;
    while (left < right) {
        if (s[left] != s[right]) return 0;
        left++;
        right--;
    }
    return 1;
}

/* Case-insensitive, ignoring non-alphanumeric */
int is_palindrome_smart(const char *s) {
    int left = 0;
    int right = (int)strlen(s) - 1;
    while (left < right) {
        while (left < right && !isalnum(s[left])) left++;
        while (left < right && !isalnum(s[right])) right--;
        if (tolower(s[left]) != tolower(s[right])) return 0;
        left++;
        right--;
    }
    return 1;
}

int main(void) {
    printf("racecar: %d\n", is_palindrome("racecar"));     /* 1 */
    printf("hello:   %d\n", is_palindrome("hello"));       /* 0 */
    printf("a:       %d\n", is_palindrome("a"));           /* 1 */
    printf("empty:   %d\n", is_palindrome(""));            /* 1 */

    /* Smart check */
    printf("'A man, a plan, a canal: Panama': %d\n",
           is_palindrome_smart("A man, a plan, a canal: Panama")); /* 1 */
    printf("'race a car': %d\n",
           is_palindrome_smart("race a car")); /* 0 */

    return 0;
}

racecar: 1
hello:   0
a:       1
empty:   1
'A man, a plan, a canal: Panama': 1
'race a car': 0

Key Points

•Compare from both ends moving inward: O(n) time, O(1) space
•Empty string and single character are palindromes
•For smart check: skip non-alphanumeric and use tolower()
•Two-pointer technique is the standard approach
•No extra memory needed (unlike creating a reversed copy)

Gotchas

•Be careful with unsigned strlen return when string is empty (0 - 1 wraps)
•tolower() takes int, not char -- pass (unsigned char) for safety with non-ASCII
•Don't forget to handle the empty string case
•Creating a reversed copy and comparing with strcmp works but wastes O(n) space

Compare characters from both ends moving inward. If all pairs match, it is a palindrome. For case-insensitive: tolower(). For ignoring spaces: isalnum(). O(n) time, O(1) space.

•Two pointers from ends, O(n) time
•Empty string = palindrome

#include <stdio.h>
#include <string.h>
int is_palindrome(const char *s) {
    int l = 0, r = (int)strlen(s) - 1;
    while (l < r) {
        if (s[l++] != s[r--]) return 0;
    }
    return 1;
}
int main(void) {
    printf("%d\n", is_palindrome("racecar")); /* 1 */
    printf("%d\n", is_palindrome("hello"));   /* 0 */
    return 0;
}

1
0

Cast strlen to int to avoid underflow with empty strings

Question 11 / 15

How do character classification functions work (ctype.h)?

The <ctype.h> header provides functions to classify and convert individual characters.

Classification functions (return non-zero for true):

isalpha(c) -- is a letter (A-Z, a-z)
isdigit(c) -- is a digit (0-9)
isalnum(c) -- is letter or digit
isspace(c) -- is whitespace (space, tab, newline, etc.)
isupper(c) / islower(c) -- is uppercase/lowercase letter
isprint(c) -- is printable (including space)
ispunct(c) -- is punctuation

Conversion functions:

toupper(c) -- convert to uppercase (returns unchanged if not lowercase)
tolower(c) -- convert to lowercase (returns unchanged if not uppercase)

All functions take int, not char. The argument must be representable as unsigned char or be EOF. Passing a negative char value is undefined behavior on some implementations.

Pseudo Code

isalpha('A') -> true    isdigit('5') -> true
isspace(' ') -> true    isalnum('x') -> true
isupper('A') -> true    islower('a') -> true
toupper('a') -> 'A'     tolower('A') -> 'a'

All take int, must be in range [0, 255] or EOF
Cast char to unsigned char before passing

Code

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

int main(void) {
    /* Classification */
    printf("isalpha('A') = %d\n", isalpha('A') != 0);  /* 1 */
    printf("isdigit('5') = %d\n", isdigit('5') != 0);  /* 1 */
    printf("isspace(' ') = %d\n", isspace(' ') != 0);  /* 1 */
    printf("isalnum('_') = %d\n", isalnum('_') != 0);  /* 0 */

    /* Conversion */
    printf("toupper('a') = %c\n", toupper('a'));  /* A */
    printf("tolower('Z') = %c\n", tolower('Z'));  /* z */
    printf("toupper('1') = %c\n", toupper('1'));  /* 1 (unchanged) */

    /* Practical: count types in a string */
    const char *s = "Hello, World! 123";
    int letters = 0, digits = 0, spaces = 0, others = 0;
    for (int i = 0; s[i]; i++) {
        unsigned char c = (unsigned char)s[i];
        if (isalpha(c)) letters++;
        else if (isdigit(c)) digits++;
        else if (isspace(c)) spaces++;
        else others++;
    }
    printf("letters=%d digits=%d spaces=%d others=%d\n",
           letters, digits, spaces, others);
    /* letters=10 digits=3 spaces=2 others=2 */

    /* Convert string to uppercase */
    char buf[] = "Hello World";
    for (int i = 0; buf[i]; i++) {
        buf[i] = (char)toupper((unsigned char)buf[i]);
    }
    printf("%s\n", buf); /* HELLO WORLD */

    return 0;
}

isalpha('A') = 1
isdigit('5') = 1
isspace(' ') = 1
isalnum('_') = 0
toupper('a') = A
tolower('Z') = z
toupper('1') = 1
letters=10 digits=3 spaces=2 others=2
HELLO WORLD

Key Points

•ctype.h functions classify single characters
•All return int: non-zero for true, 0 for false
•toupper/tolower return the converted character unchanged if not applicable
•Always cast to unsigned char before passing to ctype functions
•These are locale-dependent in the default C locale they cover ASCII

Gotchas

•Passing a signed char with value > 127 to ctype functions is UB -- cast to unsigned char first
•isdigit('0') is true but isdigit(0) is false (0 is the NUL character, not the digit '0')
•toupper/tolower return int, not char
•These functions are locale-dependent -- behavior may differ with setlocale()

<ctype.h>: isalpha, isdigit, isalnum, isspace, toupper, tolower. All take int. Cast char to unsigned char before passing. Non-zero = true.

•Cast to unsigned char before ctype functions
•toupper/tolower leave non-letters unchanged

#include <stdio.h>
#include <ctype.h>
int main(void) {
    char s[] = "Hello 123";
    for (int i = 0; s[i]; i++)
        s[i] = (char)toupper((unsigned char)s[i]);
    printf("%s\n", s); /* HELLO 123 */
    return 0;
}

HELLO 123

Signed char > 127 causes UB in ctype functions

Question 12 / 15

How do you create an array of strings in C?

There are two common ways to create an array of strings in C:

1. Array of pointers (most common):

const char *names[] = {"Alice", "Bob", "Charlie"};

Each element is a pointer to a string literal. Different strings can have different lengths. Strings are read-only (string literals).

2. 2D char array:

char names[3][20] = {"Alice", "Bob", "Charlie"};

Each row is a fixed-size char buffer. Strings are modifiable. All rows have the same fixed size (wastes space for short strings).

Comparison:

Pointer array: flexible lengths, read-only (unless pointing to modifiable buffers).
2D array: fixed row size, modifiable, contiguous memory.

Pseudo Code

Method 1: Array of pointers
  const char *arr[] = {"hello", "world"};  // flexible, read-only
  arr[0] = "new";  // OK (reassign pointer)
  arr[0][0] = 'N';  // UB (string literal is read-only)

Method 2: 2D char array
  char arr[2][10] = {"hello", "world"};   // fixed size, modifiable
  arr[0][0] = 'H';  // OK (modifiable copy)
  arr[0] = "new";   // ERROR (array not assignable)

Code

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

int main(void) {
    /* Method 1: Array of pointers to string literals */
    const char *fruits[] = {"Apple", "Banana", "Cherry", "Date"};
    int n = sizeof(fruits) / sizeof(fruits[0]);
    for (int i = 0; i < n; i++) {
        printf("%s\n", fruits[i]);
    }

    /* Method 2: 2D char array (modifiable) */
    char names[3][20] = {"Alice", "Bob", "Charlie"};
    names[1][0] = 'R';  /* Modify: Bob -> Rob */
    strcpy(names[2], "Dave");  /* Replace string */
    for (int i = 0; i < 3; i++) {
        printf("%s\n", names[i]);
    }

    /* Sorting an array of string pointers */
    const char *words[] = {"banana", "apple", "cherry"};
    int wn = 3;
    for (int i = 0; i < wn - 1; i++) {
        for (int j = i + 1; j < wn; j++) {
            if (strcmp(words[i], words[j]) > 0) {
                const char *temp = words[i];
                words[i] = words[j];
                words[j] = temp;
            }
        }
    }
    for (int i = 0; i < wn; i++) printf("%s ", words[i]);
    printf("\n"); /* apple banana cherry */

    return 0;
}

Apple
Banana
Cherry
Date
Alice
Rob
Dave
apple banana cherry

Key Points

•const char *arr[] for read-only string array (most common)
•char arr[N][M] for modifiable strings with fixed max length
•Pointer array is more memory-efficient for variable-length strings
•Sorting pointer arrays just swaps pointers (fast)
•2D array wastes space if strings have very different lengths

Gotchas

•const char *arr[] elements point to read-only literals -- cannot modify characters
•char arr[3][10] wastes 10 bytes per row even for short strings
•sizeof(arr)/sizeof(arr[0]) gives the count for both methods
•Sorting a 2D char array requires copying entire strings (slow); sorting pointers is O(1) per swap

const char *arr[] = array of pointers to string literals (flexible, read-only). char arr[N][M] = 2D char array (fixed size, modifiable). Pointer arrays are more common.

•const char *arr[] for string literal arrays
•char arr[N][M] for modifiable string arrays

#include <stdio.h>
int main(void) {
    const char *fruits[] = {"Apple", "Banana", "Cherry"};
    for (int i = 0; i < 3; i++) printf("%s\n", fruits[i]);
    char names[2][10] = {"Alice", "Bob"};
    names[0][0] = 'a'; /* modifiable */
    printf("%s\n", names[0]); /* alice */
    return 0;
}

Apple
Banana
Cherry
alice

Cannot modify characters through const char * pointers

Question 13 / 15

What are Variable Length Arrays (VLAs) in C99?

Variable Length Arrays (VLAs) were introduced in C99 and allow array sizes to be determined at runtime (using a variable, not just a constant).

Syntax: int arr[n]; where n is a variable.

Key facts:

Allocated on the stack (not the heap).
Size determined at runtime but cannot be changed after creation.
Made optional in C11 (compiler can choose not to support them).
NOT available in C89 or C++.

Advantages:

Convenient for small, temporary arrays with runtime-known sizes.
No need for malloc/free.

Disadvantages:

Allocated on the stack: risk of stack overflow for large sizes.
No way to check if allocation succeeded (unlike malloc which returns NULL).
Performance: may require runtime stack adjustments.
Controversial: some style guides forbid them (e.g., Linux kernel).

Pseudo Code

int n = get_size();
int arr[n];           // VLA: size determined at runtime

Allocated on stack (not heap)
Cannot resize after creation
Optional in C11
Not available in C89 or C++
Risk: no way to detect allocation failure

Code

#include <stdio.h>

void print_table(int rows, int cols) {
    /* VLA: size determined at runtime */
    int table[rows][cols];

    /* Initialize */
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            table[i][j] = i * cols + j;
        }
    }

    /* Print */
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%4d", table[i][j]);
        }
        printf("\n");
    }
}

int main(void) {
    int n = 5;
    int arr[n];  /* VLA */

    for (int i = 0; i < n; i++) {
        arr[i] = i * i;
    }
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n"); /* 0 1 4 9 16 */

    /* VLA for 2D array with runtime dimensions */
    print_table(3, 4);

    /* sizeof VLA is evaluated at runtime */
    printf("sizeof(arr) = %zu\n", sizeof(arr)); /* 20 */

    return 0;
}

0 1 4 9 16 
   0   1   2   3
   4   5   6   7
   8   9  10  11
sizeof(arr) = 20

Key Points

•VLA size is determined at runtime, allocated on the stack
•Introduced in C99, made optional in C11
•sizeof(VLA) is evaluated at runtime, not compile time
•Cannot be initialized with {} syntax (only regular arrays can)
•Useful for small temporary arrays with runtime-known sizes

Gotchas

•VLAs can cause stack overflow with large sizes -- no failure detection
•Not supported by all compilers (MSVC does not support VLAs)
•Cannot be used at file scope (only in function scope)
•The Linux kernel bans VLAs due to stack overflow risk and unpredictable stack usage

VLAs (C99) allow runtime-sized arrays: int arr[n]. Allocated on stack, no resize, no failure detection. Optional in C11. Risky for large sizes. Use malloc for large/unknown sizes.

•Runtime-sized stack allocation
•Optional in C11; banned in Linux kernel

#include <stdio.h>
int main(void) {
    int n = 5;
    int arr[n]; /* VLA: runtime size */
    for (int i = 0; i < n; i++) arr[i] = i * i;
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n"); /* 0 1 4 9 16 */
    return 0;
}

0 1 4 9 16

No way to detect allocation failure (unlike malloc)

Question 14 / 15

How do you determine the size of an array in C?

The standard idiom: sizeof(arr) / sizeof(arr[0]) gives the number of elements.

Why it works: sizeof(arr) gives the total byte size of the array; sizeof(arr[0]) gives the byte size of one element. The division gives the element count.

When it does NOT work:

When the array has decayed to a pointer (e.g., inside a function parameter). sizeof(pointer) / sizeof(pointer[0]) gives pointer_size / element_size, which is wrong.
For dynamically allocated arrays (malloc'd memory).

Best practice: Define a macro:

#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))

Safer macro (GCC/Clang): Use __builtin_types_compatible_p to trigger a compile error if used on a pointer instead of an array.

Pseudo Code

Element count = sizeof(arr) / sizeof(arr[0])

Works for: actual arrays in the same scope
Fails for: pointers, function parameters, malloc'd memory

Macro: #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))

Code

#include <stdio.h>

#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))

/* This does NOT work -- arr has decayed to a pointer */
void bad_print(int arr[]) {
    /* sizeof(arr) is sizeof(int*), NOT the array size */
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("bad count: %d\n", n); /* likely 2 on 64-bit (8/4) */
}

/* Correct: pass the size separately */
void good_print(const int *arr, int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main(void) {
    int arr[] = {10, 20, 30, 40, 50};
    int n = ARRAY_SIZE(arr);
    printf("Element count: %d\n", n); /* 5 */

    bad_print(arr);       /* wrong count */
    good_print(arr, n);   /* correct: 10 20 30 40 50 */

    /* Works for any type */
    double d[] = {1.1, 2.2, 3.3};
    printf("doubles: %zu\n", ARRAY_SIZE(d)); /* 3 */

    char s[] = "hello";
    printf("chars (including null): %zu\n", ARRAY_SIZE(s)); /* 6 */

    return 0;
}

Element count: 5
bad count: 2
10 20 30 40 50 
doubles: 3
chars (including null): 6

Key Points

•sizeof(arr)/sizeof(arr[0]) gives element count for actual arrays
•Does NOT work after array decay (function parameters, pointers)
•Always pass array size as a separate parameter to functions
•Define an ARRAY_SIZE macro for convenience
•sizeof(string_array) includes the null terminator

Gotchas

•sizeof(arr) inside a function parameter gives pointer size, not array size
•This idiom fails silently for pointers -- it gives a wrong number without warning
•For dynamically allocated arrays (malloc), you must track the size yourself
•ARRAY_SIZE("hello") is 6 (includes null), not 5

sizeof(arr)/sizeof(arr[0]) gives element count. Only works for actual arrays in the same scope, NOT for pointers or function parameters. Always pass size as a separate parameter.

•sizeof(arr)/sizeof(arr[0]) for element count
•Fails after array decay to pointer

#include <stdio.h>
#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))
int main(void) {
    int arr[] = {1, 2, 3, 4, 5};
    printf("count = %zu\n", ARRAY_SIZE(arr)); /* 5 */
    return 0;
}

count = 5

Gives wrong answer for pointers -- no compile warning

Question 15 / 15

What are common string interview patterns in C?

Common C string interview problems and their patterns:

1. String reversal -- two-pointer swap from ends. 2. Palindrome check -- compare from both ends. 3. Anagram check -- count character frequencies. 4. Remove duplicates -- use a hash/frequency array. 5. First non-repeating character -- count frequencies, then scan. 6. String to integer (atoi) -- handle sign, digits, overflow. 7. Substring search -- strstr() or KMP algorithm. 8. Word reversal -- reverse entire string, then reverse each word. 9. String compression -- "aabccc" -> "a2b1c3". 10. Check if one string is a rotation of another -- concatenate s1+s1 and search for s2.

Key techniques:

Use 256-element arrays for ASCII character counting.
Two-pointer technique for in-place operations.
strlen() is O(n) -- cache it before loops.

Pseudo Code

Pattern 1: Character counting (anagram, duplicates)
  int freq[256] = {0};
  for each char: freq[(unsigned char)c]++;

Pattern 2: Two pointers (reverse, palindrome)
  left = 0, right = len-1
  while (left < right): process and move inward

Pattern 3: atoi implementation
  handle whitespace, sign, digits, overflow

Code

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

/* Check if two strings are anagrams */
int are_anagrams(const char *s1, const char *s2) {
    int freq[256] = {0};
    for (int i = 0; s1[i]; i++) freq[(unsigned char)s1[i]]++;
    for (int i = 0; s2[i]; i++) freq[(unsigned char)s2[i]]--;
    for (int i = 0; i < 256; i++) {
        if (freq[i] != 0) return 0;
    }
    return 1;
}

/* Find first non-repeating character */
char first_unique(const char *s) {
    int freq[256] = {0};
    for (int i = 0; s[i]; i++) freq[(unsigned char)s[i]]++;
    for (int i = 0; s[i]; i++) {
        if (freq[(unsigned char)s[i]] == 1) return s[i];
    }
    return '\0'; /* all characters repeat */
}

/* Simple atoi implementation */
int my_atoi(const char *s) {
    int sign = 1, result = 0, i = 0;
    while (isspace((unsigned char)s[i])) i++;
    if (s[i] == '-' || s[i] == '+') {
        sign = (s[i] == '-') ? -1 : 1;
        i++;
    }
    while (isdigit((unsigned char)s[i])) {
        result = result * 10 + (s[i] - '0');
        i++;
    }
    return sign * result;
}

/* Check if s2 is a rotation of s1 */
int is_rotation(const char *s1, const char *s2) {
    size_t len = strlen(s1);
    if (len != strlen(s2)) return 0;
    char doubled[200];
    snprintf(doubled, sizeof(doubled), "%s%s", s1, s1);
    return strstr(doubled, s2) != NULL;
}

int main(void) {
    printf("anagram: %d\n", are_anagrams("listen", "silent")); /* 1 */
    printf("first unique in 'aabbc': %c\n", first_unique("aabbc")); /* c */
    printf("my_atoi('  -123') = %d\n", my_atoi("  -123")); /* -123 */
    printf("rotation: %d\n", is_rotation("abcde", "cdeab")); /* 1 */
    return 0;
}

anagram: 1
first unique in 'aabbc': c
my_atoi('  -123') = -123
rotation: 1

Key Points

•Character counting with int freq[256] = {0} for ASCII
•Two-pointer for in-place string operations
•Anagram = same character frequencies
•Rotation check: s1+s1 contains all rotations of s1
•atoi: skip whitespace, handle sign, extract digits

Gotchas

•Use unsigned char as array index to avoid negative indices
•my_atoi does not handle overflow -- production code needs strtol()
•Rotation check with concat needs buffer twice the string length + 1
•Character counting assumes ASCII; does not work for multibyte UTF-8

Key patterns: character counting with freq[256] for anagrams/duplicates, two-pointer for reversal/palindrome, concatenation for rotation check, digit extraction for atoi. Use unsigned char for array indices.

•int freq[256] for character counting
•Two-pointer for in-place operations

#include <stdio.h>
int are_anagrams(const char *a, const char *b) {
    int f[256] = {0};
    while (*a) f[(unsigned char)*a++]++;
    while (*b) f[(unsigned char)*b++]--;
    for (int i = 0; i < 256; i++) if (f[i]) return 0;
    return 1;
}
int main(void) {
    printf("%d\n", are_anagrams("listen", "silent")); /* 1 */
    return 0;
}

Cast char to unsigned char before using as array index

Built by onllm.dev

Home GitHub Support awesomePrep