#define NUMBER '0'

int main (argc, argv)
int argc;
char *argv[];
{
double op, strtofloat(), pop(), push();

while (--argc > 0)
switch (type (*++argv)){ //determines whether the next argument is a number or something else

case NUMBER: //if it's a number, it pushes it onto the stack
push (strtofloat (*argv));
break;
//otherwise it does the appropriate operation, and pushes the result onto the stack
case '+':
push (pop() + pop());
break;

case '*':
push (pop() * pop());
break;

case '-':
if (type (*argv + 1) == NUMBER){ //unary minus
push (strtofloat (*argv));
break;
}
op = pop();
push (pop() - op);
break;

case '/':
op = pop();
if (op != 0.0) push (pop() / op);
else printf ("\nZero divisor popped.\n");
break;

case '%':
printf ("\nThe floating points will be truncated for the modulus operation.\n");
op = pop();
if (op != 0.0) push ((int)pop() % (int)op);
else printf ("\nZero divisor popped.\n");
break;

default:
printf ("Illegal option: %c.\n", type (*argv));
break;
}
printf ("\t%f\n", pop());
return 0;
}

#define MAXVAL 100 //max depth of val stack

int sp = 0; //stack pointer
double val[MAXVAL]; //value stack

double push (f) //push float onto the value stack
double f;
{
if (sp < MAXVAL) return (val[sp++] = f); //if there is room on the stack push float onto the stack

printf ("Error: stack is full.\n"); //if the stack is full clear stack and return 0
clear();
return 0;
}

double pop() //pops the top value from the stack
{
if (sp > 0) return (val[--sp]); //if there are values on the stack, pop the top one
return 0; //if stack is empty return 0
}

clear() //clears stack
{
sp = 0;
}

#define TABSTOP 5 //default length between two tab stops
#define MAXLINE 1000 //maximum line length

int main (argc, argv)
int argc;
char *argv[];
{
char *argvstart = argv;
char line[MAXLINE];
char *pline;
int col; //current column number
int nextstop; //column number of the next tab stop

while (lineget (line, MAXLINE) != 0){ //get next line
argv = argvstart; //set argv back to the first argument
nextstop = (strtoint (*++argv) > 0) ? strtoint (*argv++) : TABSTOP; //find the first tab stop
for (pline = line, col = 1; *pline != '\0'; pline++){
while (col >= nextstop) //if a tab stop has been reached, find the next one
nextstop += (strtoint (*argv) > 0) ? strtoint (*argv++) : (*argv[0] == '+') ? strtoint (*argv + 1) : TABSTOP;
if (*pline == '\t') //if the character is a '\t', print enough ' ' characters to reach the next tab stop
while (col < nextstop){
putchar (' ');
col++;
}
else { //otherwise print the character
putchar (*pline);
col++;
}
}
}
return 0;
}

int lineget (ps, lim)
char *ps;
int lim;
{
int c;
char *start = ps;

while ((c = getchar()) != EOF){
if (--lim < 1){ //line is too long, skip rest of the line
*--ps = '\n';
*++ps = '\0';
return -1;
}
*ps++ = c;
if (c == '\n') break;
}
*ps = '\0';
return (ps - start); //line length counting '\n', but not '\0'
}

int strtoint (ps)
char *ps;
{
int n = 0, sign = 1;

while (*ps == ' ' || *ps == '\n' || *ps == '\t') ps++;
if (*ps == '-'){
sign = -1;
ps++;
}

while (*ps >= '0' && *ps <= '9') n = 10 * n + *ps++ - '0';
return (sign * n);
}

#define TABSTOP 5
#define MAXLINE 1000

int main (argc, argv)
int argc;
char *argv[];
{
char *argvstart = argv;
char line[MAXLINE];
char *pline;
int col; //column number
int nextstop; //column number of the next tab stop
int nspaces; //total number of consecutive spaces
int ntabs; //number of consecutive spaces covered by tabs

while (lineget (line, MAXLINE) != 0){
argv = argvstart;
nextstop = (strtoint (*++argv) > 0) ? strtoint (*argv++) : TABSTOP;

for (pline = line, col = 1; *pline != '\0'; col++){
for (ntabs = nspaces = 0; *pline == ' '; nspaces++, pline++){ //count the total number of consecutive spaces
col++;
if (col >= nextstop){
putchar ('\t');
ntabs += (strtoint (*argv) > 0) ? strtoint (*argv) : (*argv[0] == '+') ? strtoint (*argv + 1) : TABSTOP; //count the number of spaces that are covered by '\t' characters
nextstop += (strtoint (*argv) > 0) ? strtoint (*argv++) : (*argv[0] == '+') ? strtoint (*argv + 1) : TABSTOP;
}
}

while ((--nspaces) % ntabs > 0) putchar (' '); //print the remaining blanks
putchar (*pline++); //print the non-blank character

while (col >= nextstop)
nextstop += (strtoint (*argv) > 0) ? strtoint (*argv++) : (*argv[0] == '+') ? strtoint (*argv + 1) : TABSTOP;
}
}
return 0;
}

./blah.out -flag1 argument

nextstop += (strtoint (*argv) > 0) ? strtoint (*argv++) : (*argv[0] == '+') ? strtoint (*argv + 1) : TABSTOP;

int type (ps)
char *ps;
{
while (*ps == ' ' || *ps == '\t' || *ps == '\n') ps++;

if (*ps < '0' || *ps > '9') return (*ps);
return NUMBER;
}

int type (char *ps)
{
return (*ps >= '0' && *ps <= '9') ? NUMBER : *ps;
}

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

int main (argc, argv)
int argc;
char *argv[];
{
char *flag;
int hollow = 0, ground = 0, even = 0, level = 0, edge = 0;
int number;

while (--argc > 0 && (*++argv)[0] == '-')
for (flag = argv[0] + 1; *flag != '\0'; flag++)
switch (*flag){
case 'h':
hollow = 1;
break;
case 'g':
ground = 1;
break;
case 'e':
even = 1;
break;
case 'l':
level = 1;
break;
case 'b':
edge = 1;
break;
default:
printf ("Illegal flag: -%c.\n", *flag);
argc = 0;
break;
}

if (argc != 1) printf ("Usage: Pyramid -h -g -e -l/-b number_of_blocks\n");
else if ((number = strtoint (*argv)) <= 0) printf ("Illegal number argument:\t%d.\n", number);

else if (level){
int nextblocks = (even) ? 2 : 1, nextsquare = nextblocks * nextblocks;
int nblocks = 0;

while (number > 0){
nblocks += nextsquare;
number--;
nextblocks += 2;

if (hollow && (!ground || number - nextblocks * nextblocks > 0)) //if pyramid is hollow and it's not a ground floor
nextsquare = 4 * nextblocks - 4; //n² - (n-2)² = 4n - 4
else nextsquare = nextblocks * nextblocks;
}

printf ("Length of the ground level's edge:\t%d blocks.\n", nextblocks - 2);
printf ("Number of blocks needed:\t%d.\n", nblocks);
}

else if (edge){
int nextsquare = number * number;
int nlevels = 0, nblocks = 0;

while (number > 0){
nlevels++;
number -= 2;
nblocks += nextsquare;

if (hollow && (!ground || nlevels > 1))
nextsquare = 4 * number - 4;
else nextsquare = number * number;
}

printf ("Height of the pyramid:\t%d blocks.\n", nlevels);
printf ("Number of blocks used:\t%d.\n", nblocks);
}

else {
int i = number;
int nextblocks = (even) ? 2 : 1, nextsquare = nextblocks * nextblocks;
int nlevels = 0;

while (i >= nextsquare){
nlevels++;
i -= nextsquare;
nextblocks += 2;

if (hollow && (!ground || i - nextblocks * nextblocks > 0)) //if pyramid is hollow and it's not a ground floor
nextsquare = 4 * nextblocks - 4; //n² - (n-2)² = 4n - 4
else nextsquare = nextblocks * nextblocks;
}

if (hollow && ground && (number >= 4 || !even)) //if -hge, nblocks has to be larger than 4
nextsquare -= (nextblocks - 4) * (nextblocks - 4); //set the level above the ground level to hollow

printf ("Height of the pyramid:\t%d blocks.\nLength of the ground level's edge:\t%d blocks.\n", nlevels, nextblocks - 2);
printf ("Number of blocks used:\t%d.\nNumber of blocks remaining:\t%d.\n", number - i, i);
printf ("Number of blocks you need to get for next level:\t%d.\n", nextsquare - i);
}

return 0;
}

int strtoint (ps)
char *ps;
{
int n = 0, sign = 1;

while (*ps == ' ' || *ps == '\n' || *ps == '\t') ps++;
if (*ps == '-' || *ps == '+') sign = (*ps++ == '+') ? 1 : -1;

while (*ps >= '0' && *ps <= '9') n = 10 * n + *ps++ - '0';
return (sign * n);
}

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

int main()
{
double power();

printf ("%f\n", power (10, 1));
}

double power (b, exp) //integer exponents
int exp;
double b;
{
int i, sign = 1;
double p = 1;

printf ("%f, %d\n", b, exp);

if (exp < 0){
sign = -1;
exp = -exp;
}
printf ("%d, %d\n", sign, exp);

for (i = 0; i < exp; i++) p *= b;
printf ("%f\n", p);

return ((sign == 1) ? p : 1/p);
}

0.000000, 134513883
1, 134513883
0.000000
0.000000

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

int main()
{
double power();

printf ("%f\n", power (3.0, 3));
}

double power (double b, int exp) //integer exponents
{
int i, sign = 1;
double p = 1;

printf ("%f, %d\n", b, exp);

if (exp < 0)
{
sign = -1;
exp *= -1;
}

printf("%d, %d\n", sign, exp);

for (i = 0; i < exp; i++) { p *= b; }
printf ("%f\n", p);

return ((sign == 1) ? p : 1.0/p);
}