int factorial(int n){
      if(n==0) return 1;   //AXIOMA
      else return n*factorial(n-1);  //FORMULA RECURSIVA
   }  

    int fibonaci(int n){
      if(n==1 || n==2) return 1;
      else return fibonaci(n-1)+fibonaci(n-2);
    }  

    int division (int a, int b)
    {
	if(b > a) return 0;
	else
	    return division(a-b, b) + 1;
    }
 

     int invertir (int n)
    {
	if (n < 10)         //caso base
	    return n;
	else
	    return (n % 10) + invertir (n / 10) * 10;
    }

     int sumar_dig (int n)
    {
	if (n == 0)      //caso base
	    return n;
	else
	    return sumar_dig (n / 10) + (n % 10);
    }

     int mult_rusa(int A, int B)
    { 
        if(A==1){
	    return (B);
	}
	if(A%2!=0){
	return(B+mult_rusa( A/2 , B*2));
	}
	else{
	return(mult_rusa( A/2 , B*2));
	}                                
    }

     int suma_vec(int v [], int n)
    {
	if (n == 0)
	    return v [n];
	else
	    return suma_vec(v, n - 1) + v [n];
    }

     int multiplicar (int vec [], int tam)
    {
	if (tam == 0)
	    return (vec [0]);
	return (vec [tam] * multiplicar (vec, tam - 1));
    }

    int sacar_mcd(int a, int b) {
        if(b==0)
            return a;
        else
            return sacar_mcd(b, a % b);
    }
 

   public boolean positivo(int n){
    	if(n>0) return true;
    	else return negativo(n);
    }
 
    public boolean negativo(int n){
    	if(n<0) return false;
    	else return  positivo(n);
    }

        public boolean par(int n){
		if(n==0) return true;
		else return impar(n-1);
	}
 
	public boolean impar(int n){
		if(n==0) return false;
		else return par(n-1);
	}

     int suma (int fila, int col, int orden, int mat [] [])
    {
	if (fila == 0 && col == 0)
	    return mat [0] [0];
	else
	    if (col < 0)
		return suma (fila - 1, orden, orden, mat);
	    else
		return mat [fila] [col] + suma (fila, col - 1, orden, mat);
    }

     latino (int fila, int col, int cont, int orden, int mat [] [])
    {
	if (fila == 0 && col == 0)
	    mat [0] [0] = 1;
	else
	    if (fila == col)
		latino (fila - 1, orden - 1, orden, orden, mat);
	    else
	    {
		mat [fila] [col] = cont;
		latino (fila, col - 1, orden + 1, orden, mat);
	    }
    }

public class MatrizRecursividad {
 
	private static int a=0, aux=1, b=0; //Declaramos los datos necesarios
	private static int[][] matriz = new int[6][6]; //La matriz debe ser cuadrada
 
	public static void main(String[] args) {
 
		llenarMatriz(matriz, a, b); //Iniciamos el llamado recursivo
		imprimir(); //imprimimos la matriz
 
	}
 
	public static void llenarMatriz(int matriz[][], int i, int j){
 
		if(j > matriz.length -1){ //Si llegó a la ultima coluna, reseteamos los datos para la siguiente
			i++;
			j=0;
			aux++;
		}
		if(i <matriz.length){ // compara que no hallamos llegado al final
 
			if(i==(aux-1) && j >= (aux-1)){ //comprueba que estemos en el lugar adecuado, es decir ira imprimiento escaladamente
				if(i==0)// si es la primera fila ingresamos aux=1
					matriz[i][j] = matriz[i][j]=aux;
				else
					matriz[i][j] = matriz[i][i-1]*2;//ingresamos el valor correspondiente al ultimo de la "escala" *2
				llenarMatriz(matriz, i , j+1);
			}
			else{ //si no, asignamos los valores anteriores de la escala
				if(j==0)// comprobamos si es el primer digito a ingresar
					matriz[i][j] = j+1;
				else
					matriz[i][j] = matriz[i-1][j];// asignamos el mismo numero de la fila anterior (i-1)
				llenarMatriz(matriz, i, j+1);
			}
		}
	}
 
	public static void imprimir(){ //este metodo nos imprime la matriz por consola
 
		for(int i=0; i< matriz.length; i++){
			for(int j=0; j< matriz.length; j++){
				System.out.print(matriz[i][j] + " ");
			}
			System.out.print("\n");
		}
	}
 
}

    void magico(int mat [] [], int fil, int colmedio, int c, int n)
    {
	if (c == n * n)
	{
	    mat [n-1] [colmedio] = c;
	}
	else
	{
	    if (fil < 0 && colmedio == n)
	    {		
		magico(mat, fil + 2, n - 1, c, n);
	    }
	    else
	    {
		if (fil < 0)
		{
		    magico(mat, n - 1, colmedio, c, n);
		}
		else
		{
		    if (colmedio == n)
		    {
			magico(mat, fil, 0, c, n);
		    }
		    else
		    {
			if (mat [fil] [colmedio] == 0)
			{
			    mat [fil] [colmedio] = c;
			    magico(mat, fil - 1, colmedio + 1, c + 1, n);
			}
			else
			{
			    magico(mat, fil + 2, colmedio - 1, c, n);
			}
		    }
		}
	    }
 
	}
    }

        int menorvec (int x [], int n, int menor) {
        if (n == 0)
            if (menor > x [n]) return x [0];
            else return menor;
        else
            if (menor > x [n]) return menorvec (x, n - 1, x [n]);
            else return menorvec (x, n - 1, menor); }

        int mayor (int numeros [], int posicion) {
        int aux;
        if (posicion == 0) return numeros [posicion];
        else {
            aux = mayor (numeros, posicion - 1);
            if (numeros [posicion] > aux) return numeros [posicion];
            else return mayor (numeros, posicion - 1);
         }     
        }