PASS Week 10/20

PASS Week 10/20



Problem #1 Review of Loops

The value of pi (π) can be calculated by the following formula:

Θ = ✓6 * (1/1^2) + (1/2^2) + (1/3^2) + ... + (1/limit^2)

Write a program that uses this formula to calculate pi. Each operation in the
parentheses will be repeated to the number of the limit (n). Note, the program will
prompt the user for the “limit” value. Test your program once a limit of 5 terms, 10
terms and a limit of 20 terms. Print the results of each and observe how this
algorithm gets more accurate depending on how many terms you use.


/*** SKELETON CODE ***/

/***********************************************
* This program computes pi using repetition *
* and the terms or limits method. *
* By: Larry Snedden *
**********************************************/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

double compute_Pi(int);

int main(void)
{
	int limit;
	double Pi;

	printf("Enter the limit of terms to compute Pi.\n");
	scanf("%d", &limit);

	/** FUNCTION CALL HERE **/

	printf("Pi = %lf\n", Pi);
	return 0;
}//end main

/********************************************
* This function takes an integer for number*
* of terms to compute Pi and returns *
* Pi as a double. *
* *****************************************/

/*** FUNCTION GOES HERE (Put Loop inside function) ***/















Problem #3

Construct a program that uses two nested for loops to produce 10 lines of 10
integers that shows the row and column position. The first loop represents the rows
and the nested loop represents each column in a row. The first number is the row
and the second is the column position. (No skeleton code provided).
Your output should look something like this:

[0,0] [0,1] [0,2] [0,3] [0,4] [0,5] [0,6] [0,7] [0,8] [0,9]
[1,0] [1,1] [1,2] [1,3] [1,4] [1,5] [1,6] [1,7] [1,8] [1,9]
[2,0] [2,1] [2,2] [2,3] [2,4] [2,5] [2,6] [2,7] [2,8] [2,9]
[3,0] [3,1] [3,2] [3,3] [3,4] [3,5] [3,6] [3,7] [3,8] [3,9]
[4,0] [4,1] [4,2] [4,3] [4,4] [4,5] [4,6] [4,7] [4,8] [4,9]
[5,0] [5,1] [5,2] [5,3] [5,4] [5,5] [5,6] [5,7] [5,8] [5,9]
[6,0] [6,1] [6,2] [6,3] [6,4] [6,5] [6,6] [6,7] [6,8] [6,9]
[7,0] [7,1] [7,2] [7,3] [7,4] [7,5] [7,6] [7,7] [7,8] [7,9]
[8,0] [8,1] [8,2] [8,3] [8,4] [8,5] [8,6] [8,7] [8,8] [8,9]
[9,0] [9,1] [9,2] [9,3] [9,4] [9,5] [9,6] [9,7] [9,8] [9,9]



















Problem #2

Write a program that uses nested loops to produce the following pattern. The outer
loop will produce the lines and the inner loop the column values. Think about how
the numbers are descending. (No skeleton code provided)

Sample Output:

1  2  3  4  5  6  7  8  9
1  2  3  4  5  6  7  8
1  2  3  4  5  6  7
1  2  3  4  5  6
1  2  3  4  5
1  2  3  4
1  2  3
1  2
1































Problem #4
Compose a program with a function that is called recursively to
count backward from the number 10, printing each iteration to
screen. The output might look something like this:

T Minus: 10
T Minus:  9
T Minus:  8
T Minus:  7
T Minus:  6
T Minus:  5
T Minus:  4
T Minus:  3
T Minus:  2
T Minus:  1
T Minus:  0
Blast off!!!



/*** SKELETON CODE ***/

#include <stdio.h>

void CountDown(int);

int main(void)
{
	int countFrom = 10;
	CountDown(countFrom);
	return 0;
}//end main

void CountDown(int nbrIn)
{
	/*** DO RECURSION HERE ***/

	return;
}




















Recursion examples (NOT PRACTICE PROBLEMS)


/**** FACTORIAL EXAMPLE WITHOUT RECURSION ****/

/***********************************************
* This program computes Factorials. *
* By: Larry Snedden *
**********************************************/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

double compute_Factorial(int);

int main(void)
{
	int limit;

	printf("Enter the number factorial to compute.\n");
	scanf("%d", &limit);

	printf("Factorial of %d is %.2lf\n",limit,compute_Factorial(limit));

	return 0;
}//end main

/********************************************
* This function takes an integer for number*
* of terms to compute n and returns *
* n as a double. *
* *****************************************/
double compute_Factorial(int n)
{
	double factorial = 1;
	int i = 1;

	for(;i <= n; ++i) {
		factorial *= i;
	}

	return factorial;
}//end compute_Factorial








/**** FACTORIAL EXAMPLE WITH RECURSION ****/

/* Test driver for recursive factorial.
Modified by: L. Snedden
Date: 3/2/2020
*/
#include <stdio.h>
#include <stdbool.h>
long factorial (long n);

int main (void)
{
	//Local Statements
	int limit;

	printf("Enter the number factorial to compute.\n");
	scanf("%d", &limit);

	printf("Factorial %d is: %ld\n", limit, factorial (limit));

	return 0;
} /* main */

long factorial (long n)
{
	//Local Statements
	if (n == 0)
		return 1;
	else
		return (n * factorial (n - 1));
} // factorial

/* Results:
	Factorial 5 is: 120
*/






/**** EXAMPLE OF STACK OVERFLOW ****/

//RUN THIS ON OSPREY, NOT REPLIT

/*
* There are many ways to run out of stack and heap memory.
* This is just one example of recursing until the process stack
* overflows. Modern operating systems now can contain this and
* avoid crashing the system.
* By: Larry Snedden
*/
#include <stdio.h>

int StackOverflow(int);

int main(void)
{
	int n = StackOverflow(n);
	return 0;
}//end main

int StackOverflow(int n)
{
	printf("In the %d recursing function.\n", n);
	StackOverflow(n + 1);
	return 1;//never reduces never reaches a base case
}