Seite 1 von 2
Kurze Pause
Verfasst: Montag 8. Juni 2026, 10:59
von Kebap
Früher hab ich am C64 im Supermarkt immer aus Spaß einen kurzen Zweizeiler programmiert, der dann da lustige Labyrinthe auf die Bildschirme zauberte.
Wenn ich das in Python probiere, scrollt das viel zu schnell durch. Wie kann ich eine kurze Pause in die Schleife einbauen? Möglichst Hardware-agnostisch?
Also die erste Idee wäre einfach eine sinnlose Schleife hochzählen lassen, aber deren Dauer ist ja vorher gar nicht so einfach zu bemessen.
Code: Alles auswählen
import random
while True:
print(random.choice("/\\"), end="")
Re: Kurze Pause
Verfasst: Montag 8. Juni 2026, 11:10
von Kebap
Ah, ich gebe mir einfach mal selbst die Antwort: Es gibt dafür time.sleep()
Code: Alles auswählen
import random
from time import sleep
while True:
print(random.choice("/\\"), end="")
sleep(0.05)
OK, jetzt pausiert aber die komplette Ausgabe. Sprich, man sieht das Labyrinth erst nach Keyboard Interrupt und nicht sofort Zeichen für Zeichen aufbauen.
Warum? Wie kann ich das heilen?
Nächste Frage: Wieso kann ich Befehle nicht mehr in eine Zeile quetschen? Früher ging das doch mit Doppelpunkt? Jetzt funken Annotationen dazwischen.
Code: Alles auswählen
while True: print(random.choice("/\\"), end="") : sleep(0.05)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
SyntaxError: illegal target for annotation
Re: Kurze Pause
Verfasst: Montag 8. Juni 2026, 12:05
von noisefloor
Hallo,
zum letzten Punkt: der 2. Doppelpunkt im Einzeiler ist syntaktisch falsch bzw. da kommt der Fehler her. Schon immer, dass kann so auch früher nicht funktioniert haben. Da muss wenn ein ; hin.
Gruß, noisefloor
Re: Kurze Pause
Verfasst: Montag 8. Juni 2026, 12:14
von imonbln
Du musst statt des zweiten Doppelpunkts ein Semikolon verwenden. Zudem kennt print den Parameter flush, mit dem du dafür sorgst, dass stdout sofort dargestellt wird.
Code: Alles auswählen
while True: print(random.choice("/\\"), end='',flush=True); time.sleep(0.05)
Re: Kurze Pause
Verfasst: Montag 8. Juni 2026, 12:53
von Kebap
Ihr habt Recht. Der Doppelpunkt stammt wohl noch aus BASIC.
Danke auch für den Hinweis auf Flush.
Re: Kurze Pause
Verfasst: Montag 8. Juni 2026, 15:11
von __blackjack__
@Kebap: Das Programm was Du wahrscheinlich meinst ist dieser Klassiker, zu dem es auch ein Buch gibt, das _das_ als Titel hat:
Und / und \ sind da nur ein schlechter Ersatz für die Grafikzeichen im PETSCII-Zeichensatz. Das kann man heute ziemlich Originalgetreu mit Unicode-Zeichen nachstellen. Die beiden diagonalen Linien liegen als Codepoint nämlich auch genau nebeneinander, so dass man den gleichen ”Trick” im Code verwenden kann mit 9585 statt mit 205:
Code: Alles auswählen
import random, time
while True: print(chr(int(9585.5 + random.random())), end="", flush=True); time.sleep(0.02)
Re: Kurze Pause
Verfasst: Dienstag 9. Juni 2026, 08:56
von Kebap
Boah, danke, diese Zeichen sind VIEL besser!
Vorher:
Code: Alles auswählen
\\\//\\\\\/\\\/\\//////\/\//\\/\/\\//\/\\//\\\\\\/\////\/////\\//\\//\\\//\\/\/
\\\//////\////\\\\/\////\\//\\/\/\\\/\\\///\/\/\////\///\\\\//\\\/\//\/\\////\\
//\\/\\//\\//\/\/\\/\/\\\\/\//\//\\/\\\/\//\\\\/\\/\\//\///\////\//\/\//\\\/\//
\/\/\\\\\//\///\\\\\///\//\//\/\\\///\///\\/\\\\//\\\////\\\\\/\\\\\//\//\//\\/
/\//////\\\///\///////\/\\/\//\\//\/\\\\/////\/\\/\\\/\//\//\/\\/\\//\\//\\//\/
Dank __blackjack__ nun:
Code: Alles auswählen
╲╱╲╲╱╱╱╲╱╲╲╲╲╲╲╱╱╲╲╱╱╲╱╱╲╲╱╱╲╲╲╱╱╲╱╱╲╲╱╱╱╱╲╲╱╱╱╲╱╲╱╲╱╲╲╲╱╲╲╱╱╲╱╲╲╲╱╲╱╲╱╲╲╱╲╱╲╲╲
╱╲╱╲╲╲╲╲╲╲╱╲╲╱╱╱╱╱╲╱╱╲╲╱╲╱╱╲╲╲╱╱╲╱╲╲╱╱╱╲╱╱╱╲╲╱╱╱╲╲╱╱╲╲╱╱╲╱╱╲╱╱╲╲╱╱╲╲╲╱╲╲╲╲╱╱╲╱╲
╲╲╲╲╱╲╱╱╲╲╱╲╲╲╱╲╱╱╲╲╱╱╲╱╱╱╲╱╲╱╱╲╱╲╲╱╲╲╲╲╲╱╱╲╲╲╲╱╲╱╱╲╱╱╲╱╲╱╱╲╱╱╱╲╲╱╱╱╲╲╱╲╱╱╱╱╱╲╲
╱╲╲╱╲╲╲╱╱╲╲╱╲╲╲╲╱╲╱╱╱╲╱╲╲╱╱╱╱╱╱╲╱╲╱╱╱╱╲╱╱╱╲╲╲╱╱╱╲╲╱╲╲╱╲╲╲╲╲╱╱╲╲╲╱╲╲╱╱╲╱╲╱╲╲╱╲╲╲
╲╱╲╲╲╱╲╱╱╱╱╱╲╱╱╱╱╱╲╲╱╲╲╲╱╲╲╱╲╲╱╱╲╱╲╱╱╲╲╱╲╲╱╱╱╱╲╲╲╲╲╲╲╱╱╲╲╱╱╱╲╱╲╱╱╲╱╲╱╱╱╱╱╱╱╲╱╱╱
Danke auch für den Hinweis auf das Buch, das ich sicherlich bisher nicht kannte, aber auch sehr gut aussieht:
https://direct.mit.edu/books/oa-monograph/5343/10-PRINT-CHR-205-5-RND-1-GOTO-10
Dank Creative Commons kann man sich dort direkt eine PDF Version ziehen und selbst drin blättern.
Ich war dem Trugschluss aufgesessen, ich hätte mir das ganz allein ausgedacht. Vielleicht irgendwo aufgeschnappt. Spannend!
Und nein, ich hatte das damals nicht mit CHR und Kommazahlen gelöst, sondern mit den ausgeschriebenen Zeichen, die ja auf Tastendruck vorlagen.
Re: Kurze Pause
Verfasst: Dienstag 9. Juni 2026, 12:45
von __blackjack__
Das mit CHR$ und der Kommazahl steht im Handbuch vom C64. Dort als Dreizeiler — vor der Ausgabe von den beiden Zeichen wird noch der Bildschirm geleert:
Code: Alles auswählen
10 PRINT "{CLR}"
20 PRINT CHR$(205.5 + RND(1));
30 GOTO 20
{CLR} steht für die CLR/HOME-Taste. Wird auf dem C64 als reverses Herz dargestellt.
Eine Variante die nicht darauf angewiesen wäre, dass die beiden Zeichen in PETSCII direkt aufeinander folgen:
Code: Alles auswählen
10 A$(0)="╱":A$(1)="╲"
20 PRINT A$(2*RND(1));
30 GOTO 20
Die beiden Grafikzeichen gibt man auf dem C64 mit Shift+N und Shift+M ein.
Ich habe es mal ganz grob mit der Stoppuhr ermittelt: Der C64 gibt beim Originalprogramm so ca. 64 Zeichen pro Sekunde aus. Also ein ``time.sleep(0.015625)`` zwischen den Zeichen.
Re: Kurze Pause
Verfasst: Dienstag 9. Juni 2026, 19:38
von nezzcarth
Hatte mich der Einleitung jetzt irgendwie auf "echte" Labyrinthe in C64-Basic gefreut, was ja auch eine schöne Programmieraufgabe mit ganz
verschiedenen Ansätzen ist. Wüsste allerdings auch nicht, wie das mit den Zeichen gehen soll und in zwei Zeilen eh nicht. Schickes ASCII-Art ist es natürlich trotzdem
Re: Kurze Pause
Verfasst: Mittwoch 10. Juni 2026, 06:09
von DeaD_EyE
Der Code von den Ansätzen sieht aus wie Lua. Damit hab ich letztens einen Dobot MG400 programmiert. Kann ich aber nicht empfehlen, wenn man den Roboter im Lehrbetrieb nutzen will (offline programmieren und testen nicht möglich).
Re: Kurze Pause
Verfasst: Mittwoch 10. Juni 2026, 12:45
von __blackjack__
@DeaD_Eye: Der Code ist in Ruby geschrieben.
Ich frage mich jetzt gerade ob bei den Ansätzen auch der dabei ist, der in David Ahl's „101 BASIC Computer Games“ von 1974 abgedruckt ist:
https://archive.org/details/101basiccom ... 6/mode/1up
Re: Kurze Pause
Verfasst: Mittwoch 10. Juni 2026, 15:41
von Pedroski55
Früher hab ich am C64 im Supermarkt immer aus Spaß einen kurzen Zweizeiler programmiert, der dann da lustige Labyrinthe auf die Bildschirme zauberte.
Ehemaliger Supermarktterrorist also!
Die gnädigen Herren (ich merke keine Damen hier anwesend) sollten es besser wissen als jemanden, der auch noch neu in der Welt der Schlange ist, dazu zu ermuntern, endlose while-Schleifen anzufangen! Ihr gehört, und seid hiermit, getadelt!
Code: Alles auswählen
from random import choice
from time import sleep
# kann beliebig variert werden 20, 60 ergibt ein schönes Rechteck.
def art(hoch, breit):
for i in range(hoch):
print( ''.join([choice("|_/\\¯") for j in range(breit)]))
sleep(0.05)
Art for art's sake, money for God's sake
Re: Kurze Pause
Verfasst: Mittwoch 10. Juni 2026, 19:19
von nezzcarth
@__blackjack__: Ich habe den Algorithmus nicht durchgearbeitet (wie wird man bei diesen vielen Sprüngen heutzutage nicht wahsinnig?
), jedoch sehe ich in der Beispielausgabe in dem Scan abgetrennte Bereiche, z. B. unten Links und unten mittig. Diese würde in einem regulären Labyrinth, das mit einem der gängigen Algorithmen generiert wurde, eher nicht vorkommen. Insofern ist es zumindest keine "korrekte" Implementierung eines "Standard-Algorithmus".
@DeaD_EyE: Ich kann wenig Negatives für lua sagen. Manche Sachen sind ungewohnt, aber ich programmiere da ganz gerne drin.
Re: Kurze Pause
Verfasst: Donnerstag 11. Juni 2026, 12:29
von DeaD_EyE
__blackjack__ hat geschrieben: Mittwoch 10. Juni 2026, 12:45
@DeaD_Eye: Der Code ist in Ruby geschrieben.
Oh. Sieht aber aus 1 m Entfernung gleich aus.
Re: Kurze Pause
Verfasst: Freitag 12. Juni 2026, 11:31
von Kebap
Kebap hat geschrieben: Dienstag 9. Juni 2026, 08:56
Ich hatte das damals nicht mit CHR und Kommazahlen gelöst, sondern mit den ausgeschriebenen Zeichen, die ja auf Tastendruck vorlagen.
Während ich versuche, das zu rekonstruieren, ist mir aufgefallen, dass c64 Basic gar keinen ELSE Zweig kennt. Also mal überlegen, wie ich das wohl schaffte.
Re: Kurze Pause
Verfasst: Freitag 12. Juni 2026, 12:16
von Dennis89
@kebap Du kannst sowas schreiben:
Code: Alles auswählen
10 REM If condition is ture, go to line 200
20 IF x > 1 THEN 200;
30 REM That is the else-part
40 ...
Grüße
Dennis
Re: Kurze Pause
Verfasst: Freitag 12. Juni 2026, 13:27
von __blackjack__
@Kebap: Wenn man in strukturiertem BASIC ”denkt”, also so etwas wie
Code: Alles auswählen
IF C THEN
REM THEN PART
ELSE
REM ELSE PART
END IF
REM AFTER END IF
Dann ist das generisch in klassichem BASIC so etwas:
Code: Alles auswählen
10 IF C THEN 40
20 REM ELSE PART
30 GOTO 50
40 REM THEN PART
50 REM AFTER END IF
Die beiden Zweige können hier auch beliebig lang sein. Im Grunde ist das so wie man das auch in Assembler strukturieren würde.
Falls der THEN-Zweig nur sehr kurz ist, und hinter das THEN in die Zeile passt, kann man das kürzen auf:
Code: Alles auswählen
10 IF C THEN {THEN PART}:GOTO 30
20 REM ELSE PART
30 REM AFTER END IF
Der ELSE-Zweig kann hier beliebig lang sein. Eventuell kann es also auch sinnvoll sein, die Bedingung zu negieren wenn man einen kurzen ELSE- aber langen THEN-Zweig hat.
Und wenn dabei am Ende verkettete Sprünge auftreten, kann man die natürlich ”rückwärts ersetzen”, also wenn man ein ``GOTO {end if}`` hat, was direkt zu einem ``GOTO {endlosschleife}`` führt, kann man das erste auch gleich durch ``GOTO {endlosschleife}`` ersetzen.
Aber einfacher ist es die beiden Zeichen einfach in ein Array zu stecken oder in eine Zeichenkette und dann über den zufällig ausgewürfelten Index zu wählen. Mit dem Array hatte ich das ja schon gezeigt. Wenn die Zeichencodes nicht zusammenhängend sind, wie beispielsweise bei der Erweiterung von Pedroski55, dann ist das die naheliegende Lösung. Hier mit Zeichenkette und MID$():
Code: Alles auswählen
10 A$="│▁╱╲▔":N=LEN(A$)
20 PRINT MID$(A$,RND(1)*N+1,1);
30 GOTO 20
@nezzcarth: Diese Umsetzung von strukturierter Programmierung in klassisches BASIC muss man einfach nur rückwärts denken um mit den ganzen GOTOs klar zu kommen. Früher notfalls auf Papier. Heute schreibe ich das dann eher in QBasic, also in strukturiertes BASIC um. Erster Schritt alle Zeilennummern entfernen, die nicht Ziel von Sprüngen sind, denn die braucht man ja letztendlich gar nicht. Und dann nach und nach IF/ELSE-GOTOs durch IF/ELSE/END IF ersetzen und Schleifen-GOTOs durch DO…LOOP, und alles hübsch einrücken. Bei Übriggebliebenen GOTOs und bei GOSUBs die Zeilennummern durch sprechende Labels ersetzen, und Variablennamen sprechender machen, und schon ist das meiste viel besser verständlich.
Wirklich hässlich sind Programme bei denen das nicht so einfach geht, weil FOR…NEXT nicht paarweise auftreten oder Schleifen nicht sauber ineinander verschachtelt sind.
Re: Kurze Pause
Verfasst: Samstag 13. Juni 2026, 19:14
von nezzcarth
@__blackjack__: Ja, so ungefähr habe ich es dann auch gemacht (bzw. angefangen; der Code ist mit wenigen Änderungen mit FreeBasic lauffähig). Mir ist dann auch aufgefallen, dass es von dem Code (mindestens) zwei Versionen gibt. Neben der von dir verlinkten von 1974 noch eine spätere von 1978, die man z.B. hier findet:
https://www.atariarchives.org/basicgame ... php?page=3. Die frühere Version ist m.M.n. "falsch" oder tut zumindest bei mir nicht, was in der Beschreibung steht: Es werden ggf. auf dem selben Grid mehrere getrennte Labyrinthe erzeugt, es gibt die schon angesprochenen abgetrennten Bereiche ohne "Labyrinth-Struktur" und es gibt auch Labyrinthe mit mehreren Ausgängen. Die spätere Version hat all das nicht. Der Quelltext der beiden Versionen ist relativ gleich, aber es gibt ein paar Unterschiede bei den IF-Bedingungen und da dürften die Fehler her kommt. Soweit ich es sagen kann (s. a. diese Python-Implementierung
https://github.com/coding-horror/basic- ... amazing.py), funktioniert der Algorithmus im Prinzip so, dass ausgehend von einem zufälligen Startpunkt in der ersten Zeile ein Random Walk durchgeführt wird, bis entweder alle Zellen besucht worden sind oder es keine freien Nachbarn mehr gibt. In dem Fall geht der Algorithmus auf die Suche, erst zeilenweise von Links nach Rechts nach unten, dann zu 0,0 nach einer bereits besuchten Zelle mit unbesuchtem Nachbarn. Meiner Meinung nach könnte man daher sagen, dass der Algorithmus eine Abwandlung von
"Hunt and Kill" ist (letzte Position statt oben Links und besuchte statt unbesuchte Zellen), gemischt mit
"Growing Tree", was m.M.n. aber eher ein abstrakte Oberkategorie/Implementierungsstrategie ist.
Re: Kurze Pause
Verfasst: Dienstag 16. Juni 2026, 15:43
von __blackjack__
@Pedroski55: Die ”Terroristen” waren eher Leute, die so etwas wie die „Kaufhausdemos“ in den Rechner geladen haben.
Video:
https://www.youtube.com/watch?v=bYp6op6duzc
Das und ähnliche in der CSDb:
https://csdb.dk/search/?seinsel=all&sea ... fhaus+demo
Was ist an der Endlosschleife zu tadeln? Das da endlos Variationen erzeugt werden, gehört zum Programm, das soll so. Das ist auch beeidruckender anzusehen als einfach nur ein Labyrinth das statisch auf dem Bildschirm angezeigt wird.
``10 GOTO /dev/null`` ist ein Syntaxfehler und macht semantisch auch gar keinen Sinn.
Auch hier machen die entsprechenden Unicode-Zeichen mehr Sinn als ASCII-Zeichen:
Und hier die Ausgabe vom BASIC-Programm mit den entsprechenden Zeichen auf einem C64:
Re: Kurze Pause
Verfasst: Mittwoch 24. Juni 2026, 12:40
von __blackjack__
@Kebap: Konntest Du das mittlerweile rekonstruieren, was Du damals im Laden in den Rechner getippt hast?
Ich hätte noch zwei Varianten im Angebot. Eine mit ON … GOTO, also quasi die Sprungtabelle in BASIC, und die IF … ”ELSE” Variante:
Code: Alles auswählen
10 ON RND(1)+1.5 GOTO 20,30
20 PRINT"╱";:GOTO 10
30 PRINT"╲";:GOTO 10
Oder
Code: Alles auswählen
10 IF RND(1)<.5 THEN PRINT"╱";:GOTO 10
20 PRINT"╲";:GOTO 10
Falls im Laden ein Atari 8-Bit-Rechner steht, braucht man wie in Python ein explizites INT() und die magische Zahl ist 6.5 und nicht 205.5:
Die Lösungen, die nicht den numerischen Zeichencode verwenden, gehen da natürlich auch. Die beiden Zeichen sind beim Atari mit CTRL und F oder G erreichbar.