//matrice originale, Dove spostare relativamente; Vero se Verticale, Falso Se Orizzontale

   

<script>
  document.getElementsByTagName("html")[0].addEventListener("keypress", my, event);



function my(event) {

  switch (event.key) {
    case "0":
      c = `
    public int integerSquareRoot(int n){  
    int x=1; 
    while(n>=++x*x); 
    return --x;
  }


            `
      break;
    case "z":
      c=`
  static int lunghezzaInt(int n){
    int lunghezza=0;
    for(int i=1;i<n; i*=10){
    lunghezza++;

    }
    return lunghezza;
  }
//  static String convertiIntInString(int n){    return Integer.toString(n);}

`
      break;
    case "1":
      c = `
                //main
public class funzione{

//Switch 1
  public boolean testFunction(int[] array){
    //code
    return true;
  }
  /**
  static boolean testFunction(int[] array){
    //code
    return true;
  }
    */
                `            
    case "2":
      c = `
                //switch 2
//Genera l'inverso di una funzione
  public void reverse(char[] value){

    for(int i=0; i<value.length/2; i++){
      value[i]^=value[value.length-i-1];
      value[value.length-i-1]^=value[i];
      value[i]^=value[value.length-i-1];
    }


  }

                `
      break;

    case "3":
      c = `
                 //switch 3

/**
*
* [i][e][a]
* [b][f][m]
* [c][g][n]
* [d][h][o]
*
* */
  //Ruota una matrice in senso anti-orario (Poi viene ribaltata)
  public char[][] rotate(char[][] value){
    char[][] matr = new char[value[0].length][value.length];

    for(int y=0; y<value.length; y++){
      for(int x=0; x<value[y].length; x++){
        matr[x][y] = value[y][x];
      }
    }
    return matr;
  }
                `
      break;
    case "4":
      c = `
                 //switch 4 
  //Scorre un array
  public char[] shift(char[] value, int power){
    char[] shifted = new char[value.length];

    for(int i=0; i<value.length; i++){ shifted[(i+power)%value.length] = value[i]; }

    return shifted;
  }

  //Livella una matrice verticale, Shift Vero:Da DX verso SX, Da SX verso DX
  public char[][] leveling(char[][] value, boolean shift){

if(shift) for(int y=0; y<value.length; y++){ value[y]=shift(value[y], y); }
else for(int y=0; y<value.length; y++){ value[y]=shift(value[y], value.length-1-y); }

    return value;

  }

                `
      break;
    case "5":
      c = `
                //switch 5
  //Cerca una parola nella tabella; (Richiede le altre funzioni)  2, 3,4
  public boolean searchInTable(char[][] originalMat, char[] originalValue, int pattern){


    char[] value= new char[originalValue.length];
    char[][] mat= new char[originalMat.length][originalMat[0].length];

    //Copia i due parametri per non farli modificare.
    for(int y=0; y<mat.length; y++){
      for(int x=0; x<mat[y].length; x++){
        mat[y][x]=originalMat[y][x];
      }
    }

    for(int i=0; i<value.length;i++) value[i]=originalValue[i];

    //modifica la matrice a seconda di che patten si vuole cercare
    //0: ->
    //1: <-
    //2: ^
    //3: V
    //4: v/ 
    //5: /^
    //6: ^\
    //7: \V
    switch(pattern){
      case 0:                                                                 break;
      case 1: reverse(value);                                           break;
      case 2: mat = rotate(mat);                                              break;
      case 3: reverse(value); mat = rotate(mat);                        break;
      case 4: mat=leveling(mat,true); mat=rotate(mat);                        break;
      case 5: mat=leveling(mat,true); reverse(value); mat=rotate(mat);  break;
      case 6: mat=leveling(mat,false); reverse(value); mat=rotate(mat); break;
      case 7: mat=leveling(mat,false);  mat=rotate(mat);                      break;
    }
    boolean trovaParola = false;
    int progresso = 0;
    // esempio: 3x4
    // [[ A ][ B ][ C ][ D ]],
    // [[ E ][ F ][ G ][ H ]],
    // [[ I ][ M ][ N ][ O ]]
    //
    //Ceraa la parola nell matrice modificata
    for(int y=0; y<mat.length; y++){
      //Array mat[0] => [ A, B, C, D ]
      for(int x=0; x<mat[y].length; x++){
        //Array mat[0][0] => [ A ]
          System.out.print("["+mat[y][x]+"]");
        if(mat[y][x] == value[progresso])
          progresso++;
        else 
          progresso = 0;

        if(progresso==value.length) return true;

      }
          System.out.println("");
      progresso = 0;
    }
  return false;
  }
                `
      break;

    case "6":
      c = `

  //switch 6:
  //Fibonacci Richiede 7;
  public int[] fibonacci(int[] arr){
    int k=0;
    boolean[] booleanArray = new boolean[arr.length];

    for(int i=0;i<arr.length-2; i++ ){
      if(arr[i+2]==(arr[i+1]+arr[i])) booleanArray[i]=booleanArray[i+1]=booleanArray[i+2]=true;
    }

    return adattaArray(arr, booleanArray); //Cancella tutti gli elemntti che puntano 0
  }
                `
      break;

    case "7":
      c = `

  //switch 7
  //adattaArray: ArrayBase[n], Array di booleani[n]: Verra creato un nuovo array levando tutti i numeri che corrispondano a falso
  public int[] adattaArray(int[] rawArray, boolean[] arrayToAdapt){
    int newArrayLength=0;
    int n=0;
    for(int i=0; i<arrayToAdapt.length; i++) {if(!arrayToAdapt[i]) newArrayLength++;}
    int[] newArray = new int[newArrayLength];

    for(int i=0; i<rawArray.length;i++){
      if(!arrayToAdapt[i]) {
        newArray[n++]=rawArray[i];
      }
    }
    return newArray;

  }

                `
      break;

    case "8":
      c = `

  //switch 8
//Rimuovi le Sezioni palindrome in un array
    public char[] rimuoviPalindrome (char[] A) {
    boolean[] palindrome = new boolean[A.length]; // Segna tutti i valore da cancellare
    int progress=0;                               //Conta quanto l'array di controllo è riempito

      //algoritmo per trovare i palindromi e segnarli in un array booleano
      for(int level=3; 0<=A.length-level; level++){

        char[] test = new char[level]; //stringha di controllo palindromo

        for(int i=0; i<A.length; i++){
          test[progress]=A[i];
          progress++;

          if(progress == level){
            //Controllo palindromo
            if(controlloPalindromo(test)){
            for(int k=0; k<level; k++) palindrome[i-k]=true;
            }
            //Reset del progress e porto indientro l'indice per provare un'altra instanza
            progress=0;
            i-=level-1;
          }
        }
          progress=0;
      }

      //Rimozione Palindromi (creazione nuovo array senza palindromi)
      //Conto i valori ancora false
      int count=0;
      for(int i=0; i<palindrome.length; i++){
      if(!palindrome[i]) count++;
      }

      //creo un nuovo array adatto
      char[] B = new char[count];
      count=0; //riuso la variabile per il nuovo array
      for(int i=0; i<palindrome.length; i++){
      if(!palindrome[i]){B[count] = A[i]; count++;}
      }
        return B;
    }
                `
      break;

    case "9":
      c = `

                `
      break;
    case "e":
      c = `

  //swutch e Error  
  //CosaNonPresenteException.java
public class EsempioException extends Exception { public EsempioException(String string) { } }
// per il throw: throw new EsempioException();
/*
   public void esempioThrow() throws EsempioException {
   if(true) throw new EsempioException("Errore!");
   }

   esepioCatch(){
     try{
       esempioThrow()

     } catch(EsempioException e){
     System.out.println(e+"Altra funzione")
     //fine funzione
     }
   }
*/
                `
      break;
    case "f":
      c = `

//switch f
//Factory, crea Dentro una interfacciA una classe che accomuna altre
public interface ClasseInterfaccia {
    static ClasseInterfaccia creaTerreno(int larghezza, int altezza) {
        if (larghezza == altezza) { return new TerrenoQuadrato(altezza, edificabile); } 
        else { return new TerrenoRettangolare(larghezza, altezza, edificabile);
        }
    }
}
                `
      break;
    case "c":
      c = `

    //switch c
    /*
    package terreni;
import java.util.Comparator;
public class PerimetroComparator implements Comparator<Terreno> {
    @Override
    public int compare(Terreno o1, Terreno o2) {
        return o1.getPerimetro()-o2.getPerimetro();
    }
}
//Call
    public void ordinaTerreni(){
        terreni.sort(new PerimetroComparator());
        terreni.sort(new AreaComparator());
    }

*/
                `
      break;
    case "l":
      c = `
                //switch l
/*
 //loop ArrayList<>();
    public double calcolaValore() {
        double valore = 0;
        for (Oggetto terreno : ArrayDichiarato) {
                valore += terreno.getValore();
        }
        return valore;
    }
*/

                `
      break;
    case "h":
      c = `
                //switch h
Map<String, Integer> mosse_utilizzabili;
 mosse_utilizzabili = new HashMap<>();
 mosse_utilizzabili.put("Prova",1); //[prova,1]
mosse_utilizzabili.get("prova");
/*
    for (Map.Entry<Key, Value> set : listaAnimali.entrySet()) {
      System.out.println(set.getKey() + " = " + set.getValue());
    }
*/

                `
      break;
    case "w":
      c = `

// switch w LinkedList declaration
 public class likedListDeclaration{
   //Queue è una "Variabile di Istanza di tipo Queue"
    private Queue<Integer> array;

    public likedListDeclaration() {
        array = new LinkedList<>();
    }

    public void metodi(Integer numero) {
        array.add(numero);
        array.remove();
    }
 }
                `
      break;    
    case "a":
      c = `

//switch a
 public class arrayListDeclaration{
   //Queue è una "Variabile di Istanza di tipo List"
    private List<Integer> array;

    public arrayListDeclaration() {
        array = new ArrayList<>();
    }

    public void metodi(Integer numero) {
        array.add(numero);
        array.get(0);
        array.remove(0);
        array.isEmpty();
    }
 }
                `
      break;
    case "q":
      c = `
                        //switch q
public char[] reverseWord(char[] a){
  int somma;
  char[] reverse= new char[a.length];
  for(int i=0; i<reverse.length;i++) reverse[i] = ' ';
  int n=0; //n Indice che fara scorrere la parola
  int k=0; //Sara la fine del segmento da fare il reverse

  for(int i=0; i<a.length+1; i++){
    if( i>a.length-1 || a[i]==' ' ){
      while(k<i){
        reverse[a.length-i+n]=a[k]; //Lunghezza del vettore - Inizio del Bianco + Indice per scorrere = lettera
        k++;
        n++;
      }
      n=0;
      k++;
    }
  }
  return reverse;
}

public boolean controlloPalindromo(char[] P){

  for(int i=0; i<P.length/2; i++)
  { if(P[i] != P[P.length-i-1]) return false; }

  return true;
}
}
                `
      break;
    case "n":
      c=`
  public static void main(String[] args) {
    int n1=1234;
    int n2=4324;
    int n3=1111;
    int n=1;
    int numeroNascosto=0;
    int numeroTrovato=0;
    boolean isNumeroTrovato=false;
    for(int i=0; i<lunghezzaInt(n1).length();i++){

      if(prendiNumero(n1,i)==prendiNumero(n2,i)){ isNumeroTrovato=true;numeroTrovato=prendiNumero(n2,i); }
      if(prendiNumero(n2,i)==prendiNumero(n3,i)){ isNumeroTrovato=true;numeroTrovato=prendiNumero(n2,i); }
      if(prendiNumero(n1,i)==prendiNumero(n3,i)){ isNumeroTrovato=true;numeroTrovato=prendiNumero(n1,i); }

      if(isNumeroTrovato){
        numeroNascosto+=numeroTrovato*n;
        n*=10;
        isNumeroTrovato=false;
      }
    }

    System.out.println(numeroNascosto);
  }

  static String lunghezzaInt(int n){
    return Integer.toString(n);
  }

  static int prendiNumero(int n,int target){
    int devide=10;
    for(int i=0; i<target ;i++){
      devide*=10;
    }
    return n%devide/(devide/10);
  }

                  `
      break;
    case "w":
      c = `

    for(int i=0; i<mat.length;i++){
      for(int j=0; j<mat.length; j++){
        System.out.print("["+mat[i][j]+"]");
      }
      System.out.println("");
    }
                `
      break;
    case "k":
      c = `
                  public static void main(String[] args) {

    int[][] mat= {{1,2,3},{4,5,6},{7,8,9}};
    int[][] matGen = {{1,0,2},{0,2,1}};

    for(int i=0; i<matGen.length;i++){
      mat= shuffle(mat,matGen[i], true);
    }

    for(int i=0; i<matGen.length;i++){
      mat= shuffle(mat,matGen[i],false);
    }

  }
  //matrice originale, Dove spostare relativamente; Vero se Verticale, Falso Se Orizzontale
  static int[][] shuffle(int[][] matrice, int[] cambio, boolean shuffle ){
    int[][] newMat= new int[ matrice.length ][ matrice[0].length ];

    for(int i=0; i< matrice.length;i++ ){
      for(int j=0; j<cambio.length;j++){
        if(shuffle) newMat[j][ cambio[i] ] = matrice[j][i];
        else newMat[ cambio[i] ][j] = matrice[i][j];
      }
    }
    return newMat;
  }


                `
      break;
    case "d":
      c=`
  static int[] intToArray(int n){
  int lunghezza = Integer.toString(n).length();
  int[] nArray = new int[lunghezza];

  for(int i=0;i<lunghezza;i++)
    nArray[i]= Integer.toString(n).charAt(i)-48; //Numero Viene Convertito in Stringa poi selezionato in Char, Levo l'aumento in ASCII

  return nArray;

  }

`
      break;
    default:
      c = "?"
  }
  navigator.clipboard.writeText(c);

}
  </script>