/* addn.c -- Read a positive number N.

Then read N integers and

* print them out together with their sum.
*/
#include <stdio.h>

int main(void) {
int n; /* The number of numbers to be read */
int sum; /* The sum of numbers already read */
int current; /* The number just read */
int lcv; /* Loop control variable, it counts the number
of numbers already read */

printf("Enter a positive number n > ");

scanf("%d",&n); /* We should check that n is really positive*/
sum = 0;
for (lcv=0; lcv < n; lcv++) {
printf("\nEnter an integer > ");
scanf("%d",&current);
/* printf("\nThe number was %d\n", current); */
sum = sum + current;
}
printf("The sum is %d\n", sum);
return 0;
}

=========================================================================

/* add.c -- Read a sequence of positive integers and print them

* out together with their sum. Use a Sentinel value
* (say 0) to determine when the sequence has terminated.
*/

#include <stdio.h>
#define SENTINEL 0

int main(void) {
int sum = 0; /* The sum of numbers already read */
int current; /* The number just read */

do {
printf("\nEnter an integer > ");
scanf("%d", &current);
if (current > SENTINEL)
sum = sum + current;
} while (current > SENTINEL);
printf("\nThe sum is %d\n", sum);
}

/* power2.c -- Print out powers of 2: 1, 2, 4, 8, .. up to

2^N
*/

#include <stdio.h>
#define N 16

int main(void) {
int n; /* The current exponent */
int val = 1; /* The current power of 2 */

printf("\t n \t 2^n\n");
printf("\t================\n");
for (n=0; n<=N; n++) {
printf("\t%3d \t %6d\n", n, val);
val = 2*val;
}
return 0;
}

/* It prints out :

n 2^n
================
0 1
1 2
2 4
3 8
4 16
5 32
6 64
7 128
8 256
9 512
10 1024
11 2048
12 4096
13 8192
14 16384
15 32768
16 65536

*/

=====================================================================
/* homework1.c -- This is how the code for the first homework
* appears when we have a single block letter.
* In our Unix system you can compile, link,
* load, and run this program with the commands
* % cc homework1.c
* % a.out
 */

#include <stdio.h>

void blockg(void); /*Prototype for blockg function */

int main (void) {

printf("\n");
blockg();
printf("\n");
}

/* Print out the Block letter g */

void blockg(void) {
printf("gggggg\n");
printf("g g\n");
printf("g\n");
printf("g ggg\n");
printf("g g\n");
printf("gggggg\n");
}

/* It prints out:

gggggg
g g
g
g ggg
g g
gggggg

*/
/* FILE: coins.c
* DETERMINES THE VALUE OF A COIN COLLECTION
* A Variation of the Hanly/Koffman book's example
*/
#include <stdio.h>

void main ()
{
// Local data ...
int pennies; // input: count of pennies
int nickels; // input: count of nickels
int dimes; // input: count of dimes
int quarters; // input: count of quarters
int temp, left; // temporaries for various
// computations

// Read in the count of quarters, dimes, nickels and pennies.

printf("Enter the number of quarters, dimes, nickels, and pennies: ");
scanf("%d %d %d %d", &quarters, &dimes, &nickels, &pennies);

// Compute the total value in cents.

left = 25 * quarters + 10 * dimes + 5 * nickels + pennies;
 // Find and display the value in dollars
printf("Your collection is worth\n ");
temp = left / 100;
printf("\t%d dollar", temp);
if (temp==1)
printf(", ");
else
printf("s, ");
left = left % 100;

// Find and display the value left in quarters

temp = left / 25;
printf("%d quarter", temp);
if (temp==1)
printf(", ");
else
printf("s, ");
left = left % 25;

// Find and display the value left in dimes

temp = left / 10;
printf("%d dime", temp);
// Here, just for fun, instead of using a conditional statement,
// I use a conditional expression and string concatenation
printf ((temp==1) ? ", " : "s, ");
left = left % 10;

// Find and display the value left in nickels

temp = left / 5;
printf("%d nickel", temp);
if (temp==1)
printf(", and ");
else
printf("s, and ");
left = left % 5;

// Find and display the value left in pennies

printf("%d penn", left);
if (left==1)
printf("y\n");
else
printf("ies\n");
}

/* factorial.c -- It computes repeatedly the factorial

of an integer entered
* by the user. It terminates when the integer
entered is not
* positive.
*/
#include <stdio.h>
int fact(int n);

int main(void) {
int current;

printf("Enter a positive integer [to terminate enter non-positive] > ");

scanf("%d", &current);
while (current > 0) {
printf("The factorial of %d is %d\n", current, fact(current));
printf("Enter a positive integer [to terminate enter non-positive] > ");
scanf("%d", &current);
}
}

/* n is a positive integer. The function returns its factorial */

int fact(int n) {
int lcv; /* loop control variable */
int p; /* set to the product of the first lcv positive integers */

for(p=1, lcv=2; lcv <= n; p=p*lcv, lcv++);

return p;
}

/* prime1.c It prompts the user to enter an integer N.

It prints out
* if it is a prime or not. If not, it prints
out a factor of N.
*/
#include <stdio.h>

int main(void) {
int n;
int i;
int flag;

printf("Enter value of N > ");

scanf("%d", &n);
flag = 1;
for (i=2; (i<(n/2)) && flag; ) { /* May be we do not need to test
values of i greater than the square root of n? */
if ((n % i) == 0) /* If true n is divisible by i */
flag = 0;
else
i++;
}

if (flag)
 printf("%d is prime\n", n);
else
printf("%d has %d as a factor\n", n, i);
return 0;
}
/* factor1.c -- It prompts the user to enter an integer
N. It prints out
* if it is a prime or not. If not, it prints
out all of its
* proper factors.
*/

#include <stdio.h>

int main(void) {
int n,
lcv,
flag; /* flag initially is 1 and becomes 0 if we determine that n
is not a prime */

printf("Enter value of N > ");

scanf("%d", &n);
for (lcv=2, flag=1; lcv <= (n / 2); lcv++) {
if ((n % lcv) == 0) {
if (flag)
printf("The non-trivial factors of %d are: \n", n);
flag = 0;
printf("\t%d\n", lcv);
}
}
if (flag)
printf("%d is prime\n", n);
}

/* true.c -- What are in C the values of TRUE and

FALSE?
*/
#include <stdio.h>

int main(void) {
printf("The value of 1<2 is %d\n", (1<2));
printf("The value of 2<1 is %d\n", (2<1));
}

/* The program prints out

The value of 1<2 is 1

The value of 2<1 is 0

*/
============================================================================/*
fibo.c -- It prints out the first N Fibonacci
* numbers.
*/

#include <stdio.h>

int main(void) {
int n; /* The number of fibonacci numbers we will print */
int i; /* The index of fibonacci number to be printed next */
int current; /* The value of the (i)th fibonacci number */
int next; /* The value of the (i+1)th fibonacci number */
int twoaway; /* The value of the (i+2)th fibonacci number */

printf("How many Fibonacci numbers do you want to compute? ");

scanf("%d", &n);
if (n<=0)
printf("The number should be positive.\n");
else {
printf("\n\n\tI \t Fibonacci(I) \n\t=====================\n");
next = current = 1;
for (i=1; i<=n; i++) {
printf("\t%d \t %d\n", i, current);
twoaway = current+next;
current = next;
next = twoaway;
}
}
}

/* The output from a run of this program was:

How many Fibonacci numbers do you want to compute? 9

I Fibonacci(I)
=====================
1 1
2 1
3 2
4 3
5 5
6 8
7 13
8 21
9 34

*/
/* funcs.c -- Examples of function declarations,
definitions, and use
*/
#include <stdio.h>

/* Examples of declarations of functions */

void square1(void); /* Example of a function without input parameters
and without return value */

void square2(int i); /* Example of a function with one input parameter

and without return value */

int square3(void); /* Example of a function without input parameters

and with integer return value */

int square4(int i); /* Example of a function with one input parameter

and with integer return value */

int area(int b, int h); /* Example of a function with two input parameters
and with integer return value */

/* Main program: Using the various functions */

int main (void) {
square1(); /* Calling the square1 function */
square2(7); /* Calling the square2 function using 7 as actual
parameter corresponding to the formal parameter i */
printf("The value of square3() is %d\n", square3()); /* Ysing the square3
function */
printf("The value of square4(5) is %d\n", square4(5)); /* Using the square4
function with 5 as actual parameter corresponding to i */
printf("The value of area(3,7) is %d\n", area(3,7)); /* Using the area
function with 3, 7 as actual parameters corresponding
to b, h respectively */
}

/* Definitions of the functions */

/* Function that reads from standard input an integer and prints

it out together with its sum */
void square1(void){
int x;

printf("Please enter an integer > ");

scanf("%d", &x);
printf("The square of %d is %d\n", x, x*x);
}

/* Function that prints i together with its sum */

void square2(int i){
printf("The square of %d is %d\n", i, i*i);
}

/* Function that reads from standard input an integer and returns

its square */
int square3(void){
int x;
printf("Please enter an integer > ");
scanf("%d", &x);
return (x*x);
}

/* Function that returns the square of i */

int square4(int i){
 return (i*i);
}

/* Function that returns the area of the rectangle with base b

and hight h */
int area(int b, int h){
return (b*h);
}

/* The output of this program is:

Please enter an integer > 3

The square of 3 is 9
The square of 7 is 49
Please enter an integer > 4
The value of square3() is 16
The value of square4(5) is 25
The value of area(3,7) is 21

*/

/* funcs.c -- More examples of functions

*/

#include <stdio.h>

int getint(void); /*It prompts user to enter an integer, which it returns*/

int getmax(int a, int b, int c); /*It returns value of largest of a, b, c*/

/* Main program: Using the various functions */

int main (void) {
int x, y, z;

x = getint();
y = getint();
z = getint();
printf("The largest of %d, %d, and %d is %d\n", x, y, z, getmax(x,y,z));
}

int getint(void) {
int a;

printf("Please enter an integer > ");

scanf("%d", &a);
return(a);
}

int getmax(int a, int b, int c){

int m = a;

if (m<b)
m = b;
if (m<c)
m = c;
 return(m);
}
/*scope1.c -- Simple example showing effects of the
scope rules
*/
#include <stdio.h>

int a=0; /* This is a global variable */

void foo(void);

int main(void) {
int a=2; /* This is a variable local to main */
int b=3; /* This is a variable local to main */

printf("1. main_b = %d\n", b);

printf("main_a = %d\n", a);
foo();
printf("2. main_b = %d\n", b);
}

void foo(void){
int b=4; /* This is a variable local to foo */

printf("foo_a = %d\n", a);

printf("foo_b = %d\n", b);
}

/* scope2.c -- Example on scope rules

*/
#include <stdio.h>
int x = 2;
int y = 3;
int z = 4;
void moo(int x, int *y){
int z;
x = x+3;
*y = *y+3;
z = z+3; /*Here z is the local z. Notice that it has not been
initialized. As you see from the output below
in this case it was implicitly initialized to 0.
In general that is not the case and the compiler
should give you a warning
*/
printf("moo : x = %1d, *y = %1d, y = %1d, z = %1d\n", x,*y,y,z);
}
int main(void){
moo(x, &y);
printf("main: x = %1d1, y = %1d, z = %1d\n", x,y,z);
}

/* The output is
moo : x = 5, *y = 6, y = 1073742056, z = 3
main: x = 21, y = 6, z = 4

*/
/* array.c -- Operations on arrays
*/
#include <stdio.h>

int main(void) {
int a[2] = {1,2}; /* The aggregates like {1,2} are literals for arrays */
int b[2] = {2,3};
int i;

/* It is legal to use subscripts on arrays, both on the left and on

* the right hand side of assignments. */
for(i=0;i<2;i++)
a[i]=b[i];

/* It is not legal to assign arrays, like in a=b; */

/* The comparison of two distinct arrays with the same content

* results in FALSE. So below we print "They are not equal"
*/
if(a==b)
printf("They are equal\n");
else
printf("They are not equal\n");

/* The following comparison results in TRUE. */

if(a==a)
printf("Of course a is equal to a\n");
else
printf("No, a is not equal to a\n");
/* The behavior of comparison is explained when we note that the
* comparison is a comparison of addresses, not contents.
*/
/* We cannot print out an array as a single unit. We have to print out
* its elements one at a time.
*/
for(i=0;i<2;i++)
printf("a[%1d] = %3d\n", i, a[i]);
}
/* array1.c -- Simple operations with arrays.
*/

#include <stdio.h>
#define N 10

void oneWay(void);
void anotherWay(void);

int main(void) {
printf("\noneWay:\n");
 oneWay();
printf("\nantherWay:\n");
anotherWay();
}

/*Array initialized with aggregate */

void oneWay(void) {
int vect[N] = {1,2,3,4,5,6,7,8,9,0};
int i;

for (i=0; i<N; i++)

printf("i = %2d vect[i] = %2d\n", i, vect[i]);
}

/*Array initialized with loop */

void anotherWay(void) {
int vect[N];
int i;

for (i=0; i<N; i++)

vect[i] = i+1;

for (i=0; i<N; i++)

printf("i = %2d vect[i] = %2d\n", i, vect[i]);
}

/* The output of this program is

oneWay:
i = 0 vect[i] = 1
i = 1 vect[i] = 2
i = 2 vect[i] = 3
i = 3 vect[i] = 4
i = 4 vect[i] = 5
i = 5 vect[i] = 6
i = 6 vect[i] = 7
i = 7 vect[i] = 8
i = 8 vect[i] = 9
i = 9 vect[i] = 0

antherWay:
i = 0 vect[i] = 1
i = 1 vect[i] = 2
i = 2 vect[i] = 3
i = 3 vect[i] = 4
i = 4 vect[i] = 5
i = 5 vect[i] = 6
i = 6 vect[i] = 7
i = 7 vect[i] = 8
i = 8 vect[i] = 9
i = 9 vect[i] = 10

*/
/* array2.c -- Read/writing/reversing integer arrays
*/
#include <stdio.h>

#define NMAX 10

void intSwap(int *x, int *y);

int getIntArray(int a[], int nmax, int sentinel);
void printIntArray(int a[], int n);
void reverseIntArray(int a[], int n);

int main(void) {
int x[NMAX];
int hmny;

hmny = getIntArray(x, NMAX, 0);

printf("The array was: \n");
printIntArray(x,hmny);
reverseIntArray(x,hmny);
printf("after reverse it is:\n");
printIntArray(x,hmny);
}

void intSwap(int *x, int *y)

/* It swaps the content of x and y */
{
int temp = *x;
*x = *y;
*y = temp;
}

void printIntArray(int a[], int n)

/* n is the number of elements in the array a.
* These values are printed out, five per line. */
{
int i;

for (i=0; i<n; ){

printf("\t%d ", a[i++]);
if (i%5==0)
printf("\n");
}
printf("\n");
}

int getIntArray(int a[], int nmax, int sentinel)

/* It reads up to nmax integers and stores then in a; sentinel
* terminates input. */
{
int n = 0;
int temp;

do {
printf("Enter integer [%d to terminate] : ", sentinel);
scanf("%d", &temp);
if (temp==sentinel) break;
if (n==nmax)
printf("array is full\n");
else
 a[n++] = temp;
}while (1);
return n;
}

void reverseIntArray(int a[], int n)

/* It reverse the order of the first n elements of a */
{
int i;

for(i=0;i<n/2;i++){
intSwap(&a[i],&a[n-i-1]);
}
}

/* misc.c -- various C constructs */

#include <stdio.h>

int main(void) {
int answer;
short x = 1;
long y = 2;
float u = 3.0;
double v = 4.4;
long double w = 5.54;
char c = 'p';;

/* __DATE__, __TIME__, __FILE__, __LINE__ are predefined symbols */

printf("Date : %s\n", __DATE__);
printf("Time : %s\n", __TIME__);
printf("File : %s\n", __FILE__);
printf("Line : %d\n", __LINE__);
printf("Enter 1 or 0 : ");
scanf("%d", &answer);

/* answer?"you said yes":"You said no" is a conditional expression */

printf("%s\n", answer?"You sayd YES":"You said NO");

/* The size of various types */

printf("The size of int %d\n", sizeof(answer));
printf("The size of short %d\n", sizeof(x));
printf("The size of long %d\n", sizeof(y));
printf("The size of float %d\n", sizeof(u));
printf("The size of double %d\n", sizeof(v));
printf("The size of long double %d\n", sizeof(w));
printf("The size of char %d\n", sizeof(c));

/*
The output from a run was:
Date : Feb 11 1997
Time : 13:51:31
File : white.c
Line : 20
Enter 1 or 0 : 1
You sayd YES
The size of int 4
The size of short 2
The size of long 8
The size of float 4
The size of double 8
The size of long double 8
The size of char 1

*/
/* addresses.c -- Playing with addresses of variables and their contents:
* what is done by C with variables, addresses, and values.
*/

#include <stdio.h>

void moo(int a, int * b);

int main(void) {
int x;
int *y;

x=1;
y=&x;
printf("Address of x = %d, value of x = %d\n", &x, x);
printf("Address of y = %d, value of y = %d, value of *y = %d\n", &y, y, *y);
moo(9,y);
}

void moo(int a, int *b){

printf("Address of a = %d, value of a = %d\n", &a, a);
printf("Address of b = %d, value of b = %d, value of *b = %d\n", &b, b, *b);
}

/* Output from running this program on my computer:

Address of x = 536869640, value of x = 1

Address of y = 536869632, value of y = 536869640, value of *y = 1
Address of a = 536869608, value of a = 9
Address of b = 536869600, value of b = 536869640, value of *b = 1

*/

/* codes.c -- It prints out the numerical codes of the

printable ascii
* characters
*/
#include <stdio.h>

int main(void){
int c;

printf("\tCharacter Code\n"
"\t===============\n");
for (c=32; c<127; c++)
printf("\t %c %4d\n", c, c);
}

/* Here is the ouput from this program:

Character Code
===============
32
! 33
" 34
# 35
$ 36
% 37
& 38
' 39
( 40
) 41
* 42
+ 43
, 44
- 45
. 46
/ 47
0 48
1 49
2 50
3 51
4 52
5 53
6 54
7 55
8 56
9 57
: 58
; 59
< 60
= 61
> 62
? 63
@ 64
A 65
B 66
C 67
D 68
E 69
F 70
G 71
H 72
 I 73
J 74
K 75
L 76
M 77
N 78
O 79
P 80
Q 81
R 82
S 83
T 84
U 85
V 86
W 87
X 88
Y 89
Z 90
[ 91
\ 92
] 93
^ 94
_ 95
` 96
a 97
b 98
c 99
d 100
e 101
f 102
g 103
h 104
i 105
j 106
k 107
l 108
m 109
n 110
o 111
p 112
q 113
r 114
s 115
t 116
u 117
v 118
w 119
x 120
y 121
z 122
{ 123
| 124
} 125
~ 126

*/
/* Generating random number sequences using the formula
(linear congruence)
x[k+1] = (a*x[k] + c)mod m
where a, c, and m are parameters set by the user and
passed as command line
parameters together with a seed i.e. x[0]
As a simple example try a=7, c=1, m=13, and seed=5
A more sophisticated selection would be a=69069,
c=0,
m=2^32=4294967296, and seed=31
It will print out, in a sort of random order, up to
m-1 distinct values.
Then it loops.
*/

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

static long seed = 13;

static long a;
static long c;
static long m;

void random_init(long s) {
if (s != 0) seed = s;
}

long random() {
seed = (a*seed + c)%m;
return seed;
}

int main(int argc, char * argv[]) {

if (argc != 5) {
printf("usage: %s a, c, m, seed\n", argv[0]);
return 1;
}
a = atoi(argv[1]);
c = atoi(argv[2]);
m = atoi(argv[3]);
long s = atoi(argv[4]);
random_init(s);
int k;
for (k = 0; k < m-1; k++) {
printf("%8ld", random());
if (k % 8 == 7) { // after 8 elements go to a new line
printf("\n");
sleep(1); // sleep for a second
 }
}
printf("\n");
return 0;
}

/* randompermute.c - A program will generate "random

permutations of n elements"
if at all points the n! possible permutations have
all the same probability
of being generated.
*/
#include <stdio.h>
#include <stdlib.h>

// It returns a random permutation of 0..n-1

int * rpermute(int n) {
int *a = malloc(n*sizeof(int));
int k;
for (k = 0; k < n; k++)
a[k] = k;
for (k = n-1; k > 0; k--) {
int j = rand() % (k+1);
int temp = a[j];
a[j] = a[k];
a[k] = temp;
}
return a;
}

// Print a 8 elements per line

void printarray(int n, int a[n]) {
int k = 0;
for (k = 0; k < n; k++) {
printf("%6d ", a[k]);
if (k % 8 == 7)
printf("\n");
}
}

int main(void) {
int limit = 6;
int *a;
int k;
// Print 7 permutations
for (k = 0; k < 7; k++) {
a = rpermute(limit);
printarray(limit, a);
printf("\n");
}
 return 0;
}

/* line.c -- It reads lines from input and echoes them

back.
*/

#include <stdio.h>

int main(void) {
char c;
int count;

for(;;){
count=0;
printf("Please enter a line [blank line to terminate]> ");
do{
c=getchar();
putchar(c);
count++;
}while (c!='\n');
if(count==1)break;
}
}

/*linear.c -- Read an integer array and then do linear

searches.
*/

#include <stdio.h>

#define NMAX 10

int getIntArray(int a[], int nmax, int sentinel);

void printIntArray(int a[], int n);
int linear(int a[], int n, int who);

int main(void) {
int x[NMAX];
int hmny;
int who;
int where;

hmny = getIntArray(x, NMAX, 0);

printf("The array was: \n");
printIntArray(x,hmny);
printf("Now we do linear searches on this data\n");
do{
printf("Enter integer to search for [0 to terminate] : ");
scanf("%d", &who);
if(who==0)break;
 where = linear(x,hmny,who);
if (where<0){
printf("Sorry, %d is not in the array\n",who);
}else
printf("%d is at position %d\n",who,where);
}while(1);
}

void printIntArray(int a[], int n)

/* n is the number of elements in the array a.
* These values are printed out, five per line. */
{
int i;

for (i=0; i<n; ){

printf("\t%d ", a[i++]);
if (i%5==0)
printf("\n");
}
printf("\n");
}

int getIntArray(int a[], int nmax, int sentinel)

/* It reads up to nmax integers and stores then in a; sentinel
* terminates input. */
{
int n = 0;
int temp;

do {
printf("Enter integer [%d to terminate] : ", sentinel);
scanf("%d", &temp);
if (temp==sentinel) break;
if (n==nmax)
printf("array is full\n");
else
a[n++] = temp;
}while (1);
return n;
}

int linear(int a[], int n, int who)

/* Given the array a with n elements, searches for who.
* It returns its position if found, otherwise it returns
* -1.
*/
{
int lcv;
for (lcv=0;lcv<n;lcv++)
if(who == a[lcv])return lcv;
return (-1);
}
/* shift.c -- It reads a sequence of positive integers.
It stores it
* in an array, then it prompts the user to
enter an
* integer, and then rotates clockwise the
content of the
* array a corresponding number of
positions. The contents
* the array are printed out whenever it
changes.
* For example, if the sequence was
* 1,2,3,4,5
* and the number 3 is entered, the array
becomes
* 3,4,5,1,2
* and if the number 11 is now entered, the
array becomes
* 2,3,4,5,1
* and if the number -4 is now entered, the
array becomes
* 1,2,3,4,5
*/

#include <stdio.h>
#define MAXN 8

/* It prints the current content on the array a with n elements */

void printarray(int a[], int n);
/* I will assume first that I have a number of functions then I will
* write them.
*/

/* Given an array a with n values, shift rotates

* its content m positions, clockwise.
*/
void shift(int a[], int n, int m);

/* getint prompts the user to enter a positive integer and returns

* its value.
*/
int getint(void);

/* It requests the user to enter positive integers and stores

* them in a. It returns in n the number of integers stored
* in the array.
*/
void getarray(int a[], int *n);
int main(void) {
int table[MAXN]; /* array where we store the sequence */
int howmany=0; /* number of elements in sequence */
int amount; /* amount of shift */

getarray(table, &howmany);
if (howmany==0) {
printf("Sorry, you entered the null sequence. Good bye.\n");
}else {
do {
printarray(table,howmany);
printf("By how much do you want to shift[0 to terminate]? ");
scanf("%d",&amount);
if (amount!=0)
shift(table,howmany,amount);
}while(amount!=0);
}
}

/* Given an array a with n values, shift rotates

* its content m positions, clockwise.
*/
void shift(int a[], int n, int m){
int temp[MAXN];
int lcv;

if (m<0)
m = n-(abs(m)%n);
for (lcv=0;lcv<n;lcv++)
temp[(lcv+m)%n] = a[lcv];
for (lcv=0; lcv<n;lcv++)
a[lcv]=temp[lcv];
}

/* getint prompts the user to enter a positive integer and returns

* its value.
*/
int getint(void){
int answer;

printf("Please enter a positive integer [<=0 to terminate] : ");

scanf("%d", &answer);
return answer;
}

/* It requests the user to enter positive integers and stores

* them in a. It returns in n the number of integers stored
* in the array.
*/
void getarray(int a[], int *n) {
int answer;
int i=0;

do {
answer = getint();
if (answer>0 && (i<MAXN))
 a[i++]=answer;
}while(answer>0 && (i<MAXN));
*n = i;
}

/* It prints the current content of the array a with n elements */

void printarray(int a[], int n) {
int lcv;

for (lcv=0;lcv<n;lcv++){
printf(" %d",a[lcv]);
}
printf("\n");
}

/* sieve.c - It prompts the user to enter an integer N.

It prints out
* It prints out all the primes up to N
included.
* It uses a sieve method. As primes are
found they are
* stored in an array PRIMES and used as
possible factors
* for the next potential prime.
*/

#include <stdio.h>

#define NPRIMES 1000

#define FALSE 0
#define TRUE 1

int main(void) {
int n;
int i,j;
int flag;
int primes[NPRIMES]; /*It will contain the primes smaller than n
*that we have already encountered*/
int level; /*1+Number of primes currently in PRIMES*/

/*Introduction*/
printf("Enter value of N > ");
scanf("%d",&n);
level = 0;

/*Main body*/
for(i=2;i<=n;i++) {
for(j = 0, flag = TRUE; j<level && flag; j++)
flag = (i%primes[j]);
if (flag) { /*I is a prime */
 printf("%12d\n", i);
if (level < NPRIMES)
primes[level++] = i;
}
}
}
/* string1.c -- Simple string operations
String literals.
printf, scanf, %s, %c
strlen
strcpy
strcmp
*/

#include <stdio.h>
#define MAXBUFF 128

int main(void) {
char c[] = "012345";
char line[MAXBUFF];
int lcv;
int cmp;

printf("sizeof(c)= %d\n", sizeof(c));

printf("sizeof(line)= %d\n", sizeof(line));
for (lcv=0; lcv<=strlen(c); lcv++)
printf("c[lcv]= %d = %c\n",c[lcv],c[lcv]);
printf("Please enter a string : ");
scanf("%s",line);
printf("strlen(line) = %d\n", strlen(line));
printf("line = [%s]\n",line);
cmp = strcmp(c,line);
if(cmp<0)
printf("%s is less than %s\n", c, line);
else if (c==0)
printf("%s is equal to %s\n", c, line);
else
printf("%s is greater than %s\n", c, line);
strcpy(line,c); /*copy the string c into line */
cmp = strcmp(c,line);
if(cmp<0)
printf("%s is less than %s\n", c, line);
else if (cmp==0)
printf("%s is equal to %s\n", c, line);
else
printf("%s is greater than %s\n", c, line);
}

/* The output of this program:

sizeof(c)= 7
sizeof(line)= 128
c[lcv]= 48 = 0
c[lcv]= 49 = 1
c[lcv]= 50 = 2
c[lcv]= 51 = 3
c[lcv]= 52 = 4
c[lcv]= 53 = 5
c[lcv]= 0 =
Please enter a string : roses are red
strlen(line) = 5
line = [roses]
012345 is less than roses
012345 is equal to 012345

/* getline.c -- Testing a function that reads a line

* from input.
*/
#include <stdio.h>
#define MAXBUF 128

int getline(char line[], int nmax);

int main(void){
int len;
char buffer[MAXBUF];

while(1){
len = getline(buffer, MAXBUF);
if (len==0)break;
printf("len = %d, line = %s\n", len, buffer);
};
}

int getline(char line[], int nmax)

/* It prompts user and reads up to nmax
* characters into line. It returns number
* of characters read. ['\n' terminates the line]
*/
{
int len;
char c;

len = 0;
printf("Enter a string [CR to exit]: ");
while(((c=getchar())!='\n') && len<nmax-1)
line[len++]=c;
line[len]='\0';
return len;
}
/* string2.c -- Compacting sequences of spaces in a
string.
We use two different methods
*/
#include <stdio.h>
#define MAXBUFF 128

int getline(char line[], int nmax);

int compact1(char line[]);
int compact2(char line[]);

int main(void) {
char buffer1[MAXBUFF];
char buffer2[MAXBUFF];
int len;

len = getline(buffer1, MAXBUFF);

printf("You entered : %s\n", buffer1);
strcpy(buffer2,buffer1);
printf("Which is : %s\n", buffer2);

len=compact1(buffer1);
printf("compact1: len=%d, %s\n",len, buffer1);
len=compact2(buffer2);
printf("compact2: len=%d, %s\n",len, buffer2);
}

int getline(char line[], int nmax)

/* It prompts user and reads up to nmax
* characters into line. It returns number
* of characters read. ['\n' terminates the line]
*/
{
int len;
char c;

len = 0;
printf("Enter a string [CR to exit]: ");
while(((c=getchar())!='\n') && len<nmax-1)
line[len++]=c;
line[len]='\0';
return len;
}

int compact1(char line[])

/* It replaces streaks of spaces in line by a
* single space. It returns lenght of resulting string.
*/
{
int cursor=0; /* Cursor on the line */
int prevspace = 0; /* True iff preceding position was with a space */
int lcv=0; /* Other cursor */

if(line[cursor]=='\0')
return 0;
do{
if((line[cursor]==' ')&&prevspace){
/*If we have a space preceded by a space, move rest of string
left one position */
for(lcv=cursor;line[lcv];lcv++)
line[lcv]=line[lcv+1];
 }else
prevspace=(line[cursor++]==' ');
}while(line[cursor]);
return cursor;
}

int compact2(char line[])

/* It replaces streaks of spaces in line by a
* single space. It returns lenght of resulting string.
*/
{
int cursor=0; /* Cursor on the line */
int prevspace = 0; /* True iff preceding position was with a space */
int lcv = 0; /* Where we copy characters to */

do{
if(!((line[cursor]==' ')&&prevspace)){
line[lcv++]=line[cursor];
prevspace=(line[cursor]==' ');
}
}while(line[cursor++]);
return(lcv-1); /*We need the -1 since it counts also the '\0' */
}

/* counts.c - It contains a program that is given as

command parameter
* the name of a text file, say, temp.dat.
It will read each line
* of temp.dat and print out in
correspondence the number of
* characters and words on that line. At the
end it will print
* out the number of lines that were read.
*/

#include <stdio.h>

int main (int argc, char *argv[]){

FILE *fp;
int nchars, nwords, nlines;
int lastnblank; /* 0 iff the last character was a space */
char c;

if(argc!=2){
printf("Usage: %s filename\n", argv[0]);
exit(0);
}
if((fp=fopen(argv[1],"r"))==NULL){
perror("fopen");
exit(0);
}
 nchars=nwords=nlines=lastnblank=0;
while((c=getc(fp))!=EOF){
nchars++;
if (c=='\n'){
if (lastnblank)
nwords++;
printf("words=%d, characters=%d\n", nwords, nchars);
nchars=nwords=lastnblank=0;
nlines++;
}else{
if (((c==' ')||(c=='\t'))&(lastnblank))
nwords++;
lastnblank=((c!=' ')&&(c!='\t'));
}
}
printf("lines=%d\n", nlines);
fclose(fp);
}
/* cpfile.c -- Similar to Unix's cp command.
* This program will be called with two
parameters,
* the names of two files. It copies the
first to the second.
*/
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char * argv[]){

FILE *fin, *fout;
char c;

if (argc!=3){
printf("Usage: %s filein fileout\n", argv[0]);
exit(0);
}
if ((fin=fopen(argv[1],"r"))==NULL){
perror("fopen filein");
exit(0);
}
if ((fout=fopen(argv[2],"w"))==NULL){
perror("fopen fileout");
exit(0);
}

while ((c=getc(fin))!=EOF)
putc(c,fout);

fclose(fin);
fclose(fout);
return 0;
}
GCm
#include<stdio.h>
void main()
{
int a,b,c,d,i,gcd;
printf("Enter Number 1");
scanf("%d",a);
printf("Enter Number 2");
scanf("%d",b);
printf("Enter Number 3");
scanf("%d",c);
printf("Enter Number 4");
scanf("%d",d);
for(i=1;i++;)
{
if((n%a==0)&&(n%b==0)&&(n%c==0)&&(n%d==0)
{break;}
)
lcm = ((a*b*c*d)/i);
}

……………………………………………………………………………………………………………………………………………..

/*Program for printing Prime numbers*/

#include <stdio.h>
#include <conio.h>
#include <dos.h>

void main()
{
int i=1,j,f;
clrscr();

printf("\n\n\n\t\t\t Program for printing Prime numbers");

while(i<=1000)
{
j=1;
f=0;
while(j<=i)
{
if(i%j==0)
f++;
j++;
}
if(f<=2)
printf("\n\t\t\t %d",i);
i++;

delay(100);
}

getch();

*****************************************************************************

/*Program for generating a sequence*/

#include <stdio.h>
#include <conio.h>
void main()
{

int n,f=0;
clrscr();
printf("\n\n\n\t\t\t Program for generating a sequence");
printf("\n\n\n\t\t\t Enter any no. = ");
scanf("%d",&n);
if(n<1)
{
printf("\n\n\t\t\t Error !");
exit(0);
}
else
{
while(n!=1)
{
if(n%2==1)
{
n=n*3+1;
f++;
}
else
{
n=n/2;
f++;
}
printf("\n\n\t\t\t Next value %d",n);
}
printf("\n\n\t\t\t Final value %d, Operation performed %d",n,f);
}
getch();

,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,

/*Program for calculating an Armstrong number*/

#include <stdio.h>
#include <conio.h>

void main()
{
int n,r,res=0,t;
clrscr();
printf("\n\n\n\t\t\t Program for calculating an Armstrong
number");

printf("\n\n\n\t\t\t Enter any number = ");

scanf("%d",&n);
t=n;

while(n>0)
{
r=n%10;
res=res+r*r*r;
n=n/10;
}
if(t==res)
printf("\n\n\n\t\t\t %d is an Armstrong number.",t);

else
printf("\n\n\n\t\t\t %d is Not an Armstrong number.",t);

getch();

,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,

/*Program for printing Fibonacci Series*/

#include <stdio.h>
#include <conio.h>
void main()
{
int fibonacci();
int n,f;
clrscr();
printf("\n\n\n\t\t\t Program for printing Fibonacci Series");
printf("\n\n\n\t\t\t How many Fibonacci numbers you want to see ?
= ");
scanf("%d",&n);

while(n)
{
f=fibonacci();
printf("\n\t\t\t %d",f);
n--;
}
getch();

}
int fibonacci()
{
static a=0,b=1,c=0;
c=a+b;
b=a;
a=c;
return(c);

/*Program for Reversing a line of text*/

#include <stdio.h>
#include <conio.h>
void main()
{
char str[80],ch;
int len=0,i=0;
clrscr();
printf("\n\n\n\t\t\t Program for Reversing a line of text");
printf("\n\n\n\t\t\t Enter a line of Text:");
printf("\n\t >> ");
fflush(stdin);
scanf("%[^'\n']",str);

i=0;
while(str[i]!='\0')
{
len++;
i++;
}
len=len-1;
printf("\n\n\t Reverse = ");
for(i=len;i>=0;i--)
{
ch=str[i];
if(ch>=97 && ch<=123)
ch=ch-32;
printf("%c",ch);
}

getch();
}

/*Program for Encoding & Decoding a Line of text*/

#include <stdio.h>
#include <conio.h>
void main()
{
char str[80],ch;
int len=0,i=0;
clrscr();
printf("\n\n\n\t\t\t Program for Reversing a line of text");
printf("\n\n\n\t\t\t Enter a line of Text:");
printf("\n\t >> ");
fflush(stdin);
scanf("%[^'\n']",str);

i=0;
while(str[i]!='\0')
{
len++;
i++;
}
len=len-1;
printf("\n\n\t Reverse = ");
for(i=len;i>=0;i--)
{
ch=str[i];
if(ch>=97 && ch<=123)
ch=ch-32;
printf("%c",ch);
}

getch();
}

________________________________________________________________________-

/*Program to calculate the sum of series*/

#include <stdio.h>
#include <conio.h>
long int factorial(int n);
void main()
{
int n,i;
float s,r;
char c;
clrscr();
repeat : printf("

You have this series:- 1/1! + 2/2! + 3/3! + 4/4! ...");

printf("
To which term you want its sum? ");
scanf("%d",&n);
s=0;
for (i=1;i<=n;i++)
{ s=s+((float)i/(float)factorial(i)); }
printf("
The sum of %d terms is %f",n,s);
fflush(stdin);
printf ("

Do you want to continue?(y/n):- ");

scanf("%c",&c);
if (c=='y')
goto repeat;
getch();
}
long int factorial(int n)
{
if (n<=1)
return(1);
else
n=n*factorial(n-1);
return(n);
}

/*Program for finding the prime numbers*/

#include <stdio.h>
#include <conio.h>
void main()
{
int n,m,k,i,max;
char c;
clrscr();
repeat: max=0;
k=2;
n=1;
printf("You want prime numbers upto:- ");
scanf("%d",&max);
printf(" ");
for (i=1;i<=max;i++)
{
again: m=(n/k)*k;
if (m!=n)
k=k+1;
else
goto try1;
if (k < n/2)
goto again;
else
printf("%d",n);
printf(" ");
try1: n=n+1;
k=2;
}
fflush(stdin);
printf ("Do you want to continue?(y/n):- ");
scanf("%c",&c);
if (c=='y')
goto repeat;
getch();}