Scribd
Upload
11 views4 pages

Non-Recursive Java Algorithms Guide

Java

Uploaded by

sankeerthreddyagumamidii
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
11 views4 pages

Non-Recursive Java Algorithms Guide

Java

Uploaded by

sankeerthreddyagumamidii
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd

// Factorial Calculation Without Recursion

class Factorial {
static int factorial(int n) {
int result = 1;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}
public static void main(String[] args) {
[Link]("Factorial of 5 is " + factorial(5));
}
}

==================================================================

// Fibonacci Series Without Recursion


class Fibonacci {
static void fibonacci(int count) {
int a = 0, b = 1;
[Link](a + " " + b + " ");
for (int i = 2; i < count; i++) {
int c = a + b;
[Link](c + " ");
a = b;
b = c;
}
}
public static void main(String[] args) {
int count = 10;
[Link]("Fibonacci series of " + count + " terms: ");
fibonacci(count);
}
}

==================================================================

// Armstrong Number Check


class ArmstrongNumber {
public static boolean isArmstrong(int num) {
int original = num;
int result = 0, digits = 0;
int temp = num;
while (temp != 0) {
digits++;
temp /= 10;
}
temp = num;
while (temp != 0) {
int digit = temp % 10;
result += [Link](digit, digits);
temp /= 10;
}
return result == original;
}
public static void main(String[] args) {
int number = 153;
[Link](number + " is Armstrong: " + isArmstrong(number));
}
}

==================================================================

// Sum of Natural Numbers Without Recursion


class SumNatural {
static int sum(int n) {
int result = 0;
for (int i = 1; i <= n; i++) {
result += i;
}
return result;
}
public static void main(String[] args) {
int num = 10;
[Link]("Sum of first " + num + " natural numbers is " +
sum(num));
}
}

==================================================================

// Find Missing Number in Sequence (1 to n)


class MissingNumber {
public static int findMissing(int[] arr, int n) {
int total = n * (n + 1) / 2;
int sum = 0;
for (int num : arr) sum += num;
return total - sum;
}
public static void main(String[] args) {
int[] arr = {1, 2, 4, 5, 6};
int n = 6;
[Link]("Missing number is: " + findMissing(arr, n));
}
}

==================================================================

// Prime Number Checking Without Recursion


class PrimeCheck {
static boolean isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i += 6) {
if (n % i == 0 || n % (i + 2) == 0)
return false;
}
return true;
}
public static void main(String[] args) {
int num = 29;
if (isPrime(num))
[Link](num + " is prime");
else
[Link](num + " is not prime");
}
}
==================================================================

// Swapping Two Numbers Without Third Variable


class SwapNumbers {
public static void main(String[] args) {
int a = 10, b = 20;
[Link]("Before swap: a = " + a + ", b = " + b);
a = a + b; // a=10+20 => a=30
b = a - b; // b=30-20 => b=10
a = a - b; // a=30-10 => a=20
[Link]("After swap: a = " + a + ", b = " + b);
}
}

==================================================================

// Sum of Digits of a Number


class SumDigits {
public static int digitSum(int num) {
int sum = 0;
while (num != 0) {
sum += num % 10;
num /= 10;
}
return sum;
}
public static void main(String[] args) {
int number = 12345;
[Link]("Sum of digits of " + number + ": " + digitSum(number));
}
}

==================================================================

// Check if Two Numbers are Co-prime


class CoPrimeCheck {
public static int gcd(int a, int b) {
while (b != 0) {
int tmp = b;
b = a % b;
a = tmp;
}
return a;
}
public static boolean isCoPrime(int a, int b) {
return gcd(a, b) == 1;
}
public static void main(String[] args) {
int a = 14, b = 15;
[Link](a + " and " + b + " are co-prime: " + isCoPrime(a, b));
}
}

==================================================================

// GCD Without Recursion (Euclidean Algorithm)


class GCD {
static int gcd(int a, int b) {
while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}
public static void main(String[] args) {
int num1 = 56, num2 = 98;
[Link]("GCD of " + num1 + " and " + num2 + " is " + gcd(num1,
num2));
}
}

==================================================================

// LCM Calculation using GCD (Without Recursion)


class LCM {
static int gcd(int a, int b) {
while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}
static int lcm(int a, int b) {
return (a / gcd(a, b)) * b;
}
public static void main(String[] args) {
int num1 = 12, num2 = 18;
[Link]("LCM of " + num1 + " and " + num2 + " is " + lcm(num1,
num2));
}
}

==================================================================

Common questions

Powered by AI

The LCM of two numbers can be computed using their GCD via the formula: LCM(a, b) = (a / GCD(a, b)) * b. This relationship simplifies the LCM calculation by converting it into a division and multiplication operation, leveraging the efficiency of the GCD computation, which is robust and quick due to the Euclidean algorithm. Thus, this approach reduces complexity and provides precise results even for large numbers .

Using a loop to calculate the sum of natural numbers becomes less efficient compared to applying the direct arithmetic formula, n(n + 1)/2, for very large values of n. The formula executes in constant time, O(1), regardless of n's value, while loop-based summation grows linearly with n, leading to higher time complexity and resource consumption .

The Fibonacci series is generated non-recursively by iteratively computing the next term as the sum of the two preceding ones, starting from 0 and 1, and updating these two values in each step. This approach avoids the exponential time complexity and stack overflow issues of the naive recursive solution, providing a linear time complexity based on iterative calculation .

Swapping numbers using a third variable involves storing one of them temporarily while assignments happen, which is straightforward and error-free. In contrast, swapping without a third variable typically involves arithmetic operations, such as addition and subtraction, which can be susceptible to overflow in some languages and numerical contexts, making it risky without proper safeguards .

Integer overflow can occur in algorithms like prime checking when operations exceed the maximum limit of the data type used, especially during multiplication or addition in loop-based calculations. It can be mitigated by using data types with larger limits, such as long integers, or applying number-theoretic tricks that avoid large intermediate values, maintaining accuracy and consistency in the computations .

An Armstrong number (or narcissistic number) is a number that equals the sum of its own digits each raised to the power of the number of digits. The algorithm checks by first counting the number of digits, then calculating the sum of each digit raised to that power, comparing finally the resulting sum to the original number. This involves iteratively breaking down the number and using integer operations to check the equality .

The Euclidean Algorithm for GCD operates by repeatedly replacing the larger number by its remainder when divided by the smaller number until one number becomes zero; the other number then is the GCD. This method's efficiency arises from its property that each step reduces the size of the operands, often by about half, leading to logarithmic complexity in the number of digits of the smaller number .

To determine if two numbers are co-prime, their GCD is calculated using the Euclidean algorithm. If the resultant GCD is 1, the numbers share no common divisors other than 1, indicating that they are co-prime. This concept is important in number theory, highlighting a fundamental property of numbers that affects their interaction, especially in modular arithmetic contexts .

The non-recursive approach to calculating a factorial uses a simple iterative loop, multiplying numbers from 2 up to n to obtain the product. This method is preferred over recursion because it avoids the overhead associated with multiple recursive calls, such as memory consumption from the call stack, making it more efficient for large inputs .

The method for finding a missing number in a sequence relies on the arithmetic series sum formula. The formula for the sum of an arithmetic series from 1 to n is n*(n+1)/2. By calculating the sum of the given array and subtracting it from this total sum, we find the missing number. This principle relies on the invariant that the sum of a complete sequence is known, and any deviation indicates a missing number .

You might also like