mit for schleifen expermentieren

[moh]

Schreiben Sie in Python und C ein Programm, welches mittels zweier Schleifen folgende Ausgabe erzeugt:
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
Ich habe vorkurzem programmiern an zulernen.
ich hab diese Frage aber weiß nicht, weder das Anfang noch das Ende der for_schleife.
Danke an allen !

[sparrow]

Ich würde im Tutorial der Dokumentation nachschlagen.

[Sirius3]

@moh: ich würde sagen, die for-Schleife startet mit einer 1 und endet mit einer 1.
Die Forderung, dass es exakt zwei for-Schleifen sein müssen, läßt befürchten, dass Du kein Python schreiben sollst, sondern C in Python-Syntax.

Was hast Du schon über for-Schleifen gelernt und wie wendet man sie an?

[moh]

nicht viel, bin noch anfänger.
Die Grundlagen .
for schleifer wird genutzt um anwisung zu wiedaholen.
Leider dein Vorschlag mit 1,1 hat nicht funktoniert.
mit diesem code habe ich ähnliche Ergebnise bekommen aber Klar die ausgabe Form ganz anders aussieht
for i in range(1,4):
for j in range (1,5):
print(i,j)

[__blackjack__]

@moh: Welcher Vorschlag hat nicht funktioniert? Was hast Du denn aufgrund des Vorschlags an Code geschrieben?

[moh]

wenn die for_schleife mit eins beginnt und dann bei 1 aufhört was soll mein programm ausgeben?
for m in range(1,1):
print(m)

[__blackjack__]

@moh: So geht das natürlich nicht. `range()` liefert ja nur aufsteigende Zahlen, Du brauchst aber Zahlen die bei 1 beginnen, bis 5 aufsteigen, dann wieder absteigen und mit 1 enden. Da gibt es in Python mehrere Möglichkeiten sich das zu basteln. Im Grunde mehr als in C, weil ich mir das in Python wahrscheinlich aus entsprechenden Teilen zusammensetzen würde, während in C eher nur das berechnen dieser Zahlenfolge aus einer Folge von nur aufsteigenden Zahlen in Frage kommt.

[moh]

@moh: So geht das natürlich nicht. `range()` liefert ja nur aufsteigende Zahlen, Du brauchst aber Zahlen die bei 1 beginnen, bis 5 aufsteigen, dann wieder absteigen und mit 1 enden. Da gibt es in Python mehrere Möglichkeiten sich das zu basteln. Im Grunde mehr als in C, weil ich mir das in Python wahrscheinlich aus entsprechenden Teilen zusammensetzen würde, während in C eher nur das berechnen dieser Zahlenfolge aus einer Folge von nur aufsteigenden Zahlen in Frage kommt.

es ist zu viel für mich, ich kenne noch keine andere möglichkeiten.
kannst so ein code als bsp schreiben

[__blackjack__]

@moh: Ich würde an Deiner Stelle eher in Richtung C denken, also erst das Problem in C lösen und die Lösung dann nach Python portieren. Dann braucht man das grundsätzlich nur einmal zu lösen.

[sls]

Puh, keine Ahnung wie man sowas *schön* in C umsetzt, da ich C gerade eh irgendwie lernen möchte mal ein Ansatz:

Code: Alles auswählen

#include <stdio.h>

int main()
{
    int c = 5;

    for (int a=1; a<10; a++)
    {
        for (int b=1; b<6; b++)
        {
            if (b == c)
            {
                printf("%d", b);
                c--;
                break;
            }
            
            printf("%d", b);

            if (a == b)
            {
                break;
            }
        }
        printf("\n");
    }
}

[__blackjack__]

@sls: Die ``break``\s in der inneren Schleife sind halt irgendwie nicht schön. Die Aufgabe ist hier sozusagen aus `a` zu berechnen wie weit die innere Schleife laufen muss. Also die literale 6 ist da nicht gut. Ebenfalls die literale 10. Denn `c` und die 10 und die 6 hängen ja alle voneinander ab, sprich wenn Du `c` am Anfang ändern würdest, müsstest Du die 10 und die 6 auch ändern und zwar relativ zum Startwert von `c` – das lässt sich dann ja ausrechnen.

Wenn das C sein soll, dann fehlt das ``void`` in der Signatur um anzuzeigen, dass die `main()`-Funktion keine Argumente bekommt. So wie es da jetzt steht ist das C++, allerdings würde man dann idiomatischerweise Streams verwenden und nicht `printf()`. Und selbst dann wäre der korrekte Include dafür ``#include <cstdio>``.

[sls]

@__blackjack__:

ich habe das return 0; vergessen, der Compiler hat nicht gemeckert. Jetzt habe ich mich zumindest mal mit dem Thema auseinander gesetzt. Das mit den Literalen stimmt natürlich, ich überlege mir dann mal wie ich die Logik am besten umkehren kann, damit ich kein break mehr brauche.

Code: Alles auswählen

#include <stdio.h>

int main(void)
{
    int a = 10;
    int b = a / 2;

    for (int c=1; c<a; c++)
    {
        for (int d=1; d<b+1; d++)
        {
            if (d == b)
            {
                printf("%d", d);
                b--;
                break;
            }

            printf("%d", d);

            if (c == d)
            {
                break;
            }
        }
        printf("\n");
    }
}

[Sirius3]

Ohne exzessives Pointer-Gefummel ist es kein C:

Code: Alles auswählen

#include <stdio.h>

int main(void) {
    char *fmt = "%d %d %d %d %d\n";
    int k;
    for(k=0;k<9;k++) {
        printf(fmt + (k<5?4-k:k-4)*3, 1, 2, 3, 4, 5);
    }
    return 0;
}

[__blackjack__]

@Sirius3: Schöne Lösung aber nur die halbe Punktzahl weil nur die halbe Anzahl geforderter ``for``-Schleifen verbaut wurden.

Wobei das Folgen haben kann wenn die Anzahl der Argumente nicht mit der Anzahl der Platzhalter im ersten Argument übereinstimmt. Je nach Compiler/Platform kann da Datenmüll auf dem Stack liegen bleiben und das ``return`` dann ins Nirwana springen/das Programm zum Absturz bringen.

[kbr]

Komme leider auch nur auf die halbe Punktzahl ...

Code: Alles auswählen

l = []
for p in range(1, 10):
    l.append(p) if p < 6 else l.pop()
    print(' '.join(map(str, l)))

[ThomasL]

Schreiben Sie in Python (....) ein Programm, welches mittels zweier Schleifen folgende Ausgabe erzeugt:
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1

just for fun ...

Code: Alles auswählen

for i in [1,2,3,4,5,6,5,4,3,2,1]:
    for j in range(1, i):
        print(f'{j} ', end='')
    print()

[nezzcarth]

Komme leider auch nur auf die halbe Punktzahl ...

Immerhin; mir bleiben alle Punkte verwehrt, weil die Schleifen ganz fehlen (dabei habe ich das damals mal so mit Pascal in der Schule gelernt, blöd) ...

Code: Alles auswählen

In [1]: def pyramid(x=1, treshold=5): 
   ...:     print(*range(1, x+1)) 
   ...:     if x >= treshold: 
   ...:         return 
   ...:     else: 
   ...:         pyramid(x+1, treshold) 
   ...:     print(*range(1, x+1)) 
   ...:                                                                                  

In [2]: pyramid()                                                                        
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1

[snafu]

@nezzcarth: Originelle Idee. Es lässt sich noch etwas verkürzen:

Code: Alles auswählen

def pyramid(n, limit):
    print(*range(1, n + 1))
    if n < limit:
        pyramid(n + 1, limit)
        print(*range(1, n + 1))

if __name__ == '__main__':
    pyramid(1, 5)

[snafu]

Oder bei Benutzung von itertools:

Code: Alles auswählen

from itertools import chain

def pyramid(n):
    for i in chain(range(1, n + 1), reversed(range(1, n))):
        print(*range(1, i + 1))

if __name__ == '__main__':
    pyramid(5)

[nezzcarth]

Es lässt sich noch etwas verkürzen:

Stimmt Wobei am naheliegendsten natürlich dc wäre; geht sogar als "One-Liner":

Code: Alles auswählen

$ dc -e '0si5sx[li1+ddsj0sklbx[ ]pStsilx>a]sa[lk1+ddskn[ ]nlj>b]sb[li1-ddsj0sklbx[ ]pStsi1<c]sclaxlxsilcx' 
1  
1 2  
1 2 3  
1 2 3 4  
1 2 3 4 5  
1 2 3 4  
1 2 3  
1 2  
1