जावा में शून्य से पूर्णांक के एक चर लंबाई सरणी की गिनती

मेरे पास एक सरणी है जिसमें 3 फ़ाइलों में कुल पंक्तियाँ हैं। उदाहरण: [3,4,5]। मैं संख्याओं के एक क्रम का उत्पादन करना चाहूंगा, जो उस सरणी को शून्य तरीके से एक व्यवस्थित तरीके से शून्य कर दे, जिससे मुझे तीन फाइलों में लाइनों का हर संयोजन मिल जाए। यह उदाहरण 3 फ़ाइलों / लंबाई -3 सरणी का उपयोग करता है, लेकिन एल्गोरिथ्म किसी भी मनमानी लंबाई के साथ एक सरणी काम करने में सक्षम होना चाहिए।

ऊपर के उदाहरण के लिए, समाधान जैसा दिखेगा:

[3,4,5]  (line 3 from file 1, line 4 from file 2, line 5 from file 3)  
[3,4,4]  
[3,4,3]  
[3,4,2]  
[3,4,1]  
[3,4,0]  
[3,3,5]  
[3,3,4]  
[3,3,3]  
[3,3,2]  

और इसी तरह...

इस पुनरावर्ती के लिए एल्गोरिथ्म का निर्माण करने का मेरा पहला प्रयास सरणी में एक स्थिति को घटाता है, और जब वह स्थिति शून्य तक पहुंच जाती है - इससे पहले की स्थिति को घटाता है। हालाँकि मैं पिछले दो पदों की तुलना में कम होने वाली गिरावट को दूर रखने में सक्षम नहीं हूँ।

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

    public class FilePositionGenerator {

        public static void main(String[] args) {
            int[] starterArray = {2, 2, 2};
            int[] counters = starterArray.clone();
            List<Integer> results = new ArrayList<Integer>();

            FilePositionGenerator f = new FilePositionGenerator();
            f.generateFilePositions(starterArray, counters, (starterArray.length - 1), results);
        }//end main

        void generateFilePositions(int[] originalArray, int[] modifiedArray, int counterPosition, List<Integer> results) {

            if (modifiedArray[counterPosition] == 0 && counterPosition > 0) {
                modifiedArray[counterPosition] = originalArray[counterPosition];
                counterPosition = counterPosition - 1;
            } else {
                modifiedArray[counterPosition] = modifiedArray[counterPosition] - 1;
                System.out.println(Arrays.toString(modifiedArray));
                generateFilePositions(originalArray, modifiedArray, counterPosition, results);
            }
        }
    }  

मुझे लगता है कि एक चर लंबाई सरणी से निपटने के लिए, एल्गोरिथ्म पुनरावर्ती होना चाहिए, लेकिन मुझे इसके माध्यम से सोचने में परेशानी हो रही है। इसलिए मैंने एक अलग दृष्टिकोण आजमाने का फैसला किया।

एल्गोरिथ्म का उत्पादन करने का मेरा दूसरा प्रयास एक दोहरी सूचक विधि का उपयोग करता है जो वर्तमान उलटी गिनती की स्थिति [सबसे सही स्थिति] पर एक संकेतक रखता है, और अगले गैर-सही स्थिति (पॉइंटरपॉइंट) के लिए एक संकेतक जो कि सबसे सही स्थिति शून्य तक पहुंचने पर कम हो जाएगा। । इस तरह:

import java.util.Arrays;

class DualPointer {
    public static void main(String[] args) {
        int[] counters = {2, 2, 2}; // initialize the problem set
        int[] original = {2, 2, 2}; // clone a copy to reset the problem array
        int[] stopConditionArray = {0, 0, 0};   // initialize an object to show what the stopCondition should be
        int pivotLocation = counters.length - 1;    // pointer that starts at the right, and moves left
        int counterLocation = counters.length - 1;  // pointer that always points to the rightmost position
        boolean stopCondition = false;

        System.out.println(Arrays.toString(counters));
        while (stopCondition == false) {

            if (pivotLocation >= 0 && counterLocation >= 0 && counters[counterLocation] > 0) {
                // decrement the rightmost position
                counters[counterLocation] = counters[counterLocation] - 1;
                System.out.println(Arrays.toString(counters));
            } else if (pivotLocation >= 0 && counters[counterLocation] <= 0) {
                // the rightmost position has reached zero, so check the pivotPointer
                // and decrement if necessary, or move pointer to the left
                if (counters[pivotLocation] == 0) {
                    counters[pivotLocation] = original[pivotLocation];
                    pivotLocation--;
                }
                counters[pivotLocation] = counters[pivotLocation] - 1;
                counters[counterLocation] = original[counterLocation]; // reset the rightmost position
                System.out.println(Arrays.toString(counters));
            } else if (Arrays.equals(counters, stopConditionArray)) {
                // check if we have reached the solution
                stopCondition = true;
            } else {
                // emergency breakout of infinite loop
                stopCondition = true;
            }

        }
    }
}

दौड़ने पर, आप 2 स्पष्ट समस्याएं देख सकते हैं:

[2, 2, 2]  
[2, 2, 1]  
[2, 2, 0]  
[2, 1, 2]  
[2, 1, 1]  
[2, 1, 0]  
[2, 0, 2]  
[2, 0, 1]  
[2, 0, 0]  
[1, 2, 2]  
[1, 2, 1]  
[1, 2, 0]  
[0, 2, 2]  
[0, 2, 1]  
[0, 2, 0]  

नंबर एक, pivotPointer ठीक से नहीं बढ़ता है जब pivotPointer और currentCountdown एक से अधिक सरणी सेल से अलग हो। दूसरे, लाइन counters[pivotLocation] = counters[pivotLocation] - 1; पर एक arrayIndexOutOfBounds है कि अगर तय है, एल्गोरिथ्म को पूरी तरह से ठीक से चलाने से तोड़ता है।

किसी भी सहायता की सराहना की जाएगी।