गतिशील नेस्टेड लूप स्तर

Question

मैं गतिशील नेस्टेड लूप स्तर को संभालने का एक आसान तरीका जानने की कोशिश कर रहा हूं। निम्न पैरामीटर पर विचार करें जो 2 पैरामीटर में लेते हैं: # लूप की संख्या, और अधिकतम मान।

void PrintLoop(int maxloop, int maxvalue) 

PrintLoop(1,2); 
// output 
0 
1 

PrintLoop(2,2); 
// output 
0, 0 
0, 1 
1, 0 
1, 1 

PrintLoop(3,2); 
// output 
0, 0, 0 
0, 0, 1 
0, 1, 0 
0, 1, 1 
1, 0, 0 
1, 0, 1 
1, 1, 0 
1, 1, 1 

आदि ...

वहाँ एक रास्ता एक समारोह है कि यह "गतिशील नेस्टेड छोरों" व्यवहार उत्पन्न कर सकते हैं लिखने के लिए है?

किसी भी मदद

Answer 1

हाँ, यह संभव है, और इस "recursion" की अवधारणा को लागू करने के लिए धन्यवाद अक्सर प्रयोग किया जाता है:

void PrintLoop(int maxloop, int maxvalue) 
{ 
    if (maxloop<=0) return ; 
    // print something here... 
    for (int i=0;i<maxmalue;i++){ 
     PrintLoop(maxloop-1, maxvalue); 
    } 
} 

Answer 2

एडीए में आप एक घोषित ब्लॉक कर सकता है प्राप्त करने के बाद उपयोगकर्ता का निवेश; फिर अपने लूप को 1 से सेट करने के लिए सेट करें .. Read_In_Loop_Control_Value और फिर 1 से पूर्णांक मुद्रित करने के लिए एक नेस्टेड लूप .. Read_In_Number_Per_Line मान।

Answer 3

Pavel's answer दिखाता है कि रिकर्सन कैसे करें। हालांकि, एक फ़ंक्शन जो केवल दो तर्क (लूप और अधिकतम मान की संख्या) लेता है, वास्तव में आपके उदाहरण में संख्याओं को मुद्रित करने के लिए पर्याप्त संदर्भ नहीं है। इसके लिए, आपको कुछ अतिरिक्त जानकारी का ट्रैक रखना होगा।

void _print_loop(int *values, int width, int cur_col, int max) { 
    if (cur_col == width) { 
    for (int i = 0; i < width; i++) { 
     printf("%d%c", values[i], (i < width - 1) ? ' ' : '\n'); 
    } 
    } else { 
    for (int i = 0; i < max; i++) { 
     values[cur_col] = i; 
     _print_loop(values, width, cur_col + 1, max); 
    } 
    } 
} 

void print_loop(int width, int max) { 
    int values[width]; 
    memset(values, 0, width * sizeof(int)); 
    _print_loop(values, width, 0, max); 
} 

अब print_loop(3, 2) बर्ताव की उम्मीद के रूप में: एक तरह से यह करने के लिए, निम्न है।

संपादित करें: वास्तव में, एक जो एक सकारात्मक width तर्क प्राप्त होने पर प्रारंभ कर रहे हैं static चर के उपयोग के माध्यम से ऐसा करने के लिए, एक दो तर्क समारोह लिख सकते हैं। इस प्रारंभिक चरण के बाद समारोह फिर नकारात्मक मानों का उपयोग करके अपना रिकर्सन करता है। जाहिर है, जिसके परिणामस्वरूप कोड भयानक है, लेकिन मैं इसे वैसे भी पूर्णता के लिए के लिए पोस्ट करेंगे,:

void print_loop(int width, int max) { 
    static int max_width; 
    static int *values; 

    if (width > 0) { 
    max_width = width; 
    if ((values = calloc(width, sizeof(int))) == NULL) { 
     perror("calloc"); 
     exit(EXIT_FAILURE); 
    } 
    print_loop(-width, max); 
    free(values); 
    } 
    else if (width == 0) { 
    for (int i = 0; i < max_width; i++) { 
     printf("%d%c", values[i], (i < max_width - 1) ? ' ' : '\n'); 
    } 
    } 
    else { 
    for (int i = 0; i < max; i++) { 
     values[-width - 1] = i; 
     print_loop(width + 1, max); 
    } 
    } 
} 

Answer 4

आप प्रत्यावर्तन उपयोग कर सकते हैं या आप स्पष्ट रूप से एक भी पाश में प्रत्येक पाश के राज्य राज्यों की दुकान और प्रबंधन कर सकते हैं।

इस मामले में इसका मतलब है काउंटरों की एक सरणी संग्रह करना। मुख्य पाश का प्रत्येक निष्पादन आंतरिकतम काउंटर और सभी बाहरी काउंटरों को आगे बढ़ाता है जिनके भीतर के पड़ोसियों का कब्जा होता है। उच्चतम काउंटर एक गार्ड के रूप में कार्य करता है।

void printloop(int maxloop, int maxvalue) { 
    unsigned int counters[maxloop+1]; // C99 for the win 
    memset(counters, 0, sizeof(counters)); 

    while(!counters[maxloop]) { 
     int i; 
     char *sep=""; 
     for(i=maxloop; i-->0;) { 
      printf("%s%d",sep,counters[i]); 
      sep=","; 
     }; 
     printf("\n"); 
     for(i=0; counters[i]==maxvalue; i++) // inner loops that are at maxval restart at zero 
      counters[i]=0; 
     ++counters[i]; // the innermost loop that isn't yet at maxval, advances by 1 
    } 
}