Permutazioni.java

package main;

class Permutazioni {
  private static int LUNGHEZZA_PERMUTAZIONE;
  private static int N_SIMBOLI;
  private static int[] basi;
  private static int[] permutazione_iniziale;
  private static int[] permutazione_finale;
  public static int[] getPermutazioneFinalestatic(){
    return permutazione_finale;
}


  /**
   * Aggiungi i commenti sui parametri in input e spiega cosa ristorna il metodo nell'apposita riga.
   * @param lunghezza_permutazione
   * @param n_simboli
   */
  public static void inizializza(int lunghezza_permutazione, int n_simboli){
    LUNGHEZZA_PERMUTAZIONE = lunghezza_permutazione;
    N_SIMBOLI = n_simboli;
    basi = new int[LUNGHEZZA_PERMUTAZIONE];
    permutazione_iniziale = new int[LUNGHEZZA_PERMUTAZIONE];
    permutazione_finale = new int[LUNGHEZZA_PERMUTAZIONE];
    for (int i = 0; i < LUNGHEZZA_PERMUTAZIONE; i++){
      basi[i] = N_SIMBOLI;
      permutazione_iniziale[i] = 0;
      permutazione_finale[i] = N_SIMBOLI-1;
    }
  }

  // permutazioni di uguale lunghezza

  /**
   * Aggiungi i commenti sui parametri in input e spiega cosa ristorna il metodo nell'apposita riga.
   * @param permutazione1
   * @param permutazione2
   * @return
   */
  public static int[] sommaPermutazioni(int[] permutazione1, int[] permutazione2) {
    int riporto = 0;
    int somma = 0;
    int[] ris = new int[LUNGHEZZA_PERMUTAZIONE];

    for(int i = LUNGHEZZA_PERMUTAZIONE-1; i >= 0; i--){
      somma = (permutazione1[i]+permutazione2[i]+riporto)%basi[i];
      riporto = (permutazione1[i]+permutazione2[i]+riporto)/basi[i];
      ris[i] = somma;
    }
    return ris;
  }

  // restituisce una copia della permutazione iniziale
  public static int[] iniziale() {
    int[] ris = new int[LUNGHEZZA_PERMUTAZIONE];
    for (int i = 0; i < LUNGHEZZA_PERMUTAZIONE; i++){
      ris[i] = permutazione_iniziale[i];
    }
    return ris;
  }

  /**
   * Aggiungi i commenti sui parametri in input e spiega cosa ristorna il metodo nell'apposita riga.
   * @param permutazione
   * @param n_passi
   * @return
   */
  public static int[] successiva(int[] permutazione, int n_passi) {
    int N = permutazione.length;
    int[] ris = permutazione;
    for (int i = 0; i < n_passi; i++)
      ris = successiva(ris);
    return ris;
  }

  /**
   * Aggiungi i commenti sui parametri in input e spiega cosa ristorna il metodo nell'apposita riga.
   * @param permutazione
   * @return
   */
  public static boolean eFinale(int[] permutazione) {
    return uguali(permutazione, permutazione_finale);
  }

  /**
   * Aggiungi i commenti sui parametri in input e spiega cosa ristorna il metodo nell'apposita riga.
   * @param permutazione
   * @return
   */
  public static int[] successiva(int[] permutazione) {
    int[] uno = new int[]{ 0, 0, 0, 0, 0, 1};
    return sommaPermutazioni(permutazione, uno);
  }

  /**
   * Aggiungi i commenti sui parametri in input e spiega cosa ristorna il metodo nell'apposita riga.
   * @param permutazione
   */
  public static void stampa(int[] permutazione){
    StringBuffer out = new StringBuffer(LUNGHEZZA_PERMUTAZIONE*6);

    // Qui utilizza un ciclo per concatenare allp string buffer out
    // tutti i numeri che stanno nelle celle dell'array, separati da uno spazio l'uno dall'altro

    System.out.println(out.toString());
  }

  /**
   * Aggiungi i commenti sui parametri in input e spiega cosa ristorna il metodo nell'apposita riga.
   * @param seq1
   * @param seq2
   * @return
   */
  public static boolean uguali(int[] seq1, int[] seq2){
    if(seq1.length != seq2.length)
      return false;

    // Qui utilizza un ciclo per confrontare i due array cella per cella.
    // Appena trovi due celle alla stessa posizione con contenuto differente ritorna false. ;)

    return true;
  }

  public static void generaOgniPermutazione(){
    int[] permutazione = iniziale();

    // Qui inserisci un ciclo while che ad ogni iterazione
    // 1- stampa l'array permutazione
    // 2- passa alla pemutazione successiva
    // ;)

    stampa(permutazione);
  }

  /**
   * Aggiungi i commenti sui parametri in input e spiega cosa ristorna il metodo nell'apposita riga.
   * @param permutazione
   * @param pos
   *
   * Questo è il metodo ricorsivo per generare le permutazioni.
   * Come vedi utilizza l'overloading !
   *   ;)
   */
  public static void generaOgniPermutazioneRic(int[] permutazione, int pos){
    for (int k = 0; k < N_SIMBOLI; k++){
      permutazione[pos] = k;
      if (pos < permutazione.length - 1)
        generaOgniPermutazioneRic(permutazione, pos+1);
      else // pos == permutazione.length - 1
        stampa(permutazione);
    }
  }

  /**
   * Questa è la chiamata per avviare il metodo ricorsivo per generare le permutazioni. ;)
   */

  public static void generaOgniPermutazioneRic(){
    int[] permutazione = iniziale();
    generaOgniPermutazioneRic(permutazione, 0);
  }

}