# K-th term from given N merged Arithmetic Progressions in Java

The following article explores in finding the K-th term from N merged Arithmetic Progressions is crucial in various mathematical and computational contexts. It provides insights into trends, numbers, algorithm design, sequence generation, performance analysis, and mathematical modeling. Finding specific terms within merged progressions aids in generating sequences, evaluating algorithm behavior, and facilitating accurate modeling in mathematical modeling and simulation. Thus, finding the K-th term from N merged Arithmetic Progressions is fundamental across various disciplines. Merged arithmetic progressions offer flexibility, efficiency, and insight generation in mathematical and computational tasks. However, they can introduce complexity, performance degradation, accuracy issues, and resource-intensive computation, necessitating careful consideration when designing and implementing algorithms.

**Example1:**

**Input:** arr[] = {3, 7, 11}, K = 7

**Output: **22

**Explanation: **There are 3 arithmetic progressions: AP1: {3, 6, 9, ...} (Common difference = 3) AP2: {7, 14, 21, ...} (Common difference = 7) AP3: {11, 22, 33, ...} (Common difference = 11) Set S contains elements from all these progressions: {3, 6, 7, 9, 11, 14, 21, 22, ...}. Hence, the 7th term is 22.

**Example2:**

**Input:** arr[] = {1, 3, 5, 7}, K = 6

**Output: **6

**Explanation: **There are 4 arithmetic progressions: AP1: {1, 2, 3, ...} (Common difference = 1) AP2: {3, 6, 9, ...} (Common difference = 3) AP3: {5, 10, 15, ...} (Common difference = 5) AP4: {7, 14, 21, ...} (Common difference = 7) Set S contains elements from all these progressions: {1, 2, 3, 3, 5, 6, 7, 9, 10, 14, ...}. Hence, the 6th term is 6.

## Using Optimized Approach

**Algorithm**

**Step 1:** Initialize oddCount and evenCount to 0.

**Step 2:** Iterate over all possible subsequences of the given arithmetic progressions.

**Step 3:** Calculate the product of its terms and count the number of terms in the subsequence.

**Step 4: **If the count of terms is odd, add n divided by the divisor to oddCount; else add it to evenCount.

**Step 5: **Calculate the difference between oddCount and evenCount, which represent the count of values less than or equal to 'n' in the merged progressions.

**Step 6:** Implement binary search to find the kth term in the merged progressions.

**Step 7: **Define the arithmetic progression and call the findKthTerm function to find and print the kth term.

Here is an implementation of finding the kth term from given N merged arithmetic progressions using an optimized approach:

**FileName:**MergedAP.java

import java.util.*;

public class MergedAP {

static final int MAX_VALUE = 1000000000;

// Function to count values less than or equal to 'n' in merged progressions

static int countValues(int[] progression, int n) {

int oddCount = 0, evenCount = 0;

int subsequenceCount, i, j, divisor;

int totalSubsequences = (int) 1 << progression.length;

int progressionSize = progression.length;

for (i = 1; i < totalSubsequences; i++) {

divisor = 1;

subsequenceCount = 0;

for (j = 0; j < progressionSize; j++) {

// Check if j-th bit is set in the subsequence bitmask

if ((i & (1 << j)) > 0) {

divisor *= progression[j];

subsequenceCount++;

}

}

// Check if the count of terms in the subsequence is odd or even

if (subsequenceCount % 2 == 1)

oddCount += n / divisor;

else

evenCount += n / divisor;

}

return (oddCount - evenCount);

}

// Function to find the kth term in the merged progressions

static int findKthTerm(int left, int right, int[] progression, int k) {

int mid;

while (right - left > 1) {

mid = (left + right) / 2;

// Check if the kth term is in the left half

if (k <= countValues(progression, mid)) {

right = mid;

} else { // If not, it's in the right half

left = mid;

}

}

// If the kth term is exactly at 'left' or 'right', return it

if (k == countValues(progression, left))

return left;

else

return right;

}

public static void main(String[] args) {

int totalTerms = 2, kthTerm = 11;

int[] progression = {3, 7, 11};

System.out.print(findKthTerm(1, MAX_VALUE, progression, kthTerm) + "\n");

}

}

**Output: **

22

**Complexity analysis:** The above approach's time complexity is O(2^N log N) due to iterating through subsequences and performing binary searches, resulting in log N time complexity for each operation. Its space complexity is O(N), primarily used for storing arithmetic progressions and auxiliary variables.