Number Theory

Author: Dipto1971

Algorithms/04_Greedy/04_JobSequencing.cpp

@@ -35,11 +35,11 @@ void printJobScheduling(Job arr[], int n)
     int profit = 0;
 
     for (int i = 0; i < n; i++) {
-        cout << "Last possible slot for job " << arr[i].id << " is: " << min(n, arr[i].dead)-1 << endl;// Last possible slot for job the job i
+        cout << "Last possible slot for job " << arr[i].id << " is: " << min(n, arr[i].dead) << endl;// Last possible slot for job the job i
         for (int j = min(n, arr[i].dead) - 1; j >= 0; j--) {
             // Free slot found
             if (slot[j] == false) {
-                cout << "Slot " << j << " is free for job " << arr[i].id << endl;
+                cout << "Slot " << j + 1<< " is free for job " << arr[i].id<< endl;
                 result[j] = i; // Add this job to result
                 slot[j] = true; // Make this slot occupied
                 profit += arr[i].profit; // Add profit of current job to result
@@ -77,11 +77,12 @@ void printJobScheduling(Job arr[], int n)
 
 int main()
 {
-    Job arr[] = { { 'a', 2, 100 },
-                  { 'b', 1, 19 },
-                  { 'c', 2, 27 },
-                  { 'd', 1, 25 },
-                  { 'e', 3, 15 } };
+    Job arr[] = { { 'a', 5, 200 },
+                  { 'b', 3, 180 },
+                  { 'c', 3, 190 },
+                  { 'd', 2, 300 },
+                  { 'e', 4, 120 },
+                  { 'f', 2, 100 } };
 
     int n = sizeof(arr) / sizeof(arr[0]);
     cout << "Following is maximum profit sequence of jobs "

Algorithms/05_Number_Theory/02_Prime_Factor.cpp

@@ -3,30 +3,26 @@
 
 // Function to print all prime factors of a given number
 void primeFactors(int n) {
-    // Print the number of 2s that divide n
     while (n % 2 == 0) {
-        std::cout << 2 << " ";
+        cout << 2 << " ";
         n = n / 2;
     }
 
-    // n must be odd at this point. So we can skip one element (i = i + 2)
     for (int i = 3; i * i <= n; i = i + 2) {
-        // While i divides n, print i and divide n
         while (n % i == 0) {
             cout << i << " ";
             n = n / i;
         }
     }
 
-    // This condition is to handle the case when n is a prime number greater than 2
     if (n > 2)
-        std::cout << n << " ";
+        cout << n << " ";
 }
 
 int main() {
     int n = 315;
 
-    std::cout << "Prime factors of " << n << ": ";
+    cout << "Prime factors of " << n << ": ";
     primeFactors(n);
 
     return 0;

Algorithms/05_Number_Theory/03_Prime_Sieve.cpp

@@ -3,30 +3,23 @@
 
 // Function to print all prime numbers smaller than or equal to n
 void sieveOfEratosthenes(int n) {
-    // Create a boolean array "prime[0..n]" and initialize
-    // all entries as true. A value in prime[i] will
-    // finally be false if i is Not a prime, else true.
-    std::vector<bool> prime(n + 1, true);
+    vector<bool> prime(n + 1, true);
 
     for (int p = 2; p * p <= n; p++) {
-        // If prime[p] is not changed, then it is a prime
         if (prime[p] == true) {
-            // Update all multiples of p
             for (int i = p * p; i <= n; i += p)
                 prime[i] = false;
         }
     }
-
-    // Print all prime numbers
     for (int p = 2; p <= n; p++)
         if (prime[p])
-            std::cout << p << " ";
+            cout << p << " ";
 }
 
 int main() {
     int n = 10;
 
-    std::cout << "Prime numbers smaller than or equal to " << n << ": ";
+    cout << "Prime numbers smaller than or equal to " << n << ": ";
     sieveOfEratosthenes(n);
 
     return 0;

Algorithms/05_Number_Theory/04_Prime_Range.cpp

@@ -18,9 +18,8 @@ bool isPrime(int n) {
     return true;
 }
 
-// Function to find the highest occurring digit in prime numbers in the range L to R
 int highestOccurringDigit(int L, int R) {
-    std::vector<int> digitFreq(10, 0);
+    vector<int> digitFreq(10, 0);
 
     for (int i = L; i <= R; ++i) {
         if (isPrime(i)) {
@@ -49,9 +48,9 @@ int main() {
     int result = highestOccurringDigit(L, R);
 
     if (result == -1)
-        std::cout << "No prime numbers found between " << L << " and " << R << std::endl;
+        cout << "No prime numbers found between " << L << " and " << R << endl;
     else
-        std::cout << "Highest occurring digit in prime numbers between " << L << " and " << R << " is: " << result << std::endl;
+        cout << "Highest occurring digit in prime numbers between " << L << " and " << R << " is: " << result << endl;
 
     return 0;
 }

Algorithms/05_Number_Theory/Divide&Conquer.md

@@ -0,0 +1,68 @@
+1. Computing the nth Fibonacci number:
+
+```
+function fibonacci(n):
+    if n <= 1:
+        return n
+    else:
+        a = fibonacci(n - 1)
+        b = fibonacci(n - 2)
+        return a + b
+```
+
+2. Computing the factorial of a number:
+
+```
+function factorial(n):
+    if n <= 1:
+        return 1
+    else:
+        return n * factorial(n - 1)
+```
+
+3. Computing the square root of a number:
+
+```
+function squareRoot(x):
+    return squareRootHelper(x, 0, x)
+
+function squareRootHelper(x, low, high):
+    mid = (low + high) / 2
+    square = mid * mid
+
+    if abs(square - x) < epsilon:
+        return mid
+    elif square < x:
+        return squareRootHelper(x, mid, high)
+    else:
+        return squareRootHelper(x, low, mid)
+```
+
+4. Computing the prime factorization of a number:
+
+```
+function primeFactorization(n):
+    for each prime p:
+        if n is divisible by p:
+            return p, primeFactorization(n / p)
+    return n
+```
+
+5. Computing the greatest common divisor (GCD) of two numbers:
+
+```
+function gcd(a, b):
+    if b == 0:
+        return a
+    else:
+        return gcd(b, a % b)
+```
+
+6. Computing the least common multiple (LCM) of two numbers:
+
+```
+function lcm(a, b):
+    return (a * b) / gcd(a, b)
+```
+
+These pseudocode snippets illustrate the divide and conquer approach for each of the mentioned problems.