HansJack

#include <stdio.h>
int main()
{
	printf("Hello World!\n");

	return 0;
}

#include <stdio.h>
int main()
{	// Declaration
	int number = 123;
	// Definition
	printf("%d\n", number);
	// Assignment
	return 0;
}	// Instructor Frank_PPT also discussed the use of the TAB key and tab characters in this section

identifier:
	nondigit
 	identifier
	digit

nondigit:
 	_ a b c d e f g h i j k l m n o p q r s t u v w x y z
 	A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

digit:
 	0 1 2 3 4 5 6 7 8 9

add
ADD
Add
aDD

j
count
temp1
top_of_page
skip12
LastNum

// Line
    Comment

/*
        Block
    Comment
    Comment
*/

// int variable
#include <stdio.h>

int main(){
	// integer assignment
	int sun_flower = 9673;

	printf("The current value of sunshine: %d\n", sun_flower);

	return 0;
}

#include <stdio.h>
int main()
{
	int number = 100;
	// Represented in decimal
	printf("Decimal: %d\n", number);

	printf("Octal: %o\n", number);

	printf("Hexadecimal (lowercase): %x\n", number);

	printf("Hexadecimal (uppercase): %X\n", number);

	return 0;
}

#include <stdio.h>

int main() {

	float temperature = 36.5f;

	float humidity = 48.3f;

	float speed_of_sound = 343.5e2f;

	float length = 12.3f, width = 23.45f, height = 34.56f;

	printf("Temperature: %f\n", temperature);
	printf("Humidity: %f\n", humidity);
	printf("Speed of Sound: %f\n", speed_of_sound);
	printf("Length: %f x %f x %f\n", length, width, height);
// Loss of precision
// double %lf, float %f
	return 0;
}

#include <stdio.h>

int main () {

float num = 123.456;

printf("Using %%f: %f\n", num);

// %e %E scientific notation formatted output
printf("Using %%e: %e\n", num);
printf("Using %%E: %E\n", num);

// %a %A hexadecimal floating point p notation
printf("Using %%a: %a\n", num);
printf("Using %%A: %A\n", num);

return 0;
}

#include <stdio.h>
#include <float.h>// Open to see

int main() {

	float max_float = FLT_MAX;

	float overflow = max_float * 1000.0f;
	// OverFlow overflow

	float min_float = FLT_MIN;

	float underflow = min_float / 1000.0f;
	// UnderFlow underflow

	printf("Maximum Float: %e\n", max_float);
	printf("OverFloat: %e\n", overflow);
	printf("Minimum Float: %e\n", min_float);
	printf("UnderFloat: %e\n", underflow);

	return 0;
}

#include <stdio.h>
#include <float.h>
#include <math.h>

int main() {

	// Positive infinity
	float positive_infinity = INFINITY;
	printf("Positive Infinity: %f\n", positive_infinity);

	// Negative infinity
	float negative_infinity = -INFINITY;
	printf("Negative Infinity: %f\n", negative_infinity);

	// Division by 0 results in infinity
	float num = 1.0f;
	float infinity = num / 0.0f;
	printf("0.0 / 0.0 = %f\n", nan);

	// Nan 0/0
	// float nan = 0.0f / 0.0f;
	// printf("0.0f / 0.0f =%f\n", nan)

	// Square root of negative number
	float negative_sqrt = sqrt(-1.0f);
	printf("sqrt(1.0f) = %f\n", negative_sqrt);

	return 0;
}

#include <stdio.h>

int main() {

	// Round half away from zero
	// IEEE 754
	// Round to nearest, ties to even
	// Banker's rounding

	// 3.14159
	float number = 3.14159f;
	printf("%.4f\n", number);

	// 3.15
	// 3.25
	return 0;
}

#include <stdio.h>

int main() {

	// double

	// float loss of precision

	// 3D rendering

	// Interest NASA

	// Floating point constant 3.14
	// 3.14 defaults to double type, specifically noted as 3.14f

	return 0;

}

#include <stdio.h>

int main() {
 
	float float_num = 1.0 / 3.0;
	double double_num = 1.0 / 3.0;

	printf("Float precision: %20f\n", float_num);
	printf("Double precision: %.20lf\n", double_num);
	// Comparison of effective precision between float and double
	printf("Defined max precision for double: %d\n", FLT_DIG);
	printf("Defined max precision for float: %d\n", DBL_DIG);

	// 53 divided by log₂10  24 divided by log₂10  is the precision

}

#include <stdio.h>

int main() {

	char mych = 'a'; // Actually stored as int type, converting A to int type int(97)

	printf("mych: %c\n");

	// ASCII American Standard Code for Information Interchange generally uses 7 bits including 128 characters

}

Clear screen print("\033[2J");
Move cursor print("\033[%d;%dH", 3, 3);

#include <stdio.h>
#include <stdbool.h>

int main() {
	// true or false
	// Convert to 1 or 0

	bool is_game_win = true;
	bool is_game_over = false;

	return 0;
}

#include <stdio.h>
#define PI 3.14

int main() {
	// Constants

	const double MAX_USER = 100;

	printf("PI: %lf\n", PI);

	return 0;

}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
int main() {

	// Data objects
	// Lvalue
	// Rvalue
	// Operators
	uint32_t apple_box = 5;

	uint32_t orange_box = 5;

	printf("There are %" PRIu32 " apples in the apple box\n", apple_box);
	printf("There are %" PRIu32 " oranges in the orange box\n", orange_box);

	uint32_t total_fruit = apple_box + orange_box;

	printf("There are %" PRIu32 " fruits in the box\n", total_fruit);
 
	return 0;

}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
int main() {

	int32_t value = 5;
	int32_t result_1;
	int32_t result_2;

	// Postfix increment, assign first, then ++
	result_1 = value++;
	// Prefix decrement, -- first, then assign
	result_2 = --value;
	printf("After postfix increment, result_1 = %" PRIu32 ", result_2 = %" PRIu32 ", value = %" PRIu32 "\n", result_1, result_2, value);

	return 0;

}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>

int main() {

	uint8_t num = 22;
	num >> 2; // High bits are filled with zero, low bits are pushed out

	return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>

int main() {

	uint8_t num = 22;
	// num >> 2; High bits are filled with zero, low bits are pushed out

	uint8_t num = 22;
	printf("Original number: %" PRIu8 " (binary: 00010110)\n", num);

	uint8_t left_shifted = num << 2;
	printf("Left shifted by 2: %" PRIu8 " (binary: 01011000)\n", left_shifted);

	uint8_t right_shifted = num >> 2;
	printf("Right shifted by 2: %" PRIu8 " (binary: 00000101)\n", right_shifted);

	return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>

int main() {

	uint8_t num = 25;

	// uint32_t result = num * 1024;
	printf("Result: %" PRIu32 "\n", result);
	// ALU is responsible for basic operations

	return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>

int main() {

	int a = 10;
	int b = 20;
	// xxx ? xxx : xxx to determine true or false
	bool greater = a > b;
	printf("a > b: %d\n", greater);
	printf("a > b: %s\n", greater ? "true" : "false");

	bool less = a < b;
	printf("a < b: %d\n", less);
	printf("a < b: %s\n", less ? "true" : "false");

	bool not_equal = a != b;
	printf("a != b: %d\n", not_equal);
	printf("a != b: %s\n", not_equal ? "true" : "false");

	bool equal = a == b;
	printf("a == b: %d\n", equal);
	printf("a == b: %s\n", equal ? "true" : "false");

	bool greater_or_equal = a >= b;
	printf("a >= b: %d\n", greater_or_equal);
	printf("a >= b: %s\n", greater_or_equal ? "true" : "false");

	bool less_or_equal = a <= b;
	printf("a <= b: %d\n", less_or_equal);
	printf("a <= b: %s\n", less_or_equal ? "true" : "false");

	return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>

int main() {

	int score = 89;

	printf("Your score level: %s\n", score >= 60 ? "Pass" : "Fail");

	return 0;
}

#include <stdio.h>
int main() { 
	int score = 85; 
	// You can modify this score as needed 
	const char* result = (score >= 90) ? "Excellent" : (score >= 85) ? "Good" : (score >= 60) ? "Pass" : "Fail"; 
	printf("%s\n", result); 

	return 0; 
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>

int main() {

	int a = 12;
	int b = 25;

	// & Binary bit comparison, only outputs 1 if both are 1, for example
	printf("%d\n", 12 & 25);
	// Clear specific bits, check if a certain bit is 1

	return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>

int main() {

	int a = 2;
	int b = 5;

	// | Binary bit comparison, outputs 1 if there is a 1, for example 0111 
	printf("%d\n", a | b);
	// Set specific bits, combine flag bits

	return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>

int main() {

	int a = 2;
	int b = 10;

	// ^ Binary bit comparison, outputs 1 if one is 1 and the other is 0, for example 1000 
	printf("%d\n", a ^ b);
	// Logical XOR operation
	// Flip specific bits, swap two variable values, check differences

	return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>

void print_binary(uint8_t num);

int main() {

	uint8_t status = 0b00001100;	// Initial status

	printf("Initial status: 0b");
	print_binary(status);
	printf("\t(Binary)\n");

	status = status & 0b11111011;	// Mask control
	printf("Final status: 0b");
	print_binary(status);
	printf("\t(Binary)\n");
	return 0;
}

void print_binary(uint8_t num) {
	for (int index = 7; index >= 0; index--) {
	    printf("%d", (num >> index) & 1);
	}
}

#include <stdio.h>
/*
struct BigStruct {
	//..
	//..
};

void update(BigStruct& bs) {
	BigStruct temp = someExp();

	bs = bs + temp;

	bs += temp;

}
*/


int main() {

	int base_number = 8;
	int add_number = 2;
	int sub_number = 3;
	int mul_number = 2;
	int div_number = 5;
	int mod_number = 4;

	base_number += add_number;
	// In-place Modification

	base_number -=
	base_number *=
	base_number /=
	base_number %=
	base_number <<=
	base_number >>=
	base_number &=
	base_number |=
	base_number ^=

	return 0;

}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>

int main() {

	uint32_t a = 1, b = 2, c = 4;

	uint32_t result = (a += 1, b -= 1, c += 3);

	printf("a = %d, b = %d, c = %d, result = %d", a, b, c, result);

	return 0;

}

// cpp_comma_operator.cpp
#include <stdio.h>
int main () {
   int i = 10, b = 20, c= 30;
   i = b, c;
   printf("%i\n", i);

   i = (b, c);
   printf("%i\n", i);
}

20
30

func_one( x, y + 2, z );
func_two( (x--, y + 2), z );

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>

int main() {

	int32_t result;

	result = a * b + c << d > e ? b : c * sizeof(++e) / sizeof(int32_t);

	printf("Result: %" PRId32 ", result);

	return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>

int main() {

	uint32_t number = 100;

	// if statement
	if (number > 10) {
		printf("This number is greater than 10!\n");
		printf("This number is greater than 10!\n");

	}

	if (number >= 100) {
		printf("This number is greater than or equal to 100!\n");

	} 
	else {
		printf("This number is less than 100!\n");

	}


	return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>

int main() {

	bool is_weather_sunny = false;
	bool is_venue_available = true;

	if (is_weather_sunny && is_venue_available) {
		printf("The event will proceed as scheduled!\n");
	}
	else {
		printf("The event cannot proceed as scheduled!\n");
		if (!is_weather_sunny) {
			printf("Reason: The weather is not sunny!\n");
		}
		if (!is_venue_available) {
			printf("Reason: No venue available!\n");
		}
	}

	return 0;
}

// Vending machine
// Only supports coins
#include <stdio.h>
#include <stdbool.h>
#include <inttypes.h>

int main(void)

{

	const uint32_t PRICE = 3;	// drink's price

	uint32_t balance = 0;		// now total_coin

	uint32_t coin;				// every coin in it

	puts("Drink's price is $5 please!");

	while (balance < PRICE)	// Before enough amount is entered
	{
		puts("Don't!");	// Refuse transaction

		scanf_s("%" PRIu32, &coin);


		if (coin == 1 || coin == 2 || coin == 5) // Determine coin type
		{
			balance += coin;	// Assign and add

			printf("You have inserted $%" PRIu32 "\n", balance);
		}
		else {

			printf("Sorry! We do not accept $%" PRIu32 " coins\n", coin);
		}
	}

	if (balance > PRICE) {
		printf("Change: %" PRIu32 "\n", balance - PRICE);
	}
	return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <inttypes.h>

int main(void)
{

	// Player enters different conditions of rooms

	uint32_t coins = 15;
	bool is_vip = true;
	bool have_special_tool = false;

	if (is_vip) {
		puts("VIP Enter!\n");
	}
	else {
		puts("Not VIP Exit!\n");
	}

	if (coins >= 10 || have_special_tool) {
		puts("Enter!\n");
	}
	else {
		puts("Exit!\n");
	}
	return 0;
}

#include <stdio.h>
#include <stdbool.h>
#include <inttypes.h>

int main(void)
{
	const uint32_t all_laps = 100;

	uint32_t current_laps = 0;

	puts("Start!");

	while (current_laps < all_laps)
	{
		current_laps++;

		printf("Completed lap %" PRIu32 ".\n", current_laps);
	}
	return 0;
}

// Vending machine
// Only supports coins
#include <stdio.h>
#include <stdbool.h>
#include <inttypes.h>

int main(void)

{

	const uint32_t price = 10;	// drink's price

	uint32_t balance = 0;		// now total_coin

	uint32_t coin;				// every coin in it

	puts("Drink's price is $5 please!");

	while (balance < price)	// Only start the loop when enough amount is entered
	{
		puts("Don't!");	// Refuse transaction

		// Simulate coin insertion
		scanf_s("%" PRIu32, &coin);


		if (coin == 1 || coin == 2 || coin == 5) // Determine coin type
		{ 
			balance += coin;	// Assign and add
			printf("You have inserted $%" PRIu32 "\n", balance);
		}
		else {
			printf("Sorry! We do not accept $%" PRIu32 " coins\n", coin);
		}
	}

	if (balance > price) {
		printf("Change: %" PRIu32 "\n", balance - price);
	}
	return 0;
}

// Be sure to write printf to see the effect.

// When encountering loop problems
// Do not apply multiple times in the loop to avoid unnecessary errors

// Write a program to calculate the sum

#include <stdio.h>
#include <inttypes.h>

int main(void)
{
	uint32_t sum = 0;	// Set initial sum to 0

	uint32_t number = 1;	// First value of number

	while (number != 0)	// Set 0 as the method to exit the loop
	{
		scanf_s("%" PRIu32, &number);	// scanf reassigns number, the first value of number is actually not used.
		sum += number;
	}

	printf("The sum is %" PRIu32 "\n", sum);

	return 0;
}

#include <stdio.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h>
#include <limits.h>
#include <errno.h>

int main()
{
	uint32_t sum = 0;	// Set initial sum to 0

	char input[50];	// We will convert the user's input character to a number

	char* end;

	puts("Please enter a series of numbers, separated by enter, we will calculate their sum, output q to end");

	while (true)	// Set 0 as the method to exit the loop
	{
		errno = 0;

		puts("Enter a number:");

		scanf_s(" %49s", &input, 50);

		if (input[0] == 'q' && input[1] == '\0') {
			break;
		}

		long number = strtol(input, &end, 10);
		// Convert the input character to a number and add it to the total sum
		// The ASCII for 0 is 48
		if (end == input || *end != '\0') {
			printf("Invalid input, please enter a number or character q\n");

		}
		else if (errno == ERANGE || number < 0 || number > UINT32_MAX){
			printf("Number out of range! Please enter a positive integer less than or equal to %u\n", UINT32_MAX);
		}
		else {
			sum += (uint32_t)number;
		}

	}

	printf("The sum is %" PRIu32 "\n", sum);

	return 0;
}

#include <stdio.h>
#include <inttypes.h>
#include <stdbool.h>

int main()
{
	uint32_t sum = 0;	// Set initial sum to 0

	uint32_t number;	// First value of number

	puts("Please enter a series of numbers, separated by enter, we will calculate their sum, output 0 to end");

	while (true)	// Set 0 as the method to exit the loop
	{

		scanf_s(" %" PRIu32, &number);

		if (number == 0) {
			break;
		}

		sum += number;
	}

	printf("The sum is %" PRIu32 "\n", sum);

	return 0;
}

// Use of guard clauses: car rental case
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <inttypes.h>

void check_car_rent(uint8_t age, uint8_t driving_exp_years);

int main(void) 
{
	check_car_rent(22, 3);

	return 0;
}

void check_car_rent(uint8_t age, uint8_t driving_exp_years) {
// Guard clause
	if (age < 21) {
		puts("Does not meet the criteria, age is insufficient!");
		return;
	}

	if (driving_exp_years < 1) {
		puts("Does not meet the criteria, driving experience is insufficient!");
		return;
	}
}

// Simplifying logical expressions
#include <stdbool.h>
#include <inttypes.h>

int main(void) 
{
	// Logical expressions should be simplified!
	bool is_weekend = true;
	bool has_enter = true;

	if (!has_enter) {
		return 0;
	}

	return 0;
}

#include <stdbool.h>
#include <inttypes.h>

int main(void)
{
	// State machine: managing complex state transitions using switch case

	uint8_t traffic_state = 0;

	switch (traffic_state)
	{
	case 0:
		puts("red");
		traffic_state = 1;
		break;
	case 1:
		puts("yellow");
		traffic_state = 2;
		break;
	case 2:
		puts("green");
		traffic_state = 0;
		break;
	default:
		puts("???");
		break;
	}

	return 0;
}

// Difference Between switch-case and if-else
#include <stdio.h>
#include <stdbool.h>
#include <inttypes.h>

int main(void)
{


	return 0;
}

// The Role of Loops in Life

#include <stdio.h>
#include <stdbool.h>
#include <inttypes.h>

int main(void)
{
	int32_t number;

	scanf_s("Please enter: %d %d %d", &number, &number, &number);// Do not use scanf in actual development
	// not write \n in it
	printf("The numbers you entered are: %d %d %d\n", number, number, number);

	return 0;
}

// The Difference Between do-while and while

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>

int main(void)
{
	uint32_t total_laps = 10;

	uint32_t current_laps = 0;

	puts("Penalty running starts!");

	do {

		current_laps++;
		printf("The runner completed lap %" PRIu32 "\n", current_laps);
	} while (current_laps < total_laps);

	return 0;
}

// The Practical Role of do-while

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>

int main(void)
{

	uint32_t choice;

	do 
	{

		puts("**** Main Menu ****");
		puts("1. New Game");
		puts("2. Load Game");
		puts("3. Exit");
		scanf_s("%" PRIu32, &choice);

		switch (choice) 
		{
		case 1:
			puts("**** Creating a new game!");
			break;
		case 2:
			puts("**** Loading saved game!");
			break;
		case 3:
			puts("**** Exiting the game!");
			break;
		}

	} while (choice != 3);

	return 0;

}

// Random Number Guessing Game Case
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <time.h>
#include <stdlib.h>

int main(void)
{
	uint32_t secret_num, guess, status;
	char buffer[50];

	srand(time(NULL));
	// Generate a random number between 1-100
	secret_num = rand() % 100 + 1;

	puts("Take a guess!");

	do {
		puts("Please enter your guess:");

		fgets(buffer, sizeof(buffer), stdin);
		status = sscanf_s(buffer, "%d", &guess);
		// Guard clause
		if (status != 1) {
				puts("Invalid input!");
				continue;
		}

		if (guess < secret_num) {
			puts("Too low!");
		}
		else if (guess > secret_num) {
			puts("Too high!");
		}

	} while (guess != secret_num);

	printf("Congratulations, you guessed it right!");

	return 0;
}

// Continue Statement
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main(void) {

	uint32_t sum = 0;
	int32_t number;

	puts("Please enter a series of positive integers, you can enter a negative number, enter 0 to end");

	while (1) {
		puts("Please enter a number");

		scanf_s("%d", &number);

		if (number == 0) {
			break;
		}
		if (number < 0) {
			continue;	// Continue directly skips this loop
		}
		sum += number; // Count
	}
	printf("The result is: %" PRIu32 "\n", sum);

	return 0;

}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
int main() {
    uint32_t number;
    
    puts("Please enter a number (0-100), enter -1 to end the program");
    
    while (1) {
        puts("Please enter a number:");
        scanf_s("%d", &number);
        // Guard clause! Check condition to end
        if (number == -1) {
            break;
        }
        if (number < 0 || number > 100) {
            continue; // Skip the remaining part of this loop.
        }
        sum += number;
    }
    
    return 0;
}

// Introduction to for Loop
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main(void)
{
	// for loop
	const uint32_t total_laps = 10;	// Target laps

	// uint32_t current_lap = 0;	Initialize current lap

	puts("The runner starts running");

	for (uint32_t current_lap = 0; current_lap <= total_laps; current_lap++) {
		printf("The runner completed lap %" PRIu32 " \n", current_lap);
	}

	return 0;

}

// Sum of Squares of Integers
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main(void)
{
	 /*
		To calculate the sum of squares of all integers from 1 to n (n entered by the player)

	 */
	uint32_t number;

	uint32_t sum_of_squares = 0;

	puts("Enter integer n");

	scanf_s("%u", &number);

	for (uint32_t index = 1; index <= number; index++) {
		sum_of_squares += index * index;
	}

	printf("%" PRIu32 "\n", sum_of_squares);
	return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main(void) {

	/*
		Star Avenue
		Countdown from five
	*/

	uint32_t start_number;
	
	puts("Please enter a positive integer");
	scanf_s("%" SCNu32, &start_number);

	puts("The countdown begins");
	for (uint32_t index_number = start_number; index_number > 0; index_number--)
	{
		printf("%" SCNu32 "\n", index_number);
	}
	puts("The countdown stops");
	return 0;
}

// Extended sleep
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <windows.h>

int main(void) 
{

	/*
		Star Avenue
		Countdown from five
	*/

	uint32_t start_number;
	
	puts("Please enter a positive integer");
	scanf_s("%" SCNu32, &start_number);

	puts("The countdown begins");
	for (uint32_t index_number = start_number; index_number > 0; index_number--)
	{
		printf("%" SCNu32 "\n", index_number);
        Sleep(1000);
	}
	puts("The countdown stops");
	return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <windows.h>
// Factorial

int main(void) {

	uint32_t number;
	uint32_t factorial = 1;

	puts("Please enter a positive integer:");
	scanf_s("%" SCNu32, &number);

	for (uint32_t index = 1; index <= number; index++) {
		factorial *= index;
	}

	printf("%" PRIu32 "! = %" PRIu32 "\n", number, factorial);

	return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <math.h>
#include <stdbool.h>

int main(void)
{
	double number = 4.00;

	printf("%lf\n", sqrt(121));

	return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <math.h>
#include <stdbool.h>

int main(void)
{
	uint32_t num;

	bool is_prime = true;

	puts("Please enter a positive integer, except for 1, we will check if it is prime:");

	scanf_s("%" SCNu32, &num);

	if (num <= 1) {
		is_prime = false;
	}
	else {
		// for, check factors other than 1 and itself
		for (uint32_t i = 2; i * i <= num; i++) {
			if (num % i == 0) {
				is_prime = false;
				break;
			}
		}
	}
	return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <math.h>
#include <stdbool.h>

int main(void)
{
	uint32_t size;
	puts("Please enter the size of the pattern: ");
	scanf_s("%" SCNu32, &size);

	// Characteristics: length and width are the same
	puts("Printing square pattern");

	for (uint32_t i = 0; i < size; i++) {
		for (uint32_t j = 0; j < size; j++)
		{
			printf("* ");
		}
		printf("\n");
	}
	return 0;
}