Aufgabe mit Strings

[WinterMensch]

Ich habe ein Problem bezüglich folgender Aufgabe:

Also, man soll eine Zahl eingeben können, z.B. n=4. Danach soll ein Muster ausgegeben werden.
Jede Zeile soll 3^n Zeichen enthalten.
In der ersten Zeile soll die Anzahl der Zeichen durch 3 geteilt werden und der erste Abschnitt mit "." gefüllt werden, der zweite mit "*" und der dritte wieder mit "." .
In der zweiten Zeile sollen die zuvor mit "." gefüllten Abschnitte wieder in drei Teile geteilt werden, und wieder je ein Drittel mit ".", dann "*" und dann "." gefüllt werden. Die Abschnitte die mit "*" gefüllt waren sollen einfach durch "." ersetzt werden.
Das ganze soll dann n mal gemacht werden, also soll es n Zeilen geben.

Das was ich bis jetzt habe, berechnet die Anzahl der Zeichen pro Zeile und gibt die erste Zeile aus.
Die weiteren Zeilen sind aber problematisch..
Ich glaube, das ganze rekursiv zu lösen wäre vielleicht am sinnvollsten.
Vielleicht hat ja jemand eine Idee wie es weiter gehen könnte.
Vielen Dank schonmal im Voraus

class Test {
    public static void main(String[] args) {
        int b = In.readInt();
        double x = Math.pow(3,b);
        String value = new String();
        Out.println(ersteZeile(value, x));
        
    }
    
    
    static String ersteZeile(String value, double x) {
        double p = x / 3;
        while (value.length() < p) {
            value += ".";
        }
        double s = 2 * p;
        while (value.length() < s) {
            value += "*";
        }
        while (value.length() < x) {
            value += ".";
        }
        return value;
        
    }
  
}

 

[DrZoidberg]

Ich hab hier mal ne rekursive Methode geschrieben. Aber ich vermute, dass sie nicht ganz der Aufgabenstellung entspricht, da nicht alle "." in der nächsten Zeile berücksichtigt werden.

static String muster(int l, int n) {
    int l1 = l/3;
    int l2 = l - 2*l1;
    StringBuilder sb = new StringBuilder();
    if(n == 0) {
        for(int i = 0; i < l1; i++) sb.append(".");
        for(int i = 0; i < l2; i++) sb.append("*");
        for(int i = 0; i < l1; i++) sb.append(".");
    } else {
        sb.append(muster(l1, n-1));
        for(int i = 0; i < l2; i++) sb.append(".");
        sb.append(muster(l1, n-1));
    }
    return sb.toString();
}

static void printMuster(int n) {
    for(int i = 0; i < n; i++) {
        System.out.println(muster((int)Math.pow(3, n), i));
    }
}

 

[Pentalon]

Meinst Du sowas ?

    static void muster(int zahl) {
    	double m = Math.pow(3, zahl);

    	double teil = m / 3;
    	
    	while(teil >= 1) {
    		for(double i=0;i<m;i++) {
    			if(((int)(i / teil) & 1) == 0) {
    				System.out.print(".");
    			} else
    				System.out.print("*");
    		}    
    		System.out.println();
    		teil = teil / 3;
    	}
    }

Eingabe 4

Ausgabe:
[TIPP]...........................***************************...........................
.........*********.........*********.........*********.........*********.........
...***...***...***...***...***...***...***...***...***...***...***...***...***...
.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.[/TIPP]

Pentalon

 

[WinterMensch]

Im Prinzip ja, aber ab der zweiten Zeile soll unter jedem "*" ein "." Stehen.

 

[Pentalon]

Also so:

    static void muster(int zahl) {
    	double m = Math.pow(3, zahl);

    	double teil = m / 3;
    	char[] zeichen = {'.','*','.'};
    	int x=0;
    	
    	while(teil >= 1) {
    		for(x=0;x<2;x++) {
    			for(double i=0;i<m;i++) {
    				if(((int)(i / teil) & 1) == 0) {
    					System.out.print(zeichen[x]);
    				} else
    					System.out.print(zeichen[x+1]);
    			}
    			System.out.println();
    		}    
    		if(x==2)
    			teil = teil / 3;
    	}
    }

Jetzt kommt bei 3 sowas raus:
[TIPP].........*********.........
*********.........*********
...***...***...***...***...
***...***...***...***...***
.*.*.*.*.*.*.*.*.*.*.*.*.*.
*.*.*.*.*.*.*.*.*.*.*.*.*.*[/TIPP]

Sieht aus wie ein Teppichmuster

Pentalon

 

[Pentalon]

Hier noch eine Variante, bei der Du wählen kannst, wie oft sich die Zeilen abwechseln sollen:

public class Test7 
{
 
    public static void main(String[] args) 
    {
	      Scanner scan = new Scanner(System.in);

	      System.out.println("Zahl für n: ");
	      int a = scan.nextInt();
	      System.out.println("Wie oft sollen die Zeilen abgewechselt werden (max 5): ");
	      int b = scan.nextInt();
	      scan.close();	
	      muster(a,b);
	      
    }
    
    static void muster(int zahl,int toggle) {
    	double m = Math.pow(3, zahl);

    	double teil = m / 3;
    	char[] zeichen = {'.','*','.','*','.','*'};
    	int x=0;
    	
    	while(teil >= 1) {
    		for(x=0;x<toggle;x++) {
    			for(double i=0;i<m;i++) {
    				if(((int)(i / teil) & 1) == 0) {
    					System.out.print(zeichen[x]);
    				} else
    					System.out.print(zeichen[x+1]);
    			}
    			System.out.println();
    		}    
    		if(x==toggle)
    			teil = teil / 3;
    	}
    }    
}

Pentalon

 

[WinterMensch]

Ich glaube das ist immer noch nicht das gesuchte.. Tut mir voll Leid, vielleicht wäre es klarer gewesen wenn ich mal eine Ausgabe angegeben hätte.
Also hier ist eine:

k = 4

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

 

[AmunRa]

Mit war gerade fad da hab ich das hier mal geschrieben. ICh glaub es sollte deine Anforderung erfüllen

Output für 4

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

import java.util.ArrayList;
import java.util.List;

class test2 {
	public static void main(String[] args) {

		int count = 4;
		int lineLength = (int) Math.pow(3, count);
		String[] parts = makeNewParts(lineLength);
		

		while (count > 0) {
			printLine(parts);
			List<String> partList = new ArrayList<String>();
			for (String part : parts) {
				String[] newParts = splitPart(part);
				for (String newPart : newParts)
					partList.add(newPart);
			}
			parts = partList.toArray(new String[0] );
			count --;
		}
	}

	public static String[] splitPart(String part) {
		switch (part.charAt(0)) {
		case '*':
			return new String[] { translateStarsToPoint(part) };
		case ',':
			return new String[] { part };
		case '.':
			return makeNewParts(part.length());
		default:
			return new String[0];
		}
	}

	public static String[] makeNewParts(int length) {
		String parts[] = new String[3];
		int p = length / 3;

		for (int i = 0; i < 3; i++) {
			StringBuilder part = new StringBuilder(p);
			for (int j = 0; j < p; j++) {
				switch (i) {
				case 0:
				case 2:
					part.append('.');
					break;
				case 1:
					part.append('*');
					break;
				}
			}
			parts[i] = part.toString();
		}

		return parts;
	}

	public static String translateStarsToPoint(String stars) {
		return stars.replace('*', ',');
	}

	public static void printLine(String[] parts) {
		for (String part : parts) {
			System.out.print(part.replace(',', '.'));
		}

		System.out.println();
	}
}

 

[Pentalon]

So wie ich Deiner Anleitung entnehme, sollen die Bereiche die mit "." gefüllt sind, in 3 Teile unterteilt werden.
Das müsste bei 3 dann eigendlich so aussehen:

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

Sterne werden ja in der nächsten Zeile zu Punkten, die dann in der nächsten Zeile wieder in 3 Teile unterteilt werden müssten.

Hier etwas deutlicher:

.........|*********|.........
...|***|...|...|...|...|...|***|...
.*.|...|.*.|.*.|.*.|.*.|.*.|...|.*.

Pentalon

 

[WinterMensch]

Ja, genau so war das gemeint

 

[Pentalon]

Dann ist aber Deine Zeichnung auch nicht korrekt:

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

und es müsste eigendlich so sein:

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

Zur besseren Übersicht:

...|***|...|...|...|...|...|***|...|...|***|...|...|***|...|...|***|...|...|***|...|...|...|...|...|***|...
.*.|...|.*.|.*.|.*.|.*.|.*.|...|.*.|.*.|...|.*.|.*.|...|.*.|.*.|...|.*.|.*.|...|.*.|.*.|.*.|.*.|.*.|...|.*.

Pentalon

 

[WinterMensch]

Naja, das war das Beispiel aus der Aufgabe, also mit n = 4.
Aber ich denke es ist so, dass das was mal ein Sternchen war und dann zum Punkt wurde, auch immer ein Punkt bleiben soll, was irgendwie ziemlich kompliziert ist..
Kann man das irgendwie umsetzen?

 

[Pentalon]

Das hat AmunRa oben gemacht, soweit ich gelesen habe.

Pentalon

 

[WinterMensch]

Ja, das funktioniert auch

Aber mich würde interessieren ob das auch rekursiv funktioniert?

 

[DrZoidberg]

Der Code, den ich gestern gepostet hatte erzeugt doch genau das Muster, das du willst und er ist rekursiv.

 

[Bleiglanz]

gemeint ist doch sicher die

Cantor-Menge ? Wikipedia

so dass der jeweils mittlere Abschnitt für immer unverändert bleibt? Irgenwie komisch, dass die * aus der ersten Zeile in der zweiten Zeile zu . werden sollen, stimmt das wirklich? Oder gehört dazu nicht eine 0. Zeile die komplett aus . besteht?

 

[WinterMensch]

Soweit ich weiß ähnelt das der Cantor-Menge ja, aber es soll keine 0. Zeile geben

 

[WinterMensch]

Oh, stimmt, das ist genau das was ich gesucht hatte
Habe es mir leider nicht gleich genau angeguckt weil du ja geschrieben hattest, dass es vermutlich nicht ganz der Aufgabenstellung entspricht. Aber tut es ja doch. Vielen Dank