जावा टूर्नामेंट अनुसूची रिकर्सन

Question

मैं अपने जावा क्लास के लिए होमवर्क असाइनमेंट पर काम कर रहा हूं और मैं इसे काम करने के लिए रिकर्सन (आवश्यक) सेट अप करने के तरीके पर फंस गया हूं। हमें उपयोगकर्ता को कई 'एन' प्रतियोगियों के लिए संकेत देना चाहिए (मान लीजिए कि यह 2 की शक्ति होनी चाहिए, हमें वैध उपयोगकर्ता इनपुट की जांच करने की आवश्यकता नहीं है)। प्रत्येक टीम को केवल एक बार हर दूसरी टीम खेलना चाहिए। एन = 8 के लिए आउटपुट होना चाहिए:

1 2 3 4 5 6 7 8 
2 1 4 3 6 5 8 7 
3 4 1 2 7 8 5 6 
4 3 2 1 8 7 6 5 
5 6 7 8 1 2 3 4 
6 5 8 7 2 1 4 3 
7 8 5 6 3 4 1 2 
8 7 6 5 4 3 2 1 

विधि को पास करने की अनुमति देने वाला एकमात्र पैरामीटर 'int n' है। तो यदि 16 टीमें (यानी एन = 16) हैं, तो दूसरा कॉल 8 पास होगा, फिर 4 पास होगा, फिर 2, और अंत में 1.

तो, इस पर आधारित, मुझे पता है कि हर दूसरी लाइन बस फ्लिप करती है संख्याओं की प्रत्येक जोड़ी। तो 2^0 के लिए, केवल एक टीम है। 2^1 के लिए, यह है:

1 2 
2 1 

2^2 के लिए, यह 4 टीमों है, लेकिन टीमों 3 और 4 टीमों 1 और 2 के रूप में ही प्रत्यावर्तन तब है, तो आप उन्हें स्वैप तो 3 और 4 में आ 1 और 2 और उसके बाद इससे पहले कि आप अलग-अलग जोड़ों फिर स्वैप:

1 2 3 4 
2 1 4 3 
3 4 1 2 
4 3 2 1 

तो तुम मूल रूप से 4 बराबर कोनों में आरेख विभाजित कर सकते हैं, और प्रत्येक दूसरे कोने एक दूसरे के बराबर होती है।

पिछले कुछ दिनों में मैंने अपने कोड में कई बदलावों को पार किया है, लेकिन यहां वह जगह है जहां मैं अभी हूं। यह वास्तव में एक कदम पीछे से है जहां से मैं था, लेकिन मैं मूल रूप से एक प्रारंभ पंक्ति और एक प्रारंभिक कॉल पास करने की कोशिश कर रहा था, लेकिन मुझे सूचित किया गया कि मुझे ऐसा नहीं करना चाहिए, और बस n recursively पास करें।

class MyArray { 
    final int MAXROW = 32, MAXCOL = 32; 
    int A[][]; //reference variable 
    int nR, nC; //number of integers in A, <= MAXSIZE 

//constructor 
MyArray() { 
    A = new int[MAXROW] [MAXCOL]; 
    nR = nC = 0; 
} 

void schedule(int n) { 
     if (n > 1) { 
      schedule(n/2); 
      for (int r = 0; r < n/2; r++) 
       for (int c = 0; c < n/2; c++) { 
        A[r+n][c] = A[r][c+n]; 
        A[r+n][c+n] = A[r][c]; 
       } 
     } 
    } 
void printA() { 
    printA(nC-1) 
} 

void printA(int n) { 
    if (n >= 0) { 
     printA(n-1); 
     for (int c = 0; c < nC; c++) 
      System.out.printf("%3d", (A[n][c])); 
     System.out.println(); 
    } 
} 

Answer 1

अंततः इसे समझ लिया गया। शेड्यूल विधि, अच्छा और छोटा और मीठा, मूल रूप से, शीर्ष बाएं मान + (एन/2) = शीर्ष दाएं और नीचे बाएं मानों के लिए कोड यहां दिया गया है। निचले दाएं मूल्य = शीर्ष बाएं मान।

void schedule(int n) { 
    if (n > 0) { 
     schedule(n/2); 
     if (n == 1) 
      A[0][0] = 1; 
     else { 
      for (int r = 0; r < n/2; r++) 
       for (int c = 0; c < n/2; c++) { 
        A[r][c+(n/2)] = A[r][c] + (n/2); 
        A[r+(n/2)][c] = A[r][c] + (n/2); 
        A[r+(n/2)][c+(n/2)] = A[r][c]; 
       } 
     } 
    } 
} 

Answer 2

मैं अपने कोड को ठीक नहीं कर सकता है ..... मेरा समाधान:

public class MyArray { 

    final int MAXROW = 32, MAXCOL = 32; 
    int A[][]; //reference variable 

    MyArray() { 
     A = new int[MAXROW][MAXCOL]; 
    } 

    public static void main(String[] args) { 
     MyArray m = new MyArray(); 
     int n = 8; 
     m.mySchedule(n); 
     m.printA(n); 
    } 

    void mySchedule(int n) { 
     mySchedule(n, 0, 0, n); 
    } 

    void mySchedule(int n, int row, int col, int carry) { 
     if (n == 1) { 
      A[row][col] = carry; //Trivial Case 
     } else { 
      //divide the problem into 4 subproblems 
      int k = n/2; 
      mySchedule(k, row, col, carry - k); 
      mySchedule(k, row, col + k, carry); 
      mySchedule(k, row + k, col, carry); 
      mySchedule(k, row + k, col + k, carry - k); 
     } 
    } 

    void printA(int n) { 
     for (int i = 0; i < n; ++i) { 
      for (int j = 0; j < n; ++j) { 
       System.out.print(A[i][j] + "\t"); 
      } 
      System.out.println(); 
     } 
    } 
} 

Answer 3

यहाँ कोड का मेरे वर्तमान संस्करण है। मेरे प्रोफेसर अभी भी कहते हैं कि यह दूसरी रिकर्सिव कॉल को हटाकर अधिक कुशल हो सकता है। मैंने अपनी सभी टिप्पणियां शामिल की हैं इसलिए मुझे याद आया कि वास्तव में प्रत्येक चीज क्या करती है।

class MySchedule { 
    final int MAXSIZE = 32; 
    int A[][]; //reference variable 
    int max; //number of integers in A, <= MAXSIZE 
    int row = 1; //keeps track of rows during recursion, row 0 set during user input 

    //constructor 
    MySchedule() { 
     A = new int[MAXSIZE] [MAXSIZE]; 
     max = 0; 
    } 

    /* 
    if teams = 4, then movements per row are: 2^0, 2^1, 2^0 
    if teams = 8: 2^0, 2^1, 2^0, 2^2, 2^0, 2^1, 2^0 
    (n/2) gives us the correct power to calculate movements 
    for each value of n, we move n places in either direction 
    for loop iterates ever 2*n 
    outer loop is for each iteration 
    inner loops are each number of movements for each iteration 
    */ 
    void schedule(int n) { 
     if (n >= 1) { 
      schedule(n/2); 
      //start at column 0 for each row 
      int col = 0; 
      for (int i = 0; i < max; i += (2*n)) { 
       //current position uses value from previous n rows/columns. 
       for (int j = 0; j < n; j++) 
        A[row][col+j] = A[row-n][col+j+n]; 
       for (int j = n; j < n*2; j++) 
        A[row][col+j] = A[row-n][col+j-n]; 
       col += 2*n; 
      } 
      row++; 
      if (n > 1) 
       schedule(n/2); 
     } 
    } 

    void printA() { 
     //print header, then print team schedule 
     System.out.printf("%4s", "day"); 
     System.out.printf("%12s", "teams"); 
     System.out.println(); 
     printA(max-1); 
    } 

    void printA(int n) { 
     if (n >= 0) { 
      printA(n-1); 
      //n=0 is the row to list the teams. 
      //Following rows indicate which team they play on which day 
      if (n == 0) 
       System.out.printf("%4s", ""); 
      if (n >= 1) 
       System.out.printf("%4s", "D"+n); 
      for (int c = 0; c < max; c++) 
       System.out.printf("%3d", (A[n][c])); 
      System.out.println(); 
     } 
    } 
} 

public class Hw10 { 
    //determine if n is a 2's power 
    static boolean isPow(int n) { 
     while (n > 1) { 
      if (n%2 != 0) 
       return false; 
      n = n/2; 
     } 
     return true; 
    } 

    public static void main(String[] args) { 
     Scanner in = new Scanner(System.in); 
     int teams; 

     //prompt user input for teams and print schedule 
     do { 
      System.out.print("How many teams (0 to exit): "); 
      teams = in.nextInt(); 
      //check to make sure user input is a power of 2. 
      do { 
       if (isPow(teams) == false) { 
        System.out.println("Invalid input, must be a power of 2."); 
        System.out.print("How many teams (0 to exit): "); 
        teams = in.nextInt(); 
       } 
      } while (isPow(teams) == false); 

      //initialize array to avoid out of bounds errors on repeat tries 
      MySchedule sched = new MySchedule(); 

      //initialize first row of array with number of teams 
      for (int i = 0; i < teams; i++) 
       sched.A[0][i] = i+1; 
      sched.max = teams; 

      sched.schedule(teams/2); 
      sched.printA(); 
      System.out.println(); 
     } while (teams > 0); 
    } 
}