Adding exam part 1/4

Exam/IKT203-main/Submissions/Submission-02/CMakeLists.txt

@@ -0,0 +1,13 @@
+# CMakeList.txt : CMake project for Submission-01, include source and define
+# project specific logic here.
+#
+
+# Add source to this project's executable.
+add_executable (Submission-02 "main.cpp" "main.h")
+target_link_libraries(Submission-02 PRIVATE LibExample)
+
+if (CMAKE_VERSION VERSION_GREATER 3.20)
+  set_property(TARGET Submission-02 PROPERTY CXX_STANDARD 20)
+endif()
+
+# TODO: Add tests and install targets if needed.

Exam/IKT203-main/Submissions/Submission-02/main.cpp

@@ -0,0 +1,121 @@
+// Submission-01.cpp : Defines the entry point for the application.
+//
+
+#include "main.h"
+#include <iostream> 
+
+
+// printNaturalNumbers
+static void printNaturalNumbers(int aN)
+{
+	if (aN <= 0) return; // Base case: if n is less than or equal to 0, do nothing
+	printNaturalNumbers(aN - 1); // Recursive call with n-1
+	std::cout << aN << " "; // Print the number after the recursive call to achieve ascending order
+}
+
+// factorial function
+static int calculateFactorial(int aN)
+{
+	if (aN <= 1) return 1; // Base case: factorial of 0 or 1 is 1
+	return aN * calculateFactorial(aN - 1); // Recursive call
+}
+
+// power function using exponentiation by squaring
+// This method is more efficient than the naive approach, reducing the time complexity from O(n) to O(log n).
+static int power(int aBase, int aExponent)
+{
+	if (aExponent == 0) return 1; // Base case: any number to the power of 0 is 1
+	if (aExponent < 0) return 1 / power(aBase, -aExponent); // Handle negative exponents
+	if (aExponent % 2 == 0) // If exponent is even
+	{
+		int halfPower = power(aBase, aExponent / 2);
+		return halfPower * halfPower; // (x^(n/2))^2
+	}
+	else // If exponent is odd
+	{
+		return aBase * power(aBase, aExponent - 1); // x * x^(n-1)
+	}
+}
+
+// Fibonacci function
+// Note: This naive recursive solution is inefficient because it recalculates the same Fibonacci numbers multiple times, leading to an exponential time complexity of O(2^n).
+// An improvement could be made by using memoization or an iterative approach to store previously calculated values, reducing the time complexity to O(n).
+static int fibonacci(int aN)
+{
+	if (aN <= 0) return 0; // Base case: fibonacci(0) = 0
+	if (aN == 1) return 1; // Base case: fibonacci(1) = 1
+	int a = fibonacci(aN - 1);
+	int b = fibonacci(aN - 2);
+	std::cout << a << " + " << b << " = " << (a + b) << std::endl; // Print the sum of the two preceding numbers
+	return a + b; // Recursive call
+}
+
+// Count occurrences of a character in a string
+// This function counts how many times a specific character appears in a given string using recursion.
+static int countOccurrences(const char* aS, char aC)
+{
+	if (*aS == '\0') return 0; // Base case: end of string
+	return (*aS == aC ? 1 : 0) + countOccurrences(aS + 1, aC); // Check current character and recurse for the rest of the string
+}
+
+// Find the largest element in an array using binary recursion
+// This function divides the array into two halves, finds the largest element in each half recursively, and then returns the larger of the two.
+static int findLargestElement(int arr[], int size)
+{
+	if (size == 1) return arr[0]; // Base case: only one element
+	int mid = size / 2;
+	int leftMax = findLargestElement(arr, mid); // Find max in left half
+	int rightMax = findLargestElement(arr + mid, size - mid); // Find max in right half
+	return (leftMax > rightMax) ? leftMax : rightMax; // Return the larger of the two
+}
+
+// Traverse and print characters in the ASCII table from aStart to aEnd using recursion
+// This function prints characters in ascending order during the building phase of the recursion and in descending order during the unwinding phase.
+static void traverseAsciiTable(char aStart, char aEnd)
+{
+	if (aStart > aEnd) return; // Base case: if start exceeds end, do nothing
+	std::cout << aStart << " "; // Print before the recursive call
+	traverseAsciiTable(aStart + 1, aEnd); // Recursive call with next character
+	std::cout << aStart << " "; // Print after the recursive call
+}
+
+int main()
+{
+	std::cout << "--- Submission 2: Fundamental Recursion ---" << std::endl;
+	std::cout << std::endl << "Part 1: Linear Recursion - Your First Steps" << std::endl;
+	printNaturalNumbers(5);
+	std::cout << std::endl << "------------------------------------------------" << std::endl;
+
+	std::cout << std::endl << "Factorial of 5: " << calculateFactorial(5);
+	std::cout << std::endl << "------------------------------------------------" << std::endl;
+
+	std::cout << std::endl << "Part 2: Multiple & Binary Recursion - Diving Deeper" << std::endl;
+	std::cout << std::endl << "2^10: " << power(2, 10);
+	std::cout << std::endl << "------------------------------------------------" << std::endl;
+
+	std::cout << std::endl << "4th Fibonacci number: " << std::endl << fibonacci(4);
+	std::cout << std::endl << "------------------------------------------------" << std::endl;
+
+	std::cout << std::endl << "Occurrences of 'l' in 'Hello, World!': " << countOccurrences("Hello, World!", 'l');
+	std::cout << std::endl << "------------------------------------------------" << std::endl;
+
+	int* arr = new int[20];
+	// Fill array with random numbers from 0 to 999
+	for (int i = 0; i < 20; ++i) arr[i] = rand() % 999;
+	std::cout << std::endl << "Part 3: Advanced Binary Recursion" << std::endl;
+	// Print first 20 elements of the array
+	for (int i = 0; i < 20; ++i) std::cout << arr[i] << " ";
+
+	std::cout << std::endl << "Largest element in array: " << findLargestElement(arr, 20);
+	std::cout << std::endl << "------------------------------------------------" << std::endl;
+	
+	std::cout << std::endl << "Traverse ASCII table from 'A' to 'Z':" << std::endl;
+	traverseAsciiTable('A', 'Z');
+
+	/*
+	Note: The output reflects the building and unwinding of the call stack.
+	*/
+	
+	std::cout << std::endl;
+	return 0;
+}

Exam/IKT203-main/Submissions/Submission-02/main.h

@@ -0,0 +1,8 @@
+// Submission-01.h : Include file for standard system include files,
+// or project specific include files.
+
+#pragma once
+
+#include <iostream>
+
+// TODO: Reference additional headers your program requires here.