Upload batch 36/306

שנה א/מבוא למדעי המחשב/עבודות בית/פתרונות לעבודות/מטלה-12.c

@@ -0,0 +1,172 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define R 3
+#define C 3
+#define N 3
+
+void inputFromUserToMat(int mat[R][C]) {
+	printf("---Matrix Input---\nMatrix size: %dx%d\nRows: %d, Columns: %d\nTotal number: %d\n", R, C, R, C, R * C);
+	for (int i = 0; i < R; i++)
+	{
+		for (int j = 0; j < C; j++)
+		{
+			printf("Now insteting into mat[%d][%d], Enter value:", i + 1, j + 1);
+			scanf_s("%d", &mat[i][j]);
+		}
+	}
+}
+
+void printMat(int mat[R][C]) {
+	for (int i = 0; i < R; i++)
+	{
+		printf("[");
+		for (int j = 0; j < C; j++)
+		{
+			if (j + 1 == C)
+				printf("%d", mat[i][j]);
+			else
+				printf("%d,", mat[i][j]);
+		}
+		printf("]\n");
+	}
+}
+
+void matCalculate(int Mat[R][C], int* sum, int* mul, double* avg) {
+	for (int i = 0; i < R; i++)
+	{
+		for (int j = 0; j < C; j++)
+		{
+			*sum += Mat[i][j];
+			*mul *= Mat[i][j];
+		}
+	}
+	*avg = (double)*sum / (R * C);
+}
+
+void calcDiagonals(int Mat[N][N], int* sumMain, int* sumSecondary) {
+	for (int i = 0; i < N; i++)
+	{
+		for (int j = 0; j < N; j++)
+		{
+			if (i == j)
+				*sumMain += Mat[i][j];
+			if (i + j == N - 1)
+				*sumSecondary += Mat[i][j];
+		}
+	}
+}
+
+int rowInMat(int Mat[R][C], int arr[R]) {
+	int i = 0; // Row index
+	int low, high; // Pointers for binary search
+	int found; // Flag to check if the element is found in the current row
+
+	while (i < R) { // Loop through each row of the matrix
+		int curNumber = arr[i]; // The target number to search for in row i
+		low = 0; // Initialize the low pointer for binary search
+		high = C - 1; // Initialize the high pointer for binary search
+		found = 0; // Reset found flag for each row
+
+		// Perform binary search on the current row
+		while (low <= high) {
+			int mid = (low + high) / 2; // Find the middle element
+
+			if (Mat[i][mid] == curNumber) { // Check if mid element matches curNumber
+				found = 1; // Mark the number as found
+				break; // Exit the binary search loop
+			}
+
+			if (Mat[i][mid] < curNumber) {
+				low = mid + 1; // Search in the right half
+			}
+			else {
+				high = mid - 1; // Search in the left half
+			}
+		}
+
+		// If the number was not found in the current row, return 0
+		if (!found) return 0;
+
+		// Move to the next row
+		i++;
+
+		// Reset binary search pointers for the next row
+		low = 0;
+		high = C - 1;
+	}
+
+	// If all rows satisfy the condition, return 1
+	return 1;
+}
+
+// Function to shift each row of a matrix one position to the right
+void turnMatToRight(int Mat[R][C]) {
+	for (int i = 0; i < R; i++) { // Loop through each row
+		int last = Mat[i][C - 1]; // Save the last element of the current row
+
+		// Shift elements of the row to the right, starting from the end
+		for (int j = C - 1; j > 0; j--) { // Start at the last column and move backward
+			Mat[i][j] = Mat[i][j - 1]; // Move each element to the next position
+		}
+
+		// Place the saved last element at the first position of the row
+		Mat[i][0] = last;
+	}
+}
+
+
+int main()
+{
+	// 1
+	//int mat[R][C]; 
+	//inputFromUserToMat(mat);
+	//printMat(mat);
+
+	// 2
+	//int Mat[R][C]; 
+	//inputFromUserToMat(Mat);
+	//int sum = 0, mul = 1;
+	//double avg = 0;
+	//matCalculate(Mat, &sum, &mul, &avg);
+	//printf("Sum: %d, Mul: %d, Avg: %.2lf", sum, mul, avg);
+
+	// 3
+	//int Mat[N][N] = {
+	//	{9,2,1},
+	//	{3,6,3},
+	//	{7,2,1}
+	//};
+	//int sumMain = 0, sumSecondary = 0;
+	//calcDiagonals(Mat, &sumMain, &sumSecondary);
+	//printf("sumMain : %d, sumSecondary : %d",sumMain, sumSecondary);
+
+	// 4
+	//int M[3][3] = {
+	//{2, 4, 9},
+	//{3, 7, 11},
+	//{1, 2, 3}
+	//};
+	//int arr[3] = { 4, 7, 1 };
+
+	//printf("%d\n", rowInMat(M, arr));
+
+	//int M1[3][3] = {
+	//{2, 4, 9},
+	//{3, 7, 11},
+	//{1, 2, 3}
+	//};
+	//int arr1[3] = { 4, 7, 5 };
+
+	//printf("%d\n", rowInMat(M1, arr1));
+
+	// 5
+	//int M[3][3] = {
+	//{2, 4, 9},
+	//{3, 7, 11},
+	//{1, 2, 3}
+	//};
+	//turnMatToRight(M);
+	//printMat(M);
+	return 0;
+}

שנה א/מבוא למדעי המחשב/עבודות בית/פתרונות לעבודות/מטלה-2.c

@@ -0,0 +1,164 @@
+#include <stdio.h>
+#include <math.h>
+
+// Function to calculate and print the diagonal of a square given its side length
+void printDiagonal() {
+    double side = 0;
+    double diagonal;
+    printf("Please enter length of square side:\n");
+    scanf_s("%lf", &side);
+
+    if (side > 0) {
+        diagonal = sqrt((side * side) + (side * side));
+        printf("Diagonal length is: %.2lf\n", diagonal);
+    }
+    else {
+        printf("Enter a valid number (greater than 0)\n");
+    }
+}
+
+// Function to calculate and print the perimeter, area, and volume of a circle/sphere given its radius
+void printPerimeter() {
+    double PI = 3.141592;
+    double radius = 0, perimeter, area, volume;
+    printf("Enter radius of circle:");
+    scanf_s("%lf", &radius);
+    if (radius > 0) {
+        perimeter = 2 * PI * radius;
+        area = PI * radius * radius;
+        volume = radius * radius * radius * PI * (4.0 / 3.0);
+        printf("Volume = %.2lf, Perimeter = %.2lf, Area = %.2lf", volume, perimeter, area);
+    }
+    else {
+        printf("Enter a valid number (greater than 0)\n");
+    }
+}
+
+// Function to calculate the nth element in an arithmetic sequence
+double calcAn(double a1, double d, int n) {
+    double an = 0;
+    if (d != 0.0 && n > 0) {
+        an = a1 + (d * (n - 1));
+    }
+    else {
+        printf("Enter a valid number (not 0)\n");
+    }
+    return an;
+}
+
+// Wrapper to prompt user and print the nth element of an arithmetic sequence
+void printNthElement() {
+    double a1 = 1, d = 0.0, an = 0;
+    int n = 1;
+
+    printf("Please enter a1, d, n:");
+    scanf_s("%lf %lf %d", &a1, &d, &n);
+
+    an = calcAn(a1, d, n);
+    printf("A%d = %.3lf", n, an);
+}
+
+// Function to calculate and print the sum of the first n elements in an arithmetic sequence
+void printSumElements() {
+    double a1 = 1, d = 0.0, sum = 0.0, an = 0.0;
+    int n = 1;
+
+    printf("Please enter a1, d, n:");
+    scanf_s("%lf %lf %d", &a1, &d, &n);
+
+    an = calcAn(a1, d, n);
+    sum = (n * (a1 + an)) / 2;
+    printf("S = %.3lf", sum);
+}
+
+// Function to calculate the nth element in a geometric sequence
+double calcAn1(double a1, double q, int n) {
+    double an = 0;
+    if (q != 0.0 && n > 0) {
+        an = a1 * pow(q, n - 1);
+    }
+    else {
+        printf("Enter a valid number (not 0)\n");
+    }
+    return an;
+}
+
+// Wrapper to prompt user and print the nth element of a geometric sequence
+void printNthElement1() {
+    double a1 = 1, q = 0.0, an = 0;
+    int n = 1;
+
+    printf("Please enter a1, q, n:");
+    scanf_s("%lf %lf %d", &a1, &q, &n);
+
+    an = calcAn1(a1, q, n);
+    printf("A%d = %.3lf", n, an);
+}
+
+// Function to calculate and print the sum of the first n elements in a geometric sequence
+void printSumElements1() {
+    double a1 = 1, q = 0.0, sum = 0.0, an = 0.0;
+    int n = 1;
+
+    printf("Please enter a1, q, n:");
+    scanf_s("%lf %lf %d", &a1, &q, &n);
+
+    an = calcAn1(a1, q, n);
+    sum = (a1 * (pow(q, n) - 1)) / (q - 1);
+    printf("S = %.3lf", sum);
+}
+
+// Function to calculate and print the sum of squares of digits for a three-digit number
+void printSumTri() {
+    int num = 0;
+    int n1, n2, n3, sum;
+    printf("Please enter a number between 100 - 999\n");
+    scanf_s("%d", &num);
+    if (num >= 100 && num <= 999) {
+        n1 = num % 10;
+        num /= 10;
+        n2 = num % 10;
+        num /= 10;
+        n3 = num % 10;
+        sum = pow(n1, 2) + pow(n2, 2) + pow(n3, 2);
+        printf("%d", sum);
+    }
+    else {
+        printf("Please enter a VALID number\n");
+    }
+}
+
+// Function to extract and print only the decimal part of a floating-point number
+void printAfterDecimal() {
+    double d = 0;
+    int whole = 0;
+    printf("Please enter a floating number\n");
+    scanf_s("%lf", &d);
+    whole = (int)d;
+    d = d - (double)whole;
+    printf("d = %.2lf", d);
+}
+
+// Function to calculate and print Bob's new salary based on previous salary and compensation
+void printBobSalary() {
+    double prevSalary = 0, compansation = 0, salary = 0;
+    printf("Please enter: previous salary, compensation\n");
+    scanf_s("%lf %lf", &prevSalary, &compansation);
+
+    salary = ceil((0.75 * prevSalary) + (0.1 * compansation));
+    printf("Bob's new salary: %.2lf", salary);
+}
+
+int main() {
+    // Uncomment a function call to test each assignment
+    //printDiagonal();
+    //printPerimeter();
+    //printNthElement();
+    //printSumElements();
+    //printNthElement1();
+    //printSumElements1();
+    //printSumTri();
+    //printAfterDecimal();
+    //printBobSalary();
+    return 0;
+}

שנה א/מבוא למדעי המחשב/עבודות בית/פתרונות לעבודות/מטלה-3.c

@@ -0,0 +1,235 @@
+#include <stdio.h>
+#include <math.h>
+
+// Function to print the absolute value of a number
+void absolute() {
+    double x = 0;
+    printf("Please enter a number:\n");
+    scanf_s("%lf", &x);
+    if (x > 0) {
+        printf("%lf\n", x);
+    }
+    else {
+        printf("%lf\n", -x);
+    }
+}
+
+// Function to calculate Alice's total payment with discounts based on the amount
+void printAlicePay() {
+    double price = 0, amount = 0, total = 0;
+    printf("Please enter: Price, Amount\n");
+    scanf_s("%lf %lf", &price, &amount);
+
+    if (amount >= 50) {
+        total = 0.5 * (price * amount);  // 50% discount
+    }
+    else if (amount >= 25) {
+        total = 0.8 * (price * amount);  // 20% discount
+    }
+    else if (amount > 10) {
+        total = 0.95 * (price * amount); // 5% discount
+    }
+    else {
+        total = price * amount;          // No discount
+    }
+    printf("Total is: %lf\n", total);
+}
+
+// Function to check if an integer is "valid" based on given conditions
+void printValidNumber() {
+    int num = 0;
+    int valid = -1;
+    printf("Please enter a positive integer\n");
+    scanf_s("%d", &num);
+
+    if (num % 2 == 0 && num % 3 == 0 && num % 5 != 0) {
+        valid = 1;
+    }
+    if (num % 2 != 0 && num % 7 != 0 && num % 11 != 0) {
+        valid = 1;
+    }
+    if (valid == 1) {
+        printf("Valid Number\n");
+    }
+    else {
+        printf("Invalid Number\n");
+    }
+}
+
+// Function to check if three numbers are "valid" based on divisibility rules
+void printVlaidTri() {
+    int num1, num2, num3;
+    printf("Enter three numbers:\n");
+    scanf_s("%d %d %d", &num1, &num2, &num3);
+
+    int valid = -1;
+    if ((num1 % num2 == 0 || num2 % num1 == 0) &&
+        (num1 % num3 == 0 || num3 % num1 == 0) &&
+        (num2 % num3 == 0 || num3 % num2 == 0))
+        valid = 1;
+
+    if (valid == 1)
+        printf("Valid Numbers\n");
+    else
+        printf("Invalid Numbers\n");
+}
+
+// Function to calculate and print a person's age based on birth date and today's date
+void printAge() {
+    int currYear = 2024, currMonth = 11, currDay = 13;
+    int birthYear = 0, birthMonth = 0, birthDay = 0, age = 0;
+    int hadBirthday = -1;
+
+    printf("Please enter: Birth year, Birth month, Birth Day\n");
+    scanf_s("%d %d %d", &birthYear, &birthMonth, &birthDay);
+
+    age = currYear - birthYear;
+
+    if (currMonth > birthMonth || (currMonth == birthMonth && currDay >= birthDay)) {
+        hadBirthday = 1; // Already had birthday this year
+        if (currMonth == birthMonth && currDay == birthDay) {
+            printf("Happy Birthday!\n");
+        }
+    }
+
+    if (hadBirthday == -1) age--;  // Decrease age if birthday hasn't occurred this year
+
+    printf("Your age is: %d\n", age);
+}
+
+// Function to determine the quadrant of a point (x, y)
+void printQuadrant() {
+    int x = 0, y = 0, quad = 0;
+    char xSign = ' ', ySign = ' ';
+
+    printf("Please enter: x, y:\n");
+    scanf_s("%d %d", &x, &y);
+
+    xSign = (x > 0) ? '+' : '-';
+    ySign = (y > 0) ? '+' : '-';
+
+    if (x > 0 && y > 0) quad = 1;
+    else if (x < 0 && y > 0) quad = 2;
+    else if (x < 0 && y < 0) quad = 3;
+    else quad = 4;
+
+    printf("(%d,%d) is in Quadrant %d (%c,%c)\n", x, y, quad, xSign, ySign);
+}
+
+// Function to calculate the distance between two points
+double getDistance() {
+    int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
+    double distance = 0;
+
+    printf("Please enter: x1, y1, x2, y2:\n");
+    scanf_s("%d %d %d %d", &x1, &y1, &x2, &y2);
+
+    distance = sqrt((pow(x1 - x2, 2)) + (pow(y1 - y2, 2)));
+    return distance;
+}
+
+// Function to solve a quadratic equation and print the roots
+void printTrinome() {
+    int a = 0, b = 0, c = 0;
+    double x1 = 0, x2 = 0, disc = 0;
+
+    printf("Please enter: a, b, c:\n");
+    scanf_s("%d %d %d", &a, &b, &c);
+
+    disc = b * b - 4 * a * c;
+
+    if (disc < 0) {
+        printf("There are no non-complex solutions\n");
+    }
+    else {
+        x1 = (-b + sqrt(disc)) / (2 * a);
+        x2 = (-b - sqrt(disc)) / (2 * a);
+        printf("The solutions are: x1 = %.2lf, x2 = %.2lf\n", x1, x2);
+    }
+}
+
+// Function to check if the given hypotenuse and height form a valid right-angle triangle
+void printRightAngleTri() {
+    double hypo = 0, height = 0, area = 0;
+    double disc = 0;
+
+    printf("Please enter: hypotenuse, height\n");
+    scanf_s("%lf %lf", &hypo, &height);
+
+    if (hypo <= 0 || height <= 0) {
+        printf("Please enter non-negative numbers\n");
+    }
+    else {
+        area = hypo * height * 0.5;
+        disc = hypo * hypo - 4 * height * height;
+        if (disc >= 0) {
+            printf("Valid Right-angle triangle, Area is: %lf\n", area);
+        }
+        else {
+            printf("Not a Right-angle triangle\n");
+        }
+    }
+}
+
+// Function to print the astrological sign based on the date
+void printAstrologicalSign() {
+    int day = 0, month = 0, year = 0;
+
+    printf("Please enter: Day, Month, Year\n");
+    scanf_s("%d %d %d", &day, &month, &year);
+
+    if ((month == 1 && day >= 20) || (month == 2 && day <= 18)) {
+        printf("Aquarius\n");
+    }
+    else if ((month == 2 && day >= 19) || (month == 3 && day <= 20)) {
+        printf("Pisces\n");
+    }
+    else if ((month == 3 && day >= 21) || (month == 4 && day <= 19)) {
+        printf("Aries\n");
+    }
+    else if ((month == 4 && day >= 20) || (month == 5 && day <= 20)) {
+        printf("Taurus\n");
+    }
+    else if ((month == 5 && day >= 21) || (month == 6 && day <= 20)) {
+        printf("Gemini\n");
+    }
+    else if ((month == 6 && day >= 21) || (month == 7 && day <= 22)) {
+        printf("Cancer\n");
+    }
+    else if ((month == 7 && day >= 23) || (month == 8 && day <= 22)) {
+        printf("Leo\n");
+    }
+    else if ((month == 8 && day >= 23) || (month == 9 && day <= 22)) {
+        printf("Virgo\n");
+    }
+    else if ((month == 9 && day >= 23) || (month == 10 && day <= 22)) {
+        printf("Libra\n");
+    }
+    else if ((month == 10 && day >= 23) || (month == 11 && day <= 21)) {
+        printf("Scorpio\n");
+    }
+    else if ((month == 11 && day >= 22) || (month == 12 && day <= 21)) {
+        printf("Sagittarius\n");
+    }
+    else if ((month == 12 && day >= 22) || (month == 1 && day <= 19)) {
+        printf("Capricorn\n");
+    }
+    else {
+        printf("Invalid date\n");
+    }
+}
+
+int main() {
+    // Uncomment the function you want to test
+    // absolute();
+    // printAlicePay();
+    // printValidNumber();
+    // printVlaidTri();
+    // printAge();
+    // printQuadrant();
+    // printf("Distance is: %lf\n", getDistance());
+    // printTrinome();
+    // printRightAngleTri();
+    // printAstrologicalSign();
+    return 0;
+}

שנה א/מבוא למדעי המחשב/עבודות בית/פתרונות לעבודות/מטלה-4.c

@@ -0,0 +1,357 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+void fizzBuzz() {
+	int n, i = 0;
+
+	printf("Please enter an Integer\n");
+	scanf_s("%d", &n);
+	for (i = 1; i <= n; i++) {
+		if (i % 15 == 0) {
+			printf("FizBuzz, ");
+		}
+		else if (i % 5 == 0) {
+			printf("Buzz, ");
+		}
+		else if (i % 3 == 0) {
+			printf("Fizz, ");
+		}
+		else {
+			printf("%d, ", i);
+		}
+	}
+}
+
+void range() {
+	int i, min = 0, max = 0, n = 0;
+	printf("Please enter an Integer (0-999)\n");
+	scanf_s("%d", &n);
+	if (n >= 0 && n < 1000) {
+
+		for (i = 0; i < 50; i++) {
+			min = i * 25;
+			max = (i + 1) * 25;
+			if (n >= min && n < max) {
+				printf("%d is between %d-%d", n, min, max);
+			}
+
+		}
+	}
+	else {
+		printf("Enter a valid a number");
+	}
+}
+
+void change() {
+	int n = 0, twenty = 0, ten = 0, five = 0, two = 0, one = 0;
+	printf("Please enter an Amount\n");
+	scanf_s("%d", &n);
+	while (n > 0) {
+		while (n % 20 != n) {
+			twenty++;
+			n -= 20;
+
+		}
+		while (n % 10 != n) {
+			ten++;
+			n -= 10;
+		}
+		while (n % 5 != n) {
+			five++;
+			n -= 5;
+		}
+		while (n % 2 != n) {
+			two++;
+			n -= 2;
+		}
+		while (n % 1 != n) {
+			one++;
+			n -= 1;
+		}
+	}
+	printf("Twenty:%d Ten:%d Five:%d Two:%d One:%d\n", twenty, ten, five, two, one);
+}
+
+oddNotDivisableBy3() {
+	int n = 0, i = 0, num = 0, sum = 0;
+	printf("Please enter a number:\n");
+	scanf_s("%d", &n);
+	for (i = 0; i < n; i++)
+	{
+		printf("Enter value:\n");
+		scanf_s("%d", &num);
+		sum += (num % 2 != 0 && num % 3 != 0) ? num : 0;
+	}
+	printf("The sum is: %d", sum);
+
+}
+
+int calc() {
+	int n = 0, i = 0, sumAddition = 0, sumMultiply = 1;
+	double result = 0;
+	printf("Please enter a number:\n");
+	scanf_s("%d", &n);
+
+	for (i = 1; i <= n; i++)
+	{
+		sumAddition += i;
+		sumMultiply *= i;
+	}
+	result = (double)sumMultiply / sumAddition;
+	printf("The result is:%lf", result);
+}
+
+void printNumbers() {
+	printf("Please enter numbers: (-1 to stop)\n");
+	int n = 0, amount = 0, min = 10000, max = -10000;
+	while (n != -1) {
+		scanf_s("%d", &n);
+		min = (n < min && n != -1) ? n : min;
+		max = (n > max && n != -1) ? n : max;
+		if (n != -1)amount++;
+	}
+	if (amount == 0) {
+		printf("0 numbers, no max nor min");
+	}
+	else {
+		printf("%d numbers, max = %d, min = %d", amount, max, min);
+	}
+}
+
+void decimalToBinary() {
+	// Variables:
+	// n - input number
+	// temp - temporary variable to preserve the input number
+	// msb - most significant bit position
+	// lsb - least significant bit position (always 0 in binary)
+	// i - loop variable
+	int n = 0, i, temp, msb = 0, lsb = 0;
+
+	// Prompt the user to enter a number
+	printf("Enter number\n");
+	scanf_s("%d", &n);
+
+	// Preserve the original number
+	temp = n;
+
+	// Find the position of the most significant bit (MSB)
+	while (n > 0) {
+		// 12,
+		n /= 2; // Divide by 2 to shift right
+		msb++;  // Increment MSB count
+	}
+
+	// Iterate from the MSB to the LSB to print binary digits
+	for (i = msb - 1; i >= lsb; i--) {
+		// Extract the bit at position i
+		if ((temp >> i) % 2 != 0) {
+			// If the bit is 1 (result is odd), print 1
+			printf("1, ");
+		}
+		else {
+			// If the bit is 0 (result is even), print 0
+			printf("0, ");
+		}
+	}
+}
+
+void sumN() {
+	int n = 0, i = 0;
+	double a1 = 0, q = 1;
+	double aN = 0, s = 0, qN = 1, qNminusOne = 1;
+	printf("Please enter: a1 (double), q (double), n (int):\n");
+	scanf_s("%lf%lf%d", &a1, &q, &n);
+	printf("%lf %lf %d\n", a1, q, n);
+	for (i = 1; i <= n; i++)
+	{
+		qN *= q;
+		if (i != n)
+			qNminusOne *= q;
+	}
+	aN = a1 * qNminusOne;
+	s = (double)(a1 * (qN - 1)) / (q - 1);
+	printf("A%d = %.1lf,S = %.1lf", n, aN, s);
+
+}
+
+void sumOdd() {
+	int n = 0;
+	int upper = 2, lower = 3;
+	double s = 1;
+	printf("Please enter a number:\n");
+	scanf_s("%d", &n);
+
+	if (n % 2 == 0) {
+		printf("Enter an odd number\n");
+		return;
+	}
+	while (lower <= n) {
+		s += (double)upper / lower;
+		upper += 2;
+		lower += 2;
+	}
+	printf("%lf", s);
+
+}
+
+void printPositions() {
+	int n = 0, min = 10, max = -10, minP = -1, maxP = -1;
+	int i = 0, num = 0;
+	printf("Please enter a number greater than zero:\n");
+	scanf_s("%d", &n);
+	while (n > 0) {
+		num = n % 10;
+		if (num < min) {
+			min = num;
+			minP = i;
+		}
+		if (num == min) {
+			if (i > minP) {
+				min = num;
+				minP = i;
+			}
+		}
+		if (num > max) {
+			max = num;
+			maxP = i;
+		}
+		if (num == max) {
+			if (i > maxP) {
+				max = num;
+				maxP = i;
+			}
+		}
+		i++;
+		n /= 10;
+	}
+	printf("Max = %d, at position:%d, Min = %d, at position: %d", max, maxP, min, minP);
+}
+
+void printPositionsRight() {
+	int n = 0, min = 10, max = -10, minP = 100, maxP = 100;
+	int i = 0, num = 0;
+	printf("Please enter a number greater than zero:\n");
+	scanf_s("%d", &n);
+	while (n > 0) {
+		num = n % 10;
+		if (num < min) {
+			min = num;
+			minP = i;
+		}
+		if (num == min) {
+			if (i < minP) {
+				min = num;
+				minP = i;
+			}
+		}
+		if (num > max) {
+			max = num;
+			maxP = i;
+		}
+		if (num == max) {
+			if (i < maxP) {
+				max = num;
+				maxP = i;
+			}
+		}
+		i++;
+		n /= 10;
+	}
+	printf("Max = %d, at position:%d, Min = %d, at position: %d", max, maxP, min, minP);
+}
+
+void calcEvenOdd() {
+	int n = 0;
+	int evenSum = 1, oddSum = 1;
+	int num = 0;
+	double result = 0;
+	printf("Please enter a number greater than zero:\n");
+	scanf_s("%d", &n);
+	while (n > 0) {
+		num = n % 10;
+		if (num % 2 == 0) {
+			evenSum *= num;
+		}
+		else {
+			oddSum *= num;
+		}
+		n /= 10; 
+	}
+	result = (double)evenSum / oddSum;
+	printf("%lf\n",result);
+	printf("%.2lf",result);
+}
+
+void guessingGame() {
+	srand(time(NULL)); // Seed the random number generator with the current time
+	int answer = 0, guess = 0, count = 1;
+
+	// Game instructions
+	printf("--- Welcome to the Guessing game! ---\n");
+	printf("I've picked a random number from 1-10\nLets see if you can guess it...\n");
+
+	// Generate a random number between 1 and 10
+	answer = (rand() % 10) + 1;
+
+	// Loop until the user guesses the correct number
+	while (guess != answer) {
+		printf("Count: %d, Guess:\n", count); // Prompt user for their guess
+		scanf_s("%d", &guess);
+
+		if (guess == answer) {
+			// Exit loop if the guess is correct
+			break;
+		}
+		else {
+			// Increment count for each incorrect guess
+			count++;
+		}
+	}
+
+	// Determine the feedback based on the number of guesses
+	switch (count) {
+	case 1: // Guessed on the first try
+		printf("I believe you have cheated...\n");
+		break;
+	case 2:
+	case 3: // Guessed within 2-3 tries
+		printf("Excellent game!\n");
+		break;
+	case 4:
+	case 5: // Guessed within 4-5 tries
+		printf("You Played well!\n");
+		break;
+	case 6:
+	case 7: // Guessed within 6-7 tries
+		printf("Average game.\n");
+		break;
+	case 8:
+	case 9:
+	case 10: // Guessed within 8-10 tries
+		printf("Poor game\n");
+		break;
+	default: // Took more than 10 tries
+		printf("Seriously? There are only ten choices...\n");
+		break;
+	}
+}
+
+
+void main()
+{
+	//fizzBuzz();
+	//range();
+	//change();
+	//oddNotDivisableBy3();
+	//calc();
+	//printNumbers();
+	//decimalToBinary();
+	//sumN();
+	//sumOdd();
+	//printPositions();
+	//printPositionsRight();
+	//calcEvenOdd();
+	//guessingGame();
+}
+

שנה א/מבוא למדעי המחשב/עבודות בית/פתרונות לעבודות/מטלה-5.c

@@ -0,0 +1,137 @@
+#include <stdio.h>
+#include <math.h>
+
+int calculator()
+{
+	char op = ' ';
+	int num1, num2;
+
+	printf("Please enter two integers:\n");
+
+	// Attempt to read two integers
+	if (scanf_s("%d %d", &num1, &num2) != 2) {
+		printf("Invalid input. Please enter integers only.\n");
+		return 0;
+	}
+
+	// Clear white-space
+	while (getchar() != '\n');
+
+	printf("Please enter operator (+ , - , * , / , %%):\n");
+
+	if (scanf_s(" %c", &op, 1) != 1) {  // The space before %c ignores any leftover whitespace
+		printf("Invalid input. Please enter a valid operator (+ , - , * , / , %%):\n");
+		return 0;
+	}
+
+
+	printf("%d %c %d\n", num1, op, num2);
+
+	switch (op) {
+	case '+':
+		return num1 + num2;
+	case '-':
+		return num1 - num2;
+	case '*':
+		return num1 * num2;
+	case '/':
+	case '%':
+		if (num2 == 0) {
+			printf("Can't divide by zero\n");
+			return 0;
+		}
+		if (op == '/')
+			return num1 / num2;
+		else
+			return num1 % num2;
+
+	default:
+		printf("Error: Invalid operator. Please enter a valid operator (+ , - , * , / , %%).\n");
+		break;
+	}
+
+	return 0;
+
+
+}
+
+int reverse(int n) {
+	int reversed = 0;
+	while (n != 0) {
+		reversed *= 10;
+		reversed += n % 10;
+		n /= 10;
+	}
+	return reversed;
+}
+
+int divisors(int num) {
+	int sum = 0;
+	int d = 1;
+
+	while (d < num) {
+		sum += (num % d == 0) ? d : 0;
+		d++;
+	}
+
+	return sum;
+}
+
+int prime(int num) {
+	int d = 3;
+	// check if less than or equal 1, not 2 and not divisable by 2
+	if (num <= 1 || (num != 2 && num % 2 == 0))
+		return 0;
+
+	while (d < num) {
+		if (num % d == 0) return 0;
+		d++;
+	}
+	return 1;
+}
+
+int gcd(int num1, int num2) {
+	while (num2 != 0) {
+		int temp = num2;
+		num2 = num1 % num2;
+		num1 = temp;
+	}
+	return num1;
+
+}
+
+int gcdTri(int num1, int num2, int num3) {
+
+	int n1 = gcd(num1, num2);
+	int n2 = gcd(n1, num3);
+
+	return n2;
+}
+
+int main()
+{
+
+	//int result = calculator();
+	//printf("Result: %d\n", result);
+
+	//int result1 = reverse(5614);
+	//printf("Result: %d\n", result1);
+
+	//int result2 = reverse(320);
+	//printf("Result: %d\n", result2);
+
+	//int result3 = divisors(12);
+	//printf("Result: %d\n", result3);
+
+	//int result4 = divisors(16);
+	//printf("Result: %d\n", result4);
+
+	//int result5 = prime(919);
+	//printf("Result: %d\n", result5);
+
+	int result6 = gcdTri(15, 20, 100);
+	printf("Result: %d\n", result6);
+
+
+	return 0;
+}

שנה א/מבוא למדעי המחשב/עבודות בית/פתרונות לעבודות/מטלה-6.c

@@ -0,0 +1,114 @@
+#include <stdio.h>
+
+int hasEven(int num) {
+	// base case
+	if (num % 10 == 0) return 0;
+	if ((num % 10) % 2 == 0) return 1;
+
+	return hasEven(num / 10);
+}
+
+int fibo(int n) {
+
+	// base case
+	if (n == 0) return 0;
+	if (n == 1) return 1;
+
+	return (fibo(n - 1) + fibo(n - 2));
+
+}
+
+int fibo1(int n) {
+
+	if (n == 0) return 0;
+	if (n == 1) return 1;
+	int num1 = 1, num2 = 1;
+	int i = 2;
+	int fib = 0;
+
+	while (i != n) {
+		fib = num1 + num2;
+		num1 = num2;
+		num2 = fib;
+		i++;
+	}
+	return fib;
+}
+
+int digits(int num) {
+	if (num == 0) return 0;
+	return digits(num / 10) + 1;
+}
+
+int sum(int num) {
+	if (num == 0) return 0;
+	return sum(num / 10) + num % 10;
+}
+
+int ascending(int num) {
+	if (num < 9) return 1;
+
+	return (num % 10 < (num / 10) % 10) ? ascending(num / 10) : 0;
+}
+
+int smallerThan(int num) {
+
+	int input;
+	printf("Please enter an integer:\n");
+	scanf_s("%d", &input);
+
+	// base case:
+	if (input == -1) return 0;
+
+	if (input < num) {
+		return 1 + smallerThan(num);
+	}
+	else {
+		return smallerThan(num);
+	}
+}
+
+void printFromNumDown(int num) {
+	if (num == 0) {
+		printf(".");
+		return;
+	}
+	printf("%d ", num);
+	return printFromNumDown(num - 1);
+}
+
+void printFromOneToNum(int num) {
+	if (num == 1) {
+		printf("%d ", num);
+		return;
+	}
+	printFromOneToNum(num - 1);
+
+	printf("%d ", num);
+}
+
+void printFromNumTo1ToNum(int num) {
+	if (num == 1) {
+		printf("%d ", num);
+		return;
+	}
+	printf("%d ", num);
+	printFromNumTo1ToNum(num - 1);
+	printf("%d ", num);
+}
+
+int main()
+{
+	//printf("%d", hasEven(13547));
+	//printf("%d", fibo1(19)); // 4181
+	//printf("%d", digits(123456789)); // 9
+	//printf("%d", sum(123)); // 6
+	//printf("%d", ascending(123456)); // 0
+	//printf("%d", ascending(321)); // 1
+	//printf("%d", smallerThan(5));
+	//printFromNumDown(5);
+	//printFromOneToNum(5);
+	//printFromNumTo1ToNum(5);
+
+	return 0;
+}

שנה א/מבוא למדעי המחשב/עבודות בית/פתרונות לעבודות/מטלה-7.c

@@ -0,0 +1,192 @@
+#include <stdio.h>
+#include <math.h>
+
+
+
+void inputArray(int* arr, int n) {
+	printf("Please enter %d numbers:\n", n);
+	int i = 0;
+	while (i < n) {
+		scanf_s("%d", &arr[i]);
+		i++;
+	}
+}
+
+void printArray(int* arr, int n) {
+	printf("\nPrinting Array\n");
+	int i = 0;
+	while (i < n) {
+		printf("%d ", arr[i]);
+		i++;
+	}
+}
+
+void arrCalc(int* arr, int n, int* max, int* min, int* sum, double* avg, int* isEven) {
+	int i = 0;
+	*max = arr[0];
+	*min = arr[0];
+	*isEven = 0;
+	while (i < n) {
+		*sum += arr[i];
+		*max = (arr[i] > *max) ? arr[i] : *max;
+		*min = (arr[i] < *min) ? arr[i] : *min;
+		*isEven = (arr[i] % 2 == 0) ? 1 : *isEven;
+		i++;
+	}
+	*avg = (double)(*sum / n);
+}
+
+int ascending(int* arr, int n, int* isReallyAscending) {
+	int i = 0;
+	int isAscending = 1;
+	*isReallyAscending = 1;
+	while (i < n - 1) {
+		if (arr[i] > arr[i + 1]) {
+			isAscending = 0;
+			*isReallyAscending = 0;
+			return isAscending;
+		}
+		if (arr[i] == arr[i + 1]) {
+			*isReallyAscending = 0;
+		}
+		i++;
+	}
+	return isAscending;
+
+}
+
+int ascendingR(int* arr, int n, int* isReallyAscending) {
+	if (n == 1 || n == 0) {
+		*isReallyAscending = 1;
+		return 1;
+	}
+	if (arr[0] > arr[1]) {
+		*isReallyAscending = 0;
+		return 0;
+	}
+	if (arr[0] == arr[1]) {
+		*isReallyAscending = 0;
+	}
+
+	return ascending(arr + 1, n - 1, isReallyAscending);
+
+}
+
+int sumNighborArr(int* arr, int n) {
+	int i = 1;
+	while (i < n - 1) {
+		if (arr[i - 1] + arr[i + 1] == arr[i]) {
+			return 1;
+		}
+		i++;
+	}
+	return 0;
+}
+
+void reverse(int* arr, int n) {
+	int i, j;
+	int temp = 0;
+	for (i = 0, j = n - 1; i < n / 2; i++, j--)
+	{
+		temp = arr[i];
+		arr[i] = arr[j];
+		arr[j] = temp;
+	}
+}
+
+void reverseR(int* arr, int n) {
+	// Base case: if the size of the array is 1 or less, stop recursion
+	if (n <= 1) return;
+
+	// Swap the first element (arr[0]) with the last element (arr[n-1])
+	int temp = arr[0];
+	arr[0] = arr[n - 1];
+	arr[n - 1] = temp;
+
+	// Recursively call reverseR on the inner portion of the array
+	// Move the array pointer one step forward (arr + 1)
+	// Reduce the size of the problem by 2 (n - 2)
+	reverseR(arr + 1, n - 2);
+}
+
+
+int main()
+{
+
+	//Question 1
+	//int arr[100];
+	//int n = 5;
+	//inputArray(&arr, n);
+	//printArray(&arr, n);
+
+	//Question 2
+	//int arr[] = { 5, 8, 2, 3, 7 };
+	//int n = 5;
+	//int max = 0, min = 0, sum = 0, isEven = 0;
+	//double avg;
+
+	//// Call the function
+	//arrCalc(arr, n, &max, &min, &sum, &avg, &isEven);
+
+	//// Print the results
+	//printf("Max: %d\n", max);
+	//printf("Min: %d\n", min);
+	//printf("Sum: %d\n", sum);
+	//printf("Average: %.2f\n", avg);
+	//printf("Is there an even number? %d\n", isEven);
+
+	// Question 3: Test ascending (iterative) and ascendingR (recursive)
+	//int arr1[] = { 1, 3, 5, 6, 11 };
+	//int arr2[] = { 1, 3, 3, 6, 11 };
+	//int arr3[] = { 1, 3, 2, 5, 11 };
+	//int isReallyAscending;
+
+	//// Test with iterative function
+	//printf("Testing iterative ascending function:\n");
+	//isReallyAscending = 0;
+	//printf("Array 1: Ascending: %d, Really Ascending: %d\n", ascending(arr1, 5, &isReallyAscending), isReallyAscending);
+
+	//isReallyAscending = 0;
+	//printf("Array 2: Ascending: %d, Really Ascending: %d\n", ascending(arr2, 5, &isReallyAscending), isReallyAscending);
+
+	//isReallyAscending = 0;
+	//printf("Array 3: Ascending: %d, Really Ascending: %d\n", ascending(arr3, 5, &isReallyAscending), isReallyAscending);
+
+	//// Test with recursive function
+	//printf("\nTesting recursive ascending function:\n");
+	//isReallyAscending = 0;
+	//printf("Array 1: Ascending: %d, Really Ascending: %d\n", ascendingR(arr1, 5, &isReallyAscending), isReallyAscending);
+
+	//isReallyAscending = 0;
+	//printf("Array 2: Ascending: %d, Really Ascending: %d\n", ascendingR(arr2, 5, &isReallyAscending), isReallyAscending);
+
+	//isReallyAscending = 0;
+	//printf("Array 3: Ascending: %d, Really Ascending: %d\n", ascendingR(arr3, 5, &isReallyAscending), isReallyAscending);
+
+	// Question 4
+	//int arr1[] = { 1,2,7,5,9,6 };
+	//int arr2[] = { 1,2,8,5,9,6 };
+	//int n = 6;
+	//printf("Array1:   %d\n",sumNighborArr(arr1, n));
+	//printf("Array2:   %d\n",sumNighborArr(arr2, n));
+
+	// Question 5
+	// A
+	//int arr1[] = { 1,3,2,5,6};
+	//int n = 5;
+	//reverse(arr1,n);
+	//for (int i = 0; i < n; i++)
+	//{
+	//	printf("%d,",arr1[i]);
+	//}
+	// B
+	int arr1[] = { 1,3,2,5,6 };
+	int n = 5;
+	reverseR(arr1, n);
+	for (int i = 0; i < n; i++)
+	{
+		printf("%d,", arr1[i]);
+	}
+	return 0;
+}
+

שנה א/מבוא למדעי המחשב/עבודות בית/פתרונות לעבודות/מטלה-8.c

@@ -0,0 +1,181 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int* inputArray(int size) {
+	int* arr = (int*)malloc(size * sizeof(int));
+	if (arr == NULL) {
+		printf("Memomry allocation falied.\n");
+		return;
+	}
+	int* start = arr;
+	int i;
+	for (i = 0; i < size; i++) {
+		printf("Enter number for element %d:\n", i + 1);;
+		scanf_s("%d", &arr[i]);
+	}
+	return start;
+}
+
+int* fibo(int n) {
+	// allocate memory
+	int* arr = (int*)malloc((n + 1) * sizeof(int));
+	if (arr == NULL) {
+		printf("Memomry allocation falied.\n");
+		return;
+	}
+	// base case
+	if (n == 0) {
+		arr[0] = 0;
+		return arr;
+	}
+	if (n == 1) {
+		arr[0] = 0;
+		arr[1] = 1;
+		return arr;
+	}
+	// Initalize the first two elemnts
+	arr[0] = 0;
+	arr[1] = 1;
+
+	for (int i = 2; i <= n; i++)
+		arr[i] = arr[i - 2] + arr[i - 1];
+	return arr;
+
+}
+
+int appearsMost(int* arr, int n) {
+	// allocate memory
+	int arrCount[] = { 0,0,0,0,0,0,0,0,0 };
+	int max = -1, maxLoc = -1;
+	if (arrCount == NULL) {
+		printf("Memomry allocation falied.\n");
+		return;
+	}
+	// count the numbers
+	for (int i = 0; i < n; i++) {
+		arrCount[arr[i]] += 1;
+	}
+	// find max
+
+	for (int i = 0; i < n; i++)
+	{
+		if (arrCount[i] > max) {
+			max = arrCount[i];
+			maxLoc = i;
+		}
+	}
+
+	printf("The most frequent number is: %d and it appears: %d times", maxLoc, max);
+
+	return max;
+}
+
+int appearsInArr(int* arr, int n, int k) {
+	int* count = (int*)calloc(k + 1, sizeof(int));
+	if (count == NULL) {
+		printf("Memomry allocation falied.\n");
+		return;
+	}
+	for (int i = 0; i < n; i++)
+		count[arr[i]] += 1;
+
+	for (int i = 0; i < k; i++)
+	{
+		if (count[i] != i)
+			return 0;
+	}
+
+	free(count);
+
+	return 1;
+}
+
+int diff(int* arr, int n, int a, int b) {
+	// Allocate memory for count array to store frequencies in range [a, b]
+	int* count = (int*)calloc((b - a) + 1, sizeof(int));
+	if (count == NULL) {
+		printf("Memory allocation failed.\n");
+		return -1; // Return an error code
+	}
+
+	// Variables for tracking max and min frequencies
+	int i, max = 0, maxLoc = -1, min = n + 1, minLoc = -1;
+
+	// Count occurrences of elements in arr within the range [a, b]
+	for (i = 0; i < n; i++) {
+		if (arr[i] >= a && arr[i] <= b) { // Ensure arr[i] is within [a, b]
+			count[arr[i] - a]++;          // Update count array at adjusted index
+		}
+	}
+
+	// Iterate through count array to find max and min frequencies
+	for (i = 0; i < (b - a) + 1; i++) {
+		if (count[i] > 0) { // Only consider elements that appear at least once
+			// Update max if current frequency is greater or equal, and prioritize a higher value for maxLoc
+			if (count[i] > max || (count[i] == max && i + a > maxLoc)) {
+				max = count[i];
+				maxLoc = i + a; // Convert back to the original value
+			}
+			// Update min if current frequency is smaller or equal, and prioritize a lower value for minLoc
+			if (count[i] < min || (count[i] == min && i + a < minLoc)) {
+				min = count[i];
+				minLoc = i + a; // Convert back to the original value
+			}
+		}
+	}
+
+	free(count); // Free allocated memory
+
+	// Return the difference between maxLoc and minLoc
+	return maxLoc - minLoc;
+}
+int main() {
+	// 1
+	//int size = 5;  // Define the size of the array
+	//int* ptr = inputArray(size);
+
+	//if (ptr != NULL) {
+	//    printf("You entered the following numbers:\n");
+	//    for (int i = 0; i < size; i++) {
+	//        printf("%d ", ptr[i]);  // Print the array elements
+	//    }
+	//    printf("\n");
+
+	//    free(ptr);  // Free the dynamically allocated memory
+	//}
+
+	// 2
+	//int n = 10;
+	//int* ptr = fibo(n);
+
+	//if (ptr != NULL) {
+	//	printf("Fibonacci sequnce:\n");
+	//	for (int i = 0; i <= n; i++) {
+	//		printf("%d ", ptr[i]);  // Print the array elements
+	//	}
+	//	printf("\n");
+
+	//	free(ptr);  // Free the dynamically allocated memory
+	//}
+
+	// 3
+	//int arr[] = { 1,6,3,3,3,6,3 };
+	//int n = 7;
+	//int res = appearsMost(arr,n);
+
+	// 4
+	//int arr[] = { 1,4,4,3,4,2,2,3,3,4 };
+	//int arr1[] = { 1,4,4,3,4,2,2,1,3,4 };
+	//int n = 10, k = 4;
+	//printf("%d\n", appearsInArr(arr, n, k));
+	//printf("%d\n", appearsInArr(arr1, n, k));
+
+	// 5
+	//int arr[] = { 5,5,1,4,4,4,7,7 };
+	//int arr1[] = { 5,1,6,6,9,9 };
+	//printf("%d\n", diff(arr, 8, 1, 8));
+	//printf("%d\n", diff(arr1, 6, 1, 9));
+
+
+	return 0;
+}

שנה א/מבוא למדעי המחשב/עבודות בית/פתרונות לעבודות/מטלה-9.c

@@ -0,0 +1,198 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+char* stringTwice(char* s) {
+	int charCount = 0;
+	char* start = s;
+
+	// Count the number of characters in the input string
+	while (*s) {
+		charCount++;
+		s++;
+	}
+
+	// Allocate memory for the new string (doubled + null terminator)
+	char* newStr = (char*)malloc((charCount * 2 + 1) * sizeof(char));
+	if (newStr == NULL) {
+		printf("Memory allocation failed.\n");
+		return NULL; // Return NULL to indicate failure
+	}
+
+	char* newStart = newStr; // Preserve the original pointer for return
+
+	// Fill the first part of the new string
+	for (int i = 0; i < charCount; i++) {
+		*newStr = *start;
+		*(newStr + charCount) = *start; // Fill the second half
+		newStr++;
+		start++;
+	}
+
+	newStr = newStart + (charCount * 2); // Move to the end of the allocated memory
+	*newStr = '\0'; // Null terminator
+
+	return newStart; // Return the original pointer
+}
+
+char appearsMost(char* s) {
+	// Step 1: Allocate memory for frequency array
+	int pCount[26] = { 0 }; // Array for counts of each letter, initialized to 0
+	char* ptr = s;        // Pointer to iterate through the string
+
+	// Step 2: Count frequencies of lowercase letters
+	while (*ptr) {
+		char curChar = *ptr;
+		if (curChar >= 'a' && curChar <= 'z') { // Check if the character is lowercase
+			int index = curChar - 'a';         // Calculate index based on 'a'
+			pCount[index]++;                   // Increment the corresponding count
+		}
+		ptr++; // Move to the next character
+	}
+
+	// Step 3: Find the letter with the maximum frequency
+	int maxFreq = 0;  // Variable to track the highest frequency
+	int maxIdx = -1;  // Variable to track the index of the letter with max frequency
+	for (int i = 0; i < 26; i++) {
+		if (pCount[i] > maxFreq) { // Compare frequencies
+			maxFreq = pCount[i];   // Update max frequency
+			maxIdx = i;            // Update the index of the most frequent letter
+		}
+	}
+
+	// Step 4: Return the result
+	if (maxIdx == -1) {
+		return '\0'; // If no valid letter found, return '\0'
+	}
+	return (char)(maxIdx + 'a'); // Convert the index to the corresponding letter and return
+}
+
+int validString(char* s) {
+	char* ptr = s;
+	int flc = (*s >= 'A' && *s <= 'Z') ? 1 : 0; // First letter capitelized
+
+	if (flc) { // First letter is Capitalized
+		ptr++; // Move to second letter
+		int slc = (*ptr >= 'A' && *ptr <= 'Z') ? 1 : 0; // Seoncd letter capitelized
+		ptr++; // Move to third letter
+		if (slc) { // Second letter is Capitalized
+			while (*ptr != '\0') { // Check that all ther rest are also capitalized
+				if (*ptr != ' ' && *ptr <= 'z' && *ptr >= 'a')
+					return 0;
+				ptr++;
+			}
+		}
+		else {// Second letter is NOT Capitalized
+			while (*ptr != '\0') { // Check that all ther rest are also not capitalized
+				if (*ptr != ' ' && *ptr >= 'A' && *ptr <= 'Z')
+					return 0;
+				ptr++;
+			}
+		}
+	}
+	else { // first letter is not capitalized, check that the rest are also not capitalized
+		while (*ptr != '\0') {
+			if (*ptr != ' ' && *ptr >= 'A' && *ptr <= 'Z')
+				return 0;
+			ptr++;
+		}
+	}
+	return 1;
+}
+
+char* removeSpaces(char* s) {
+	char* ptr = s; // Pointer to traverse the input string
+	int count = 0; // Counter to track the number of non-space characters
+
+	// Step 1: Count the number of non-space characters
+	while (*ptr != '\0') { // Loop until the end of the string
+		if (*ptr != ' ') // If the character is not a space
+			count++; // Increment the count
+		ptr++; // Move to the next character
+	}
+
+	// Step 2: Allocate memory for the new string
+	// Allocate enough space for all non-space characters plus the null terminator
+	char* str = malloc((count + 1) * sizeof(char));
+	ptr = s; // Reset the pointer to the beginning of the input string
+
+	if (str == NULL) { // Check if memory allocation failed
+		printf("Memory allocation failed.\n");
+		return NULL; // Return NULL to indicate failure
+	}
+
+	// Step 3: Copy non-space characters to the new string
+	char* pStr = str; // Pointer to traverse the new string
+	while (*ptr != '\0') { // Loop until the end of the input string
+		if (*ptr != ' ') { // If the character is not a space
+			*pStr = *ptr; // Copy the character to the new string
+			pStr++; // Move to the next position in the new string
+		}
+		ptr++; // Move to the next character in the input string
+	}
+
+	// Step 4: Add the null terminator to the end of the new string
+	*pStr = '\0';
+
+	// Step 5: Return the new string
+	return str;
+}
+
+int palindrome(char* str) {
+	char* start = str, * end = NULL; // Two pointers: start points to the beginning of the string, end will point to the last character.
+	int count = 0; // Counter to calculate the length of the string.
+
+	// Step 1: Calculate the length of the string
+	while (*start != '\0') { // Traverse the string until the null terminator.
+		count++; // Increment the counter for each character.
+		start++; // Move to the next character.
+	}
+
+	start = str; // Reset start to point to the beginning of the string.
+	end = str + (count - 1); // Set end to point to the last character (count - 1 due to 0-based indexing).
+
+	// Step 2: Check for palindrome
+	while (start < end) { // Loop until the two pointers meet in the middle.
+		if (*start != *end) return 0; // If characters at start and end are not equal, it's not a palindrome.
+		start++; // Move start pointer forward.
+		end--;   // Move end pointer backward.
+	}
+
+	return 1; // If the loop completes without finding mismatched characters, the string is a palindrome.
+}
+
+
+
+int main()
+{
+	// 1
+	printf("%s\n", stringTwice("abcd"));
+	printf("%s\n", stringTwice("adir buskila"));
+
+	// 2
+	printf("%c\n", appearsMost("strings seem silly")); // Expected Output: 's'
+	printf("%c\n", appearsMost("abcabcabc"));          // Expected Output: 'a'
+	printf("%c\n", appearsMost("12345!@#$%z"));         // Expected Output: '\0'
+
+	// 3
+	printf("%d\n", validString("This is valid"));
+	printf("%d\n", validString("THIS IS VALID"));
+	printf("%d\n", validString("this is valid"));
+	printf("%d\n", validString("This IS NOT ValiD"));
+
+	// 4
+	printf("%s\n", removeSpaces("I  li  ve  in  isra el"));
+	printf("%s\n", removeSpaces("  H E LL O WORLD"));
+	printf("%s\n", removeSpaces("      "));
+	printf("%s\n", removeSpaces("A B C D"));
+
+	// 5
+	printf("%d\n", palindrome("tacocat"));
+	printf("%d\n", palindrome("racecar"));
+	printf("%d\n", palindrome("level"));
+	printf("%d\n", palindrome("rotor"));
+	printf("%d\n", palindrome("civic"));
+	printf("%d\n", palindrome("civic"));
+	printf("%d\n", palindrome("notpalindrome"));
+	printf("%d\n", palindrome("shoshi"));
+	return 0;
+}

שנה א/מבוא למערכות מחשב/מבחנים/דף נוסחאות.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:691ada1aa80af6f00f8670f27a5f834023b1a9763591f288105169b879ff1900
+size 2474177