Strings, in one page

Worked example 1

The in-class activity: palindrome checker

Given char word[20] = "level";, decide whether it reads the same forwards and backwards. Test on "level" and "lovelace".

1. Name the pattern. Card 8: pair box i with box len − 1 − i. And a flag (Lab 4): assume it's a palindrome, and try to disprove it.
2. Get the length. int len = strlen(word);. Use the text length (5), not the array size (20). With 20, the pairs would compare letters against the zero-filled tail.
3. Write it.

   #include <stdio.h>
   #include <string.h>
   
   int main(void) {
       char word[20] = "level";
       int len = strlen(word);
       int isPal = 1;                       /* assume yes, try to disprove */
       for (int i = 0; i < len / 2; i++) {
           if (word[i] != word[len - 1 - i]) {
               isPal = 0;
               break;
           }
       }
       if (isPal) printf("%s is a palindrome\n", word);
       else       printf("%s is not a palindrome\n", word);
       return 0;
   }

4. Trace "level" (len 5, so len / 2 = 2 and i takes the values 0 and 1):

   i	pair	compare	result
   0	(0, 4)	l vs l	match
   1	(1, 3)	e vs e	match
   —	loop ends; the middle v (box 2) has no partner and needs none. isPal is still 1.

   Output: level is a palindrome.
5. Trace "lovelace" (len 8, so i would run 0–3): i = 0 compares l (box 0) with e (box 7). That's a mismatch, so isPal = 0 and break, after one comparison. Output: lovelace is not a palindrome.
6. Edge cases an examiner likes. Even length has no middle: "abba" checks (0, 3) and (1, 2), and prints palindrome. Case matters: "Level" is not a palindrome to this code, because 'L' (76) ≠ 'l' (108). To ignore case, compare tolower(word[i]) != tolower(word[len - 1 - i]) (tested: "Level" then gives 1). State which you assume.

All four outputs (level, lovelace, Level, abba) are from the compiled program.

Worked example 2

Word count with the in-word flag, on messy spacing

Count the words in char s[] = " Ada wrote code ";. It has two leading spaces, double and triple gaps, and a trailing space.

1. Why the obvious idea fails. "Count the spaces and add 1" gives 8 spaces + 1 = 9. The answer is 3. Spaces aren't words, and runs of spaces confuse any count based on them.
2. Count word starts instead (card 9). A start is a non-space character that comes when inWord is 0.

   int wordCount = 0, inWord = 0;
   for (int i = 0; s[i] != '\0'; i++) {
       if (s[i] != ' ' && !inWord) {
           wordCount++;
           inWord = 1;
       } else if (s[i] == ' ') {
           inWord = 0;
       }
   }
   printf("%d\n", wordCount);

3. Trace (repeated rows grouped):

   i	s[i]	what happens	inWord	count
   0–1	␣ ␣	space, already outside	0	0
   2	A	word starts: count it	1	1
   3–4	d a	inside a word: neither branch runs	1	1
   5–6	␣ ␣	space: leave the word (the second space changes nothing)	0	1
   7	w	word starts	1	2
   8–11	r o t e	inside	1	2
   12–14	␣ ␣ ␣	space ×3	0	2
   15	c	word starts	1	3
   16–18	o d e	inside	1	3
   19	␣	space	0	3
   20	\0	loop test fails: stop		3

4. Answer: 3 (the compiled program prints 3). The lecture's sentence, "Ada Lovelace wrote the first algorithm", gives 6.
5. If the text came from fgets, it ends in '\n'. That's not a space, so it just counts as part of the last word and the answer is unchanged. But a line that is only "\n" would count as 1 word. Strip the newline first (card 4).

Worked example 3

Predict the output: strcat, strcpy, strlen, sizeof

char a[20] = "code";
char b[] = "C";
strcat(a, "!");
printf("%d %d\n", (int) strlen(a), (int) sizeof(a));
strcpy(a, b);
printf("%s %d %d\n", a, (int) strlen(a), (int) sizeof(b));
a[1] = 'S';
printf("%s\n", a);

1. Draw the boxes of a first. c o d e \0 0 0 … (20 boxes, zero-filled).
2. strcat(a, "!") writes ! over the 0 in box 4 and a new 0 in box 5: c o d e ! \0. So strlen(a) = 5. sizeof(a) is the whole array: 20. Line 1: 5 20.
3. strcpy(a, b) copies C and its 0 into boxes 0–1: C \0 d e ! \0. Boxes 2–5 still hold the old de! and its 0. %s prints C, strlen(a) = 1, and sizeof(b) = 2 (C plus its 0). Line 2: C 1 2.
4. a[1] = 'S' overwrites the 0 that ended the string, so %s walks on into the old text until the next 0 (box 5): C S d e !. Line 3: CSde!.
5. Output (compiled and run):

   5 20
   C 1 2
   CSde!

The lesson: strlen measures the text, sizeof measures the array, and old characters behind a 0 are still there.