जावा में स्ट्रिंग क्रमपरिवर्तन (गैर-पुनरावर्ती)

Question

मैं ग्रेड 10 के एक उच्च विद्यालय के छात्र हूं जो जावा पर डेटा संरचनाओं और एल्गोरिदम पुस्तक में कुछ समस्याओं के माध्यम से काम करने की कोशिश कर रहा है।

प्रश्नों में से एक एक स्ट्रिंग के सभी क्रमपरिवर्तन मुद्रित करना है।

class C14 
{ 
public static void main(char a[]) 
{ 
    // char[] a = {'c','a','r','b','o','n'}; 
    int c=0,w=0; 
    for(int q = 0;q<a.length;q++) 
    { 
     for(int i=0;i<a.length;i++) 
     { 
      for(int j=1;j<a.length;j++) 
      { 
       for(int k=1;k<a.length-1;k++) 
       { 
        for(int z=0;z<a.length;z++) 
        { 
         System.out.print(a[z]); 
         c++; 
        } 
        w++; 
        System.out.println(); 
        char p=a[k+1]; 
        a[k+1]=a[k]; 
        a[k]=p; 
       } 
       System.out.println(); 
      } 
      System.out.println(); 
      char x=a[0]; 
      a[0]=a[1]; 
      a[1]=x; 
     } 
     } 
    System.out.println(" Character count = " + c); 
    System.out.println(" Word count = " + w); 
    } 
} 

यह मेरा प्रयास है। किताब मुझे पात्रों 'सी', 'ए', 'आर', 'बी', 'ओ', 'एन' के लिए ऐसा करने के लिए कहती है। मेरा समाधान बस यही करता है, लेकिन जब मैं 3 या 4 अक्षर शब्दों का उपयोग करने की कोशिश करता हूं, तो यह मुझे पुनरावृत्ति देता है। अगर मैं बाहरीतम पाश को हटा देता हूं और इसे प्रिंट करने का प्रयास करता हूं, तो यह 3 और 4 अक्षर शब्दों के लिए काम करता है लेकिन 5+ अक्षर शब्दों के लिए नहीं।

मुझे इसके लिए मेरे तर्क को स्पष्ट करने में खुशी होगी, मुझे पता है कि यह सबसे कुशल नहीं है, लेकिन इस तथ्य को ध्यान में रखें कि मैं केवल ग्रेड 10 में हूं और यह मेरे दिमाग में पहले आया था।

क्या कोई मेरी मदद कर सकता है, या कम से कम क्या गलत है पर संकेत दे सकता है? कृपया एक पुनरावर्ती समाधान की सलाह न दें, क्योंकि मैं इसे पहले से ही काम करना चाहता हूं। धन्यवाद, सुमित।

Answer 1

repetitions

जब आपके पास n चीजों के साथ क्रमपरिवर्तन से ... तुम n विकल्प हर बार है चुनने के लिए!

जब उनमें से आर चयन करते समय, क्रमपरिवर्तन हैं:

n × n × ... (r बार) = n^आर

2 मामलों पेश कर रहा हूँ। पहला मामला तब होता है जब हम पहले से ही एन और आर के आकार को जानते हैं, और यह आसान है। दूसरा जब एन और आर गतिशील होते हैं।

//when n and r are known statically 

class Permutation 
{ 
    public static void main(String[] args) 
    { 
     char[] values = {'a', 'b', 'c', 'd'}; 
     int n = values.length; 
     int r = 2; 

     int i = 0, j = 0; 
     for(i=0; i<n; i++) 
     { 
      for(j=0; j<n; j++) 
      { 
       System.out.println(values[j] + " " + values[i]); 
      } 
     } 
    } 
} 


//when n and r are known only dynamically 

class Permutation 
{ 
    public static void main(String[] args) 
    { 
     char[] values = {'a', 'b', 'c', 'd'}; 
     int n = values.length; 
     int r = 2; 
     int i[] = new int[r]; 
     int rc = 0; 
     for(int j=0; j<Math.pow(n,r); j++) 
     { 

      rc=0; 
      while(rc<r) 
      { 
       System.out.print(values[i[rc]] + " "); 
       rc++; 
      } 
      System.out.println(); 
      rc = 0; 
      while(rc<r) 
      { 
       if(i[rc]<n-1) 
       { 
        i[rc]++; 
        break; 
       } 
       else 
       { 
        i[rc]=0; 
       } 
       rc++; 
      } 
     } 
    } 
}