C programming Language – Code snippets
C Programming Language, 2nd Edition
Compiling and running the sample codes using gcc :
This shell example compiles one saved C source file into an executable named sample, then runs it from the current directory. It is a workflow illustration, not a guarantee that every historical example below compiles unchanged with a modern compiler; inspect the individual caveats first.
gcc sample.c -o sample
./sampleChapter 3 - Control Flow
1. Trim whitespace
This whitespace exercise scans backward to remove trailing spaces, tabs and newlines by inserting a terminating zero byte. The later scan does not shift the text or select a new start pointer, so leading spaces remain despite the broad title. The missing ctype declaration is another modern-build issue to review.
#include<stdio.h>
#include<string.h>
int main()
{
int n,i=0;
char s[]=" HELLO THERE ";
printf("Before trim:%s\n",s);
for(n=strlen(s)-1; n>=0; n--)
if(s[n]!=' ' && s[n]!='\t' && s[n]!='\n') break;
s[n+1]='\0';
while(isspace(s[i++]));
i=0;
while(s[i]!='\0') s[i++];
s[i]='\0';
printf("After trim:%s\n",s);
return n;
}2. Binary search
This binary search repeatedly compares the target with the middle element and discards half the remaining interval. It requires an already sorted integer array. The preserved main examines arguments and constructs storage before fully validating the count, and uses atoi without its proper header, so input handling needs review.
#include<stdio.h>
int binsearch(int x, int v[], int n);
int main(int argc, char *argv[])
{
int size=argc,found;
int counter=0,x, v[size-2];
x=atoi(argv[size-1]);
if (argc<3) {printf("Usage: progname integer-list integer-to-be-searched\n"); return -1; }
while(counter <= size-3)
{ v[counter]=atoi(argv[counter+1]);
counter++; }
(found=binsearch(x,v,size-2))!=-1 ? printf("Found=%d\n",v[found]): printf("Not found\n");
return 0;
}
int binsearch(int x, int v[], int n)
{
int low, high, mid;
low=0;
high=n-1;
while(low<=high)
{
mid=(low+high)/2;
if(x < v[mid]) high=mid-1;
else if (x > v[mid]) low=mid+1;
else
return mid;
}
return -1;
}
3. Integer to string with argument parsing.
This integer-to-string routine extracts decimal remainders, appends a sign when needed and reverses the collected digits. main obtains the number from a command-line argument. The ten-byte output buffer is too small for every signed int representation on common systems, and negating the most negative int can overflow.
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define SIZE 10
void itoa(int n, char s[]);
void reverse(char s[]);
int main(int argc, char *argv[])
{
char s[SIZE];
int n;
if(argc!=2) { printf("Usage: progrname integer\n"); return -1; }
n=atoi(argv[1]);
itoa(n,s);
printf("String:%s\n",s);
return 0;
}
void itoa(int n, char s[])
{
int i, sign;
if((sign=n)<0) n=-n;
i=0;
do {
s[i++]=n%10 + '0';
} while( (n/=10)>0);
if (sign<0) s[i++]='-';
s[i]='\0';
reverse(s);
}
void reverse(char s[])
{
int c, i, j;
for(i=0,j=strlen(s)-1; i<j; i++,j--)
{
c=s[i]; s[i]=s[j]; s[j]=c;
}
}4. Reverse string and convert integer to string
This paired demonstration first reverses a sample string and then reuses reversal to finish an integer-to-string conversion. Swapping characters from opposite ends illustrates an in-place two-pointer algorithm. The conversion shares the usual fixed-buffer and minimum-integer caveats of this historical itoa implementation.
#include<stdio.h>
#include<string.h>
#define SIZE 1000
void reverse(char s[]);
void itoa(int n, char s[]);
int main()
{
char s[SIZE]="HELLO WORLD!!";
reverse(s);
printf("%s\n",s);
itoa(87690,s);
printf("%s\n",s);
return 0;
}
void reverse(char s[])
{
int c, i, j;
for(i=0,j=strlen(s)-1; i<j; i++,j--)
{
c=s[i]; s[i]=s[j]; s[j]=c;
}
}
void itoa(int n, char s[])
{
int i, sign;
if((sign=n)<0) n=-n;
i=0;
do {
s[i++] = n%10 + '0';
} while((n/=10)>0);
if(sign<0) s[i++] = '-';
s[i]='\0';
reverse(s);
}5. Command line argument parsing
This program prints the argument count and then walks each argument character by character, including the program name. Incrementing argv entries advances the stored pointers themselves, which makes the traversal easy to see but consumes their original positions. It demonstrates representation rather than a complete option parser.
#include<stdio.h>
int main(int argc, char *argv[])
{
int i,counter;
printf("Number of arguments:%d\n",argc);
printf("Arguments character-by-character\n");
for(counter=0;counter < argc ; counter++)
{ while(*argv[counter])
printf("%c ",*argv[counter]++);
printf("\n");
}
printf("\n");
return 0;
}
6. Reverse a string
This string reversal swaps the first and last characters, then moves both indexes inward until they meet. It modifies a writable character array in place and leaves the terminating zero byte at the end. It reverses bytes, so multi-byte Unicode characters require a different approach.
#include<stdio.h>
#include<string.h>
#define SIZE 1000
void reverse(char s[]);
int main()
{
char s[SIZE]="HELLO WORLD!";
reverse(s);
printf("%s\n",s);
return 0;
}
void reverse(char s[])
{
int c, i, j;
for(i=0,j=strlen(s)-1; i<j; i++,j--)
{
c=s[i]; s[i]=s[j]; s[j]=c;
}
}
7. Sorting with shell sort method.
This Shell sort demonstration compares elements separated by a decreasing gap and performs insertion-like swaps within each gap sequence. The final gap of one completes the ordering. It illustrates nested loops and a sorting strategy that improves on adjacent-only passes for many inputs, without claiming a universal performance bound.
#include<stdio.h>
#define SIZE 10
void shellsort(int v[], int n);
int main()
{
int counter;
int v[SIZE]={8,13,9,45,90,24,56,11,20,10};
shellsort(v,SIZE);
for(counter=0; counter<SIZE; counter++)
printf("%d ",v[counter]);
printf("\n");
return 0;
}
void shellsort(int v[], int n)
{
int gap, i, j, temp;
for(gap=n/2; gap>0; gap/=2)
for(i=gap; i<n; i++)
for(j=i-gap; j>=0 && v[j]>v[j+gap]; j-=gap)
{
temp=v[j];
v[j]=v[j+gap];
v[j+gap]=temp;
}
}8. using switch case
This input classifier uses switch cases to group digit and whitespace handling, maintaining per-digit counters and other totals. It demonstrates grouped case labels and break behavior. Read the conditions in the default branch carefully when interpreting alphabetic versus other-character counts; this is a simple byte-oriented exercise.
#include<stdio.h>
int main()
{
int c, i, nwhite, nother,alpha, ndigit[10];
nwhite=nother=alpha=0;
for(i=0; i<10; i++) ndigit[i]=0;
while((c=getchar())!=EOF)
{
switch(c)
{
case '0': case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9':
ndigit[c-'0']++; break;
case ' ': case '\n': case '\t': nwhite++; break;
default:
nother++; break;
}
}
printf("Digits =");
for(i=0; i<10; i++) printf(" %d", ndigit[i]);
printf(", white space =%d, other = %d\n", nwhite, nother);
return 0;
}
9. Double input - strip out non integers
This example parses an optional sign and leading decimal digits after whitespace, then multiplies the resulting integer by two. Despite the heading mentioning double input, the calculation uses integer parsing and integer arithmetic. The input copy has neither a bounds check nor a terminating zero byte, so conversion can read beyond the copied data; overflow is also unchecked.
#include<stdio.h>
#include<ctype.h>
#define SIZE 10
int atoi(char s[]);
int main(int argc, char *argv[])
{
int counter=0;
char s[SIZE];
if (argc!=2) {
printf("Usage: progname integer\n");
return 1;
}
while(*argv[1]) s[counter++]=(*argv[1]++);
printf("Twice Result=%d\n",2*atoi(s));
return 0;
}
int atoi(char s[])
{
int n, i,sign;
for(i=0; isspace(s[i]); i++);
sign=(s[i]=='-')? -1: 1;
if(s[i] == '+' || s[i] == '-') i++;
for(n=0; isdigit(s[i]); i++)
n=10*n + (s[i]-'0');
return sign*n;
}
Reference - https://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628#reader_0131103628