Thread: Exercise problem

Hello .. I would like to help with this exercise. I think it has to do with recursion .... but I do not have a clear idea.

A magic carpet of order n (0 ≤ n ≤ 5 ) and parameter k (0 ≤ k <9 ) `
and a 3^n× 3^n matrix , to binary values ​​, defined inductively as follows:
• if n = 0 ( 1 × 1 matrix ) , then the only element of the array is 1 ;
• if n> 0 (matrix 3^n × 3^n ) , consider a subdivision of the matrix in 9
blocks of size 3^n- 1 × 3^n- 1 each. Consider numbered from 0 to 8
the blocks , in this way :
0 1 2
3 4 5
6 7 8
The block number j (0 ≤ j <9 ) `
and in turn
- A block of elements all equal to zero , if j = k ;
- A magic carpet of order n - 1 and parameter k , if j = k .
You want to create a Java program that data nek print a representation
text of a magic carpet of order n and parameter k .
Input format . The input `
and structured in the following way :
• a line containing two integers n and k , separated by a space.
Assume that nek satisfying constraints 0 ≤ n ≤ 5, 0 ≤ k <9 .
Output Format . You should print a magic carpet of order n parameter
k , according to the following code:
• the values ​​equal to 0 are represented by the character ' . ' ;
• the values ​​equal to 1 are represented by the character ' * ' .
The values ​​in the same row are not separated by spaces. Each row of the matrix is
and
completed by the usual newline ' \ n ';


for example if I choose n = 2 and k = 4 this print

*********
*.**.**.*
*********
***...***
*.*...*.*
***...***
*********
*.**.**.*
*********

Thanks!

Originally Posted by Norm

What have you tried?

import java.io.*;
import java.util.*;




class Tappeto_Magico {
*int[][] m;
*int k;
*int num=1;
*Tappeto_Magico(int n,int k){
* * *this.m=new int[(int)Math.pow(3,n)][(int)Math.pow(3,n)];
* * *this.k=k;
*}
void matrice(int n,int k,int i1,int j1,int h){
* * if(n==0){
* * * *m[0][0]=0;
* * * *return;
* * }else{
* * if(n==1){
* * * *int cas=0;
* * * * *for(int i=i1;i<3;i++){
* * * * * *for(int j=j1;j<3;j++){
* * * * * * * *if(cas==k){
* * * * * * * * m[i][j]=0; **
* * * * * * * *}
* * * * * * * *cas++;
* * * * * *}
* * }
* * }else{
* * * * for(int g=0;g<9;g++){
* * * * * * int cas1=0;
* * * * * * for(int i=i1;i<m.length/(Math.pow(3,h));i++){
* * * * * *for(int j=j1;j<m.length/(Math.pow(3,h));j++){
* * * * * * * *if(cas1==g){
* * * * * * * * * *m[i][j]=0;
* * * * * * * *}
* * * * * * * *cas1++;
* * * * * * *
* * * * * *}
* * * * * *}
* * * * * * *matrice(n-1,k,i1,j1,++h);
* * * * * * }
* * }
* * }
}
void stampa(){
* * * *for(int i=0;i<m.length;i++){
* * * * * *for(int j=0;j<m.length;j++){
* * * * * * * *System.out.print(m[i][j]);
* * * * * *}
* * * * * * System.out.print("\n");
* * * * * *}
}
*public static void main(String []args) throws IOException{
* * BufferedReader br=new BufferedReader( new InputStreamReader(System.in));
* * String s=br.readLine();
* * StringTokenizer st=new StringTokenizer(s);
* * int n=Integer.parseInt(st.nextToken());
* * int k=Integer.parseInt(st.nextToken());
* *Tappeto_Magico t=new Tappeto_Magico(n,k);
* *t.matrice(n,k,0,0,1);
* *t.stampa();
* *
* **
} * *
}

<import java.io.*;
import java.util.*;
 
class Magic_Carpet {
 int[][] m;
 int k;
 int num=1;
 Magic_Carpet(int n,int k){
     this.m=new int[(int)Math.pow(3,n)][(int)Math.pow(3,n)];
     this.k=k;
 }
void matrix(int n,int k,int i1,int j1,int h){
    if(n==0){
       m[0][0]=0;
       return;
    }else{
    if(n==1){
       int cas=0;
         for(int i=i1;i<3;i++){
           for(int j=j1;j<3;j++){
               if(cas==k){
                m[i][j]=0;   
               }else{
                   m[i][j]=1;
               }
               cas++;
           }
    }
    }else{
        int cas1=0;
        int rig=0;
        int col=0;
        for(int g=0;g<9;g++){         
            for(int i=i1;i<m.length/(Math.pow(3,h));i++){
           for(int j=j1;j<m.length/(Math.pow(3,h));j++){
               if(cas1==g){
                   m[i][j]=0;
               }
               cas1++;
           }
           }
            rig++;
            col++;
             if(rig==3){
              j1=j1*2;
          }
          if(col==3){
 
          }
             matrix(n-1,k,i1,j1,++h);
            }
    }
    }
}
void print(){
       for(int i=0;i<m.length;i++){
           for(int j=0;j<m.length;j++){
               System.out.print(m[i][j]);
           }
            System.out.print("\n");
           }
}
public static void main(String []args) throws IOException{
BufferedReader br=new BufferedReader( new InputStreamReader(System.in));
String s=br.readLine();
StringTokenizer st=new StringTokenizer(s);
int n=Integer.parseInt(st.nextToken());
int k=Integer.parseInt(st.nextToken());
Magic_Carpet t=new Magic_Carpet(n,k);
t.matrix(n,k,0,0,1);
t.print();   
}    
}
>

I try to write the algorithm to print the magic carpet using recursion ... but I lose indices .... I thought that for the initial matrix 3 ^ n I have to cut it into 9 parts and then each part in other 9 shares and so on and on each submatrix I have to check if the block is equal numbered ako not.
printing of my code just makes me the basic step . I press
111000000000000000000000000
101000000000000000000000000
111000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000

this with n=3 and k=4!

now i work with post#5...

<import java.io.*;
import java.util.*;
 
class Magic_Carpet {
int[][] m;
int k;
int num=1;
Magic_Carpet(int n,int k){
this.m=new int[(int)Math.pow(3,n)][(int)Math.pow(3,n)];
this.k=k;
}
void matrix(int n,int k,int i1,int j1,int h){
if(n==0){
m[0][0]=0;
return;
 }else{
 if(n==1){
 int cas=0;
  for(int i=i1;i<3;i++){
   for(int j=j1;j<3;j++){
    if(cas==k){
    m[i][j]=0;   
    }else{
    m[i][j]=1;
    }
    cas++;
    }
   }
  }else{ 
  int cas1=0;
  int rig=0;
  int col=0;
  for(int g=0;g<9;g++){         
   for(int i=i1;i<m.length/(Math.pow(3,h));i++){
    for(int j=j1;j<m.length/(Math.pow(3,h));j++){
    if(cas1==g){
    m[i][j]=0;
    }
    cas1++;
    }
   }
   rig++;
   col++;
   if(rig==3){
   j1=j1*2;
   }
   if(col==3){
   }
   matrix(n-1,k,i1,j1,++h);
   }
}
 for(int i=0;i<m.length;i++){
  for(int j=0;j<m.length;j++){
 System.out.print(m[i][j]);
  }
 System.out.print("\n");
 }
}
public static void main(String []args) throws IOException{
BufferedReader br=new BufferedReader( new InputStreamReader(System.in));
String s=br.readLine();
StringTokenizer st=new StringTokenizer(s);
int n=Integer.parseInt(st.nextToken());
int k=Integer.parseInt(st.nextToken());
Magic_Carpet t=new Magic_Carpet(n,k);
t.matrix(n,k,0,0,1);
t.print();   
}    
}

I try to post it in the right way. My problem is that I need the solution within 12 hours .... so please help me because they do not really know how to do ... I do not know if my code is completely wrong or not ... so if you have a solution to the problem could post?

do you mean by power? What is not clear? the exercise asks you to print the magic carpet with power n and k we have chosen that would be the square of the matrix numbered ... I posted my code to figure out where I'm wrong but maybe I have it all wrong then ignoring my code look for a solution for this exercise.... thanks!

Thank you anyway. The output is an array that contains dots or zeros according to box k. The solution that I thought I was taking my first block of the matrix 3 ^ n then the first matrix 3 ^ n-1 (the first of the 9 sub-matrices) and then on it recursively call their 9 sub-matrices and so on ... but I have difficulty in writing the code.
for example, if I choose n = 2 and k = 4, the output is the following matrix:

*********
*.**.**.*
*********
***...***
*.*...*.*
***...***
*********
*.**.**.*
*********

dots must be below each asterisk but because of the character they are not!

I'm sorry! I forgot to say, but the point is equal to 0 instead of the asterisk is equal to 1!


in my first post there are all the details!