Bildschirmausgabe erzeugen

[JavaIsTheBest]

Hallo,
ich bin schon länger am überlegen, wie ich diese Aufgabe lösen kann.
Es soll folgende Bildschirmausgabe erzeugt werden. Der Haken dabei?
Man sollte nur eine Schleife benutzen. Mit zwei Schleifen habe ich es geschafft.


#
**
###
****
#####
******

 

[Thallius]

Naja ich schaffe das sogar ohne eine Schleife

 

[Baldur]

Da ich ja nicht gleich alles vorgeben will, versuch ich mal ein paar dezente Hinweise zu geben

Du hast eine Schleife, die die Werte von 1 bis 6 durchläuft. Pro Durchlauf wird die entsprechende Anzahl Zeichen ausgegeben.
Gerade Zeilen geben Sternchen aus, ungerade die Raute.

Um das ganze in einer Schleife zu schaffen, stell dir das ganze als eine Sequenz von Zeichen vor:
"*<Zeilenumbruch>##<Zeilenumbruch>***<Zeilenumbruch>...."

Hoffe das hilft weiter

 

[JavaIsTheBest]

Ich weiß, da fehlt noch Code aber so richtig weiter komme ich nicht.

public class Test {
   
    public static void main(String[] args){
       
        for(int i=0;i<6;i++){
            if(i%2==1) System.out.print("#");
            else System.out.print("*");
        }
       
    }

}

 

[Xyz1]

Ich hab das hinbekommen, aber nur mit zwei zusätzlichen Hilfsvariablen, unschön:

    /**
     * Print:
     *   #
     *   **
     *   ###
     *   ****
     *   #####
     *   ******
     *   #
     *
     * @param args
     */
    public static void main(String[] args) {
        int j = 1;
        int k = 1;
        for (int i = 0; i < 22; i++) {
            if ( /* geheim */ ) {
                k++;
                j += k;
                System.out.println("");
            }
            if ( /* geheim */ ) {
                System.out.print("*");
            } else {
                System.out.print("#");
            }
        }
    }

ich bitte um eine Verbesserung, Hilfsvariablen umgehen, von euch.

 

[Meniskusschaden]

Zum Beispiel so (hat aber auch Hilfsvariablen):

public static void main(String[] args) {
        String s1 = "";
        String s2 = "";
        for (int i = 0; i < 6; i++) {
            s1 += "#";
            s2 += "*";
            System.out.println((i%2==0)?s1:s2);
        }
    }

 

[Xyz1]

Pro Durchlauf wird die entsprechende Anzahl Zeichen ausgegeben.

Da liegt das Problem, straightforward dürfen aber nicht auf einmal mehrere Zeichen ausgegeben werden.

 

[Baldur]

Da liegt das Problem, straightforward dürfen aber nicht auf einmal mehrere Zeichen ausgegeben werden.

Stimmt, den Teil hätte ich weglassen sollen, der verwirrt nur

Ganz ohne Hilfsvariablen gehts natürlich nicht. Mein Ansatz hat zwei int-Variablen, zwei if-Abfragen und keine for-Schleife.

Die Aufgabe ist wahrscheinlich ein bisschen realitätsfremd, aber eine ganz nette Bastelaufgabe zum "Um die Ecke denken". Und es gibt auf jeden Fall mehrere richtige Lösungen.

 

[Xyz1]

Ich hab gerade geguckt, ob die Fibonacci-Zahlen weiterhelfen, aber nööö, ich denke nicht...
1
3
6
10
15
21 ...
(kein IQ-Test) sieht denn irgendwer ein Muster?

@Baldur: Ja, eigentlich sollten wir ihr die aufgaben auch gar nicht lösen, deshalb hab ich meine bescheidene Lösung auch die wichtigen Stellen weggelassen. Aber es ist eine Bastelaufgabe, wie sie in Unis gestellt wird.

 

[JavaIsTheBest]

Ich hab das hinbekommen, aber nur mit zwei zusätzlichen Hilfsvariablen, unschön:

    /**
     * Print:
     *   #
     *   **
     *   ###
     *   ****
     *   #####
     *   ******
     *   #
     *
     * @param args
     */
    public static void main(String[] args) {
        int j = 1;
        int k = 1;
        for (int i = 0; i < 22; i++) {
            if ( /* geheim */ ) {
                k++;
                j += k;
                System.out.println("");
            }
            if ( /* geheim */ ) {
                System.out.print("*");
            } else {
                System.out.print("#");
            }
        }
    }

ich bitte um eine Verbesserung, Hilfsvariablen umgehen, von euch.

Könntest du bitte deine Lösung näher erklären?

 

[Blender3D]

Eine Schleife, ein Zeichen ? Vielleicht so?

    public static void printOneLoop(int max ) {      
        int currentmax = 1;
        int cnt = 0;
        int id = 0;
        char out[] = { '#', '*' };
        while (currentmax <= max) {
            System.out.print(out[id]);
            cnt++;
            if (cnt == currentmax) {
                System.out.println();
                cnt = 0;
                currentmax++;
                id = (id + 1) % out.length;
            }
        }
    }

Zeichen lassen sich beliebig erweitern und auch das Maximum ist flexibel.

 

[Meniskusschaden]

Ich hab gerade geguckt, ob die Fibonacci-Zahlen weiterhelfen, aber nööö, ich denke nicht...
1
3
6
10
15
21 ...
(kein IQ-Test) sieht denn irgendwer ein Muster?

Das sind eigentlich nicht die Fibonacci-Zahlen (0, 1, 1, 2, 3, 5, 8, ...) sondern die Summen der ersten natürlichen Zahlen.

 

[Baldur]

Das sind eigentlich nicht die Fibonacci-Zahlen (0, 1, 1, 2, 3, 5, 8, ...) sondern die Summen der ersten natürlichen Zahlen.

Oder auch die Indizes an denen in dem Beispiel ein Zeilenumbruch erfolgt

 

[Xyz1]

Ich hab eine PN geschickt, läuft ja auch nix im Fernsehen zZt.
Gibt es eine Formel für die Berechnung eines Folgeelements der Summe der ersten natürlichen Zahlen?
Edit: Mei Frage hat sich gerade erübrigt,
dann lässt sich vielleicht 1 - 2 Variablen einsparen.
Gauß hat es ja schon als kleines Kind entdeckt.

 

[Baldur]

Hm, da wär ich auch glatt mal neugierig, wie deine aktuelle Lösung ausschaut
Meine ist eigentlich gar nicht so unähnlich zu deiner ersten, nur mit einem Zähler weniger.

 

[Meniskusschaden]

Man könnte vielleicht zu Beginn mittels Gauß die Anzahl der Schleifendurchläufe ermitteln. Dann könnte man die Gleichung umformen um bei jeder Iteration aus dem Schleifenzähler direkt berechnen zu können, ob ein Zeilenwechsel nötig ist, der ja auch gleichbedeutend mit einem Zeichenwechsel ist.

 

[Xyz1]

@Baldur: Gerne,

    /**
     * @author DerWissende on 03/17/2016
     */
    public static void main(String[] args) {
        int j = 1;
        for (int i = 0; i < 100; i++) {
            if ( /* think, and insert Gauß Summenformel here */ ) {
                j++;
                System.out.println("");
            }
            if (j % 2 == 0) {
                System.out.print("*");
            } else {
                System.out.print("#");
            }
        }
    }

habn wir jetzt für diese Aufgabe viel zu viel geschrieben?

 

[Blender3D]

Gauß hat es ja schon als kleines Kind entdeckt.

sum(n) = (n*(n+1))/2

 

[Baldur]

Ich muss gestehn, an Gauss hätt ich bei der Aufgabe jetzt nicht gedacht
Von der Effizienz her sind ist dann die Variante mit den Zählern dann aber doch um ein paar Instruktionen günstiger.

Dann geb ich meine Variante auch mal zum Besten:

int zeile = 1;
int zeichen = 1;

while(zeile <= 6) {
   boolean gerade = zeile%2 == 0;
   System.out.print(gerade ? '#' : '*');
   ++zeichen;

   if (/* ??? */) {
      System.out.print('\n');
      // ???
      // ???
   }
}

 

[Blender3D]

    public static void printOneLoop(int max, char[] out) {
        int currentmax = 1;
        int cnt = 0;
        int id = 0;      
        while (currentmax <= max) {
            System.out.print( cnt == currentmax ? '\n' : out[id]);
            cnt++;
            if ( cnt == currentmax+1) {              
                cnt = 0;
                if (out[id] != '\n')
                    currentmax++;
                id = (id + 1) % out.length;
            }
        }
    }

..
OneLoopOutput.printOneLoop(7, new char[]{ '#','*' });
..

Erfüllt folgende Bedingungen:
1 Schleife, pro Loop 1 System.out.print(char )

 

[Meniskusschaden]

Ich habe auch noch eine Gauss-Version:

public static void main(String[] args) {
    gibMitGaussAus(6);
}

private static void gibMitGaussAus(int n) {
    boolean raute = true;
    for (int i = 1; i <= n/2f*(n+1); i++) {
        System.out.print(raute?'#':'*');
        if ( (-1f/2+Math.sqrt(1f/4+2*i)) % 1 == 0 ) {
            System.out.println();
            raute = !raute;
        };  
    }
}

Aktuell geht es ja gerade nicht mehr um gute Lesbarkeit, oder?

 

[Baldur]

gehts jetzt schon um die Teilnahme am Obfuscated C Contest? Dann hätt ich auch noch eins

for(int l=1,c=1; l<=6; ++c) {
    if (c > l) {
        c-=++l;
        putchar('\n');
    }
    else {
        putchar(l&1 ? '#' : '*');
    }
}

Diesmal auch mit nur einer Ausgabe pro Iteration.
(Wer lieber Java will, ersetzt einfach putchar durch System.out)

 

[Baldur]

Ok, es geht noch eine Stufe widerlicher und wirklich nur mit einer einzigen Ausgabe.. don't try this at home

for(int l=1,c=0; l<=6;) putchar(++c>l&&!(c-=++l)?'\n':l&1?'#':'*');

 

[kneitzel]

Die Lösung ist getestet? Kann ich gerade leider nicht testen, aber beim lesen stolpere ich über l & 1. Das ist ja das bitweise und, d.h. das Ergebnist ist auch wieder eine zahl. Und ? : Erwartet doch ein boolean so dass ich ein l&1==1 erwartet hätte.
Wo hab ich den Denkfehler?

Aber generell lassen sich zwei Schleifen immer durch eine ersetzen.
Man könnte Regeln zum Übersetzen aufsetzen:
for (start; bedingung; aktion) {inhalt;}
wird zu
{start; while(bedingung) {inhalt;aktion;}}

while (bed1){
aktion1;
while (bed2){
aktion2;
}
aktion3;
}

kann zu folgendem gemacht werden:

boolean inInnerLoop=false;
while(bed1) {
// move definition of local variabels of outer loop here!
if (!inInnerLoop) { aktion1; }
if (bed2) { inInnerLoop=true; aktion2; } else { inInnerLoop=false;}
if (!inInnerLoop) { aktion3; }
}

So eine Regel lässt sich universell einsetzen. Das Ergebnis ist erst einmal nicht schön, aber man hat etwas, das man dann umschreiben könnte.

 

[Baldur]

Die Lösung ist getestet? Kann ich gerade leider nicht testen, aber beim lesen stolpere ich über l & 1. Das ist ja das bitweise und, d.h. das Ergebnist ist auch wieder eine zahl. Und ? : Erwartet doch ein boolean so dass ich ein l&1==1 erwartet hätte.

Ja, die ist getestet Ich hab das ganze für den zusätzlichen Spaßfaktor in C geschrieben, da können ints auch implizit als logischer Ausdruck interpretiert werden. Bei Java brauchst du natürlich das "== 1" dazu und musst ggf noch zusätzliche Klammern setzen. Das war eh ein kleines Mikado-Spiel auszuprobieren welche Klammern wirklich unbedingt nötig waren

 

[Xyz1]

Ok, Lesbarkeit (2.) ist das eine, Geschwindigkeit (2.) das andere, und dann gibt's noch Basteln & Kreativität & Intelligenz (3.). Mit 1 und 2 hat das nicht mehr viel zu tun. Deswegen gibt es ja zwei geschachtelte Schleifen, ohne Spaghetti (4.). Aber intelligent (3) ist es.
In C wird innerhalb einer Bedingung alles, was != 0 ist, als true/TRUE angesehen. Hardcore/üblicherweise wird so das Ende einer Zeichenkette herausgefunden.
Ich hatte ein int 'quasi" wie ein boolean benutzt, damit es wenigstens noch etwas lesbar erscheint.

 

[Baldur]

Die Lesbarkeit ist bei meinem Einzeiler natürlich fürn Arsch, aber in Produktiv-Code hat sowas auch nichts zu suchen

Aber von der Geschwindigkiet müsste der Einzeiler eigentlich gleichauf sein mit meiner ursprünglichen Variante. Zumindest wenn der Compiler erkennt, daß der Ausdruck rechts von dem && immer wahr ist.

 

[Xyz1]

Also das ist ja "eben" die Essenz dessen, was ich sagen wollte.

Falls irgendwann mal die Anforderung gestellt werden sollte, so eine Ausgabe wird benötigt... äh... dann nimmt man doch besser zwei ineinander geschachtelte Schleifen -> schnell, übersichtlich, lesbar.

Edit: Oben muss bei Lesbarkeit eine (1.) hin.

 

[Baldur]

Hab das gestern auch schon in einem anderen Thema hier geschrieben. Solche "Optimierungs" Kunststücke zu schreiben hat eigentlich so gut wie immer nur Nachteile. Es wird in jedem Fall weniger lesbar/verständlich und am Ende macht der Compiler eh die effektiveren Optimierungen

Wenn wir mal alle unsere Varianten kompilieren und den Bytecode vergleichen, kommt wahrscheins am Ende raus, daß der Kompiler in jedem einzelnen Fall ein "loop unrolling" durchführt und durch ein einzelnes System.out ersetzt

 

[Xyz1]

Ich kann dir nicht genau sagen, was der Kompiler da macht, bin ja kein Komp.Bauer.
Außerdem ist der Kompiler von Java nicht gerade unkompliziert, und die Optimierungen zur Laufzeit auch nicht...
Außerdem will ich gar nicht Bytecode vergleichen oder die Operationen "ermitteln". Ist doch gar nicht in der aufgabenstellung gefragt.
Außerdem sollten wir eigentlich nicht diese aufgabe für sie lösen, aber ich hab damit angefangen...

 

[Baldur]

Ich fürchte sie ist schon bei dem ersten Codebeispiel ausgestiegen :I

Zum Thema Optimierungen reicht es eigentlich zu wissen, daß der Compiler meist eh schlauer als der Programmierer ist, was das angeht Zumindest wenn es darum geht, Rechenoperationen oder konstante Ausdrücke zu kürzen. Als Programmierer sollte man sich gar nicht fragen, ob eine zusätzliche Variable für Zwischenergebnisse Sinn macht oder nicht, und im Zweifelsfall einfach den leserlicheren Code schreiben.
Spannender sind an der Stelle eher Shader, wo man wirklich wissen sollte, wie die GPU arbeitet