Sie sind nicht angemeldet.

Lieber Besucher, herzlich willkommen bei: GEOS-InfoBase-Forum. Falls dies Ihr erster Besuch auf dieser Seite ist, lesen Sie sich bitte die Hilfe durch. Dort wird Ihnen die Bedienung dieser Seite näher erläutert. Darüber hinaus sollten Sie sich registrieren, um alle Funktionen dieser Seite nutzen zu können. Benutzen Sie das Registrierungsformular, um sich zu registrieren oder informieren Sie sich ausführlich über den Registrierungsvorgang. Falls Sie sich bereits zu einem früheren Zeitpunkt registriert haben, können Sie sich hier anmelden.

1

Dienstag, 4. September 2012, 21:50

Ein Dummie experimentiert mit R-Basic

============================================================
Hallo Leute

das bin ich: ?(

also ein brutalst möglicher Dummie in Programmieren und daher auch R-Basic...
============================================================


! Ich will zwei Variablen jeweilige Wörter zuweisen und die
! Variablen, also die dazugehörigen Wörter anzeigen lassen.
! Alles was mir einfällt ist sowas:

LET A$="Hallo"
LET B$="Welt"
PRINT A$,B$

! Den in vielen Basic Dialekten nicht benötigten Befehl LET
! fand ich auch in R-Basic nicht.

! A$="Hallo"
! B$="Welt"
! Print A$,B$

! Lasse ich LET weg, funktioniert es aber auch nicht.

! Ich finde mit dem R-Basic Code Wizard einen DIM Befehl

! DIM A$="Hallo"
! DIM B$="Welt"
! PRINT A$, B$

! Funktioniert so nicht

DIM Hallo, A$
DIM Welt, B$
PRINT A$, B$

! Obiger Versuch lässt R-Basic einfrieren. Immerhin hat R-Basic compiliert ;-)



?(

Euer Dummie

Dieser Beitrag wurde bereits 8 mal editiert, zuletzt von »alexzop« (4. September 2012, 21:53)


2

Dienstag, 4. September 2012, 22:14

RE: Ein Dummie experimentiert mit R-Basic

============================================================
Hallo Leute

das bin ich: ?(

also ein brutalst möglicher Dummie in Programmieren und daher auch R-Basic...
============================================================


! Ich gebe nicht auf und schaue mir eines der
! Variablenbeispiele von Rainer an.
! Ich denke nach und tippe dieses:

DIM A$
DIM B$
A$="Hallo"
B$="Welt"
Print A$, B$

! Komisch, wieder compiliert R-Basic friert dann aber ein.
! Ich bemerke, dass ich R-Basic falsch gestartet hatte. Ich
! habe nicht extra "klassisches Basic" angeklickt. Ich
! markiere den Code und kopiere ihn. Starte R-Basic für
! klassisches Basic und füge den Code ein.

! Der vorletzte Versuch erzeugt nun immerhin ein leeres
! Basic Fenster.

! Der letzte Versuch klappt!

! Das Hallo Welt steht zwar recht weit auseinander,
! aber Juhuuu!

:]

Euer Dummie

Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von »alexzop« (4. September 2012, 22:19)


3

Dienstag, 4. September 2012, 22:48

RE: Ein Dummie experimentiert mit R-Basic

============================================================
Hallo Leute

das bin ich: ?(

also ein brutalst möglicher Dummie in Programmieren und daher auch R-Basic...
============================================================


REM Ich erinnere mich an die FOR TO NEXT Schleifen im Homecomputer Basic
REM Ich glaube das sah so aus:

10 FOR A=1 TO 100
20 PRINT A
30 Next A

REM Und weil R-Basic keine Zeilennummern benoetigt...

FOR A=1 TO 100
PRINT A
Next A

REM Tja, das funktioniert in R-Basic so nicht...

?(

Euer Dummie

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »alexzop« (4. September 2012, 22:52)


4

Dienstag, 4. September 2012, 22:51

RE: Ein Dummie experimentiert mit R-Basic

============================================================
Hallo Leute

das bin ich: ?(

also ein brutalst möglicher Dummie in Programmieren und daher auch R-Basic...
============================================================


REM Ich gebe nicht auf...
REM Im For-Next Demo 1 von Rainer entdecke ich wieder
REM den DIM Befehl. Ich überlege und versuche es selbst...

DIM A
For A=1 TO 100
Print A
Next A

REM Juhuu! Jetzt funktioniert es und rattert genauso runter,
REM wie ich es mir vorgestellt hatte.

:]

Euer Dummie

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »alexzop« (4. September 2012, 22:51)


5

Dienstag, 4. September 2012, 22:56

Na bitte, geht doch :-)

Bernd

6

Dienstag, 4. September 2012, 23:05

RE: Ein Dummie experimentiert mit R-Basic

============================================================
Hallo Leute

das bin ich: ?(

also ein brutalst möglicher Dummie in Programmieren und daher auch R-Basic...
============================================================


REM In einem alten Basic Lehrbuch finde ich ein Beispiel
REM fuer verschachtelte For...Next Schleifen.
REM Das Buch sagt, wichtig sei, dass die innere Schleife
REM kleiner ist, als die Aeussere.
REM Der DIM Befehl kommt im Buch nicht vor.
REM Ich setze den DIM Befehl selbstaendig:

DIM X
DIM Y
FOR X=1 TO 100
FOR Y=1 TO 10
PRINT Y;" ";
NEXT Y
Print X
Next X

REM Ich hatte keine Ahnung was dabei rauskommt, aber
REM Juhuu, es klappt.

:]

Euer Dummie

7

Mittwoch, 5. September 2012, 00:06

RE: Ein Dummie experimentiert mit R-Basic

============================================================
Hallo Leute

das bin ich: ?(

also ein brutalst möglicher Dummie in Programmieren und daher auch R-Basic...
============================================================


REM In einem alten Basic Lehrbuch finde ich folgende Casinosimulation
REM als praktisches Beispiel der FOR...NEXT Schleifen
REM Das PRG soll einen Casinogang simulieren.
REM Es soll simuliert werden, wie oft rot oder schwarz
REM auf dem Rouletteller erscheint:

! 500 REM CASINOSIMULATION
! 510 REM WIE OFT KOMMT ROT UND SCHWARZ
! 520 Print "WUERFE","ROT","SCHWARZ"
! 530 FOR I=100 TO 1000 STEP 100
! 540 LET R=0
! 550 LET S=0
! 560 FOR J=1 TO I
! 570 LET A=INT(10*RND(1))
! 580 LET X=5*A
! 590 LET Y=X/2
! 600 LET W=INT(Y)
! 610 IF W=Y THEN 640
! 620 LET R=R+1
! 630 GOTO 650
! 640 LET S=S+1
! 650 NEXT J
! 660 PRINT I,R,S
! 670 NEXT I
! 680 END

REM Tja, ich bin recht erschlagen. Es kommen einige Befehle vor,
REM die R-Basic nicht kennt...

REM Ich versuche zumindest einer Loesung vielleicht naeher zu kommen:

! DIM I
! DIM R
! DIM S
! DIM J
! DIM A
! DIM X
! DIM Y
! DIM W
! FOR I=100 TO 1000 STEP 100
! R=0
! S=0
! FOR J=1 TO I
! A=INT(10*RND(1))
! X=5*A
! Y=X/2
! W=INT(Y)
! IF W=Y THEN S=S+1
REM Tja in obiger Zeile hatte ich keine Ahnung wie ich in R-Basic
REM einen Sprung im Code umsetze. Ich denke, in R-Basic ist so
REM ein Spagettiecode nicht moeglich. Muesste ich
REM Unterprogramme schreiben bzw. OBJECTe definieren?
! R=R+1
! NEXT J
! PRINT I,R,S
! Next I
! End

REM AEhem... R-Basic meint: "Achtung es gibt Compilerwarnungen".
REM Es oeffnet sich aber ein Basic Fenster indem Zahlen erscheinen.
REM Aber ob das die gewuenschte Casinosimulation ist?
REM Eher nicht.

REM Ich glaube, ich muss mich mal um Unterprogramme kuemmern...

DECL SUB unter1 (P AS Real)
DECL SUB unter2 (U AS REAL)

SUB unter1 (P AS REAL)
DIM S
S=S+1
NEXT J
PRINT I,R,S
Next I
END SUB

SUB unter2 (U AS REAL)
DIM R
R=R+1
NEXT J
PRINT I,R,S
Next I
End SUB

DIM I
DIM J
DIM A
DIM X
DIM Y
DIM W
FOR I=100 TO 1000 STEP 100
R=0
S=0
FOR J=1 TO I
A=INT(10*RND(1))
X=5*A
Y=X/2
W=INT(Y)
IF W=Y THEN unter1
unter2
End

REM Irgendwie bin ich voll im Wald. Es hagelt Compilermeldungen. Sooo geht das sicher nicht.
REM Im Grunde habe ich auch gar keine Ahnung was zu tun ist.
REM Wie rufe ich denn Unterprogramme auf? Irgendwie mit den
REM von mir gesetzten Unterprogrammvariablen P und U?


?(

Euer Dummie

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »alexzop« (5. September 2012, 01:33)


8

Mittwoch, 5. September 2012, 00:43

RE: Ein Dummie experimentiert mit R-Basic

============================================================
Hallo Leute

das bin ich: ?(

also ein brutalst möglicher Dummie in Programmieren und daher auch R-Basic...
============================================================


REM Ich gebe nicht auf und experimentiere an den Unterprogrammen.
REM Rainers Beispiele fuer Unterprogramme
REM helfen mir selbst nachzudenken:

!DIM I
!DIM J
!DIM A
!DIM X
!DIM Y
!DIM W
!DIM S
!DIM R

!DECL SUB unter1 ()
!DECL SUB unter2 ()

!SUB unter1 ()
!S=S+1
!END SUB

!SUB unter2 ()
!R=R+1
!End SUB

!Print "WUERFE","ROT","SCHWARZ"
!FOR I=100 TO 1000 STEP 100
!R=0
!S=0
!FOR J=1 TO I
!A=INT(10*RND(1))
!X=5*A
!Y=X/2
!W=INT(Y)
!IF W=Y THEN unter1
!unter2
!NEXT J
!PRINT I,R,S
!Next I
!End

REM R-Basic meldet Compilerwarnungen...
REM Ein Basic Fenster wirft Zahlen aus.
REM Das selbe wie ganz am Anfang? Keine Ahnung...
REM Ich gaube, dass ich unter2 anders aufrufen muss...
REM Ob da eine WHILE...WEND Schleife hilft???
REM Oder einfach IF W ungleich Y THEN unter2 ???
REM Ich denke <> bedeutet Ungleich, also ein durchgestrichenes =

DIM I
DIM J
DIM A
DIM X
DIM Y
DIM W
DIM S
DIM R

DECL SUB unter1 ()
DECL SUB unter2 ()

SUB unter1 ()
S=S+1
END SUB

SUB unter2 ()
R=R+1
End SUB

Print "WUERFE","ROT","SCHWARZ"
FOR I=100 TO 1000 STEP 100
R=0
S=0
FOR J=1 TO I
A=INT(10*RND(1))
X=5*A
Y=X/2
W=INT(Y)
IF W=Y THEN unter1
IF W<>Y THEN unter2
NEXT J
PRINT I,R,S
Next I
End

REM Ich habe keine Ahnung ob mein PRG nun macht, was ich will.
REM R-Basic meldet Compilerwarnungen, aber es startet
REM und zeigt Zahlen an...
REM Immerhin...

:O

Euer Dummie

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »alexzop« (5. September 2012, 00:44)


9

Mittwoch, 5. September 2012, 13:17

Hallo Alex,

ich habe deine Ausführungen mit einem breiten Schmunzeln gelesen. Wirklich sehr schön geschrieben ;-)

Aber zur Sache. Eigentlich gibt es nur ganz wenige Dinge, die ich dir noch auf den Weg geben muss:

1. LET ist schon seit 30 Jahren veraltet. R-BASIC kennt es auch nicht. Einfach weglassen.

2. Alle Varibalen müssen in R-BASIC vor Verwendung per DIM "deklariert" werden. Statt
DIM I
DIM J
DIM A
DIM X
DIM Y
DIM W
DIM S
DIM R
kannst du auch einfacher
DIM I, J, A, X, Y, W, S, R
schreiben.

3. Compilerwarnungen musst du ernst nehmen. Statt
RND(9) musst du z.B. 9*RND() schreiben. Das liegt an der KC-Kompatibilität. Evt ändere ich das noch einmal und lasse RND(9) zu.

4. Die R-BASIC Onlinehilfe (Menü Hilfe, thematische Übersicht) ist ganz gut. Dort sind die Befehe ausführlich erklärt.


Das mit dem Einfrieren (ganz am Anfang) ist ein Bug, den ich noch ausmerzen sollte.

Gruß
Rainer

P.S. Bei konkreten Fragen kannst du mir auch ne PM schreiben. Und: es gibt keine dummen Fragen.
Es gibt 10 Arten von Menschen - die einen wissen was binär ist, die anderen nicht.

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »Rainer« (5. September 2012, 13:19)


10

Mittwoch, 5. September 2012, 20:21

RE: Ein Dummie experimentiert mit R-Basic

============================================================
Hallo Leute

das bin ich: ?(

also ein brutalst möglicher Dummie in Programmieren und daher auch R-Basic...
============================================================


REM Danke Rainer, fuer Deine Info.
REM Ich versuche es nun so:

DIM A,I,J,R,S,W,X,Y

DECL SUB unter1 ()
DECL SUB unter2 ()

SUB unter1 ()
S=S+1
END SUB

SUB unter2 ()
R=R+1
End SUB

Print "WUERFE","ROT","SCHWARZ"
FOR I=100 TO 1000 STEP 100
R=0
S=0
FOR J=1 TO I
A=INT(10*(1*RND()))
X=5*A
Y=X/2
W=INT(Y)
IF W=Y THEN unter1
IF W<>Y THEN unter2
NEXT J
PRINT I,R,S
Next I
End

REM A=INT(10*1*RND()) oder A=INT(10*(1*RND())) ????
REM Auch mein Gefuehl sagt, dass in der zweiten Idee die Klammerverschachtelung richtig ist.
REM Es gibt keine Compilerwarnungen mehr!
REM Ob meine R-Basic Umsetzung das selbe macht, wie das Original Listing, ist mir
REM weiter nicht klar. Ich gebe mich aber dennoch mit dem Erreichten zufrieden.


:]

Euer Dummie

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »alexzop« (5. September 2012, 20:23)


11

Mittwoch, 5. September 2012, 21:22

Habe dein letztes Beispiel mal ausprobiert, es funktioniert. Prima gemacht, Alex.

Ich habe den Code in das Unterprogramm "Arbeit" der aktuellen Version des MiniTool-Templates kopiert und deine beiden Unterprogramme wieder rückgängig gemacht. Dann auf den Start-Button geklickt und es lief.





Bernd

12

Donnerstag, 6. September 2012, 12:08

Super! ;-)
Es gibt 10 Arten von Menschen - die einen wissen was binär ist, die anderen nicht.

13

Donnerstag, 6. September 2012, 20:02

RE: Ein Dummie experimentiert mit R-Basic

============================================================
Hallo Leute

das bin ich: ?(

also ein brutalst möglicher Dummie in Programmieren und daher auch R-Basic...
============================================================


! Arrgh. Ich hatte mich selbst in den "Wald" geführt.
! Bernd zeigt mir, dass ich gar keine Unterprogramme
! gebraucht hätte. Eigentlich war ich da ja schon nah
! dran, habe es aber wohl nicht logisch zuende gedacht.
! Der ursprüngliche Programmierer
! benötigte die GOTO Befehle wohl wegen dem benötigten
! LET Befehl, oder weil er nicht schreiben konnte
! IF ... THEN LET ...
! Oder sein Compiler kannte "Ungleich" nicht.
! (Hey, dann habe ich das PRG ja sogar leicht verbessert, ähem)

! Immerhin hatte ich wohl Rainers Hinweis Klammermässig
! richtig umgesetzt.

---------

REM Aha! Ich hatte mir soeben die Hilfe zu Rate gezogen
REM R-Basic laesst ja doch "Spaghetti-Code" mit GOTO fuer
REM Unverbesserliche zu! Da haette ich mir die modernen Muehen
REM um modernen Code zu schreiben auch sparen koennen:

REM CASINOSIMULATION
REM WIE OFT KOMMT ROT UND SCHWARZ
DIM A,I,J,R,S,W,X,Y
Print "WUERFE","ROT","SCHWARZ"
FOR I=100 TO 1000 STEP 100
R=0
S=0
FOR J=1 TO I
A=INT(10*(1*RND()))
X=5*A
Y=X/2
W=INT(Y)
IF W=Y THEN GOTO LABEL1
R=R+1
GOTO LABEL2
LABEL LABEL1
S=S+1
LABEL LABEL2
NEXT J
PRINT I,R,S
NEXT I
END

! So haette ich es mir wohl am einfachsten machen koennen
! R-Basic "Kompatibilitaetsmodus" zu Uralt Basicdialekten macht es moeglich


:tongue:

Euer Dummie

Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von »alexzop« (6. September 2012, 22:38)


14

Donnerstag, 6. September 2012, 21:54

RE: Ein Dummie experimentiert mit R-Basic

============================================================
Hallo Leute

das bin ich: ?(

also ein brutalst möglicher Dummie in Programmieren und daher auch R-Basic...
============================================================


! Diesmal versuche ich mich am INPUT Befehl
! Ich nehme einfach Mathe

!DIM R,F,Y,A,B,X,Z,O,P,L
!!PI=3.14159
!INPUT Y
!R=SQR(Y)/PI
!Print "RADIUS=";R
!INPUT A,B
!F=A*B
!Print "FLAECHE=",F
!INPUT X,Y,Z,O,P
!L=X*Y*Z*O*P
!Print "ERGEBNIS=";L
!End

! Zuerst habe ich begriffen, das R-Basic PI selbststaendig kennt.
! Wenn nicht haette ich fuer PI wohl auch eine Variable per DIM
! vereinbaren muessen.
! Ich hoffe die BASIC-Funktion SQR() liefert die Quadratwurzel der als Argument angegebenen Zahl zurück.
! Nun muss ich erkennen, das mein INPUT Befehl nicht klappt
! Ich moechte eigentlich mehrere Eingaben in einer Zeile zulassen
! und dachte, ich muesse die einzelnen Variablen nur durch Komma
! trennen... tztz

!DIM R,F,Y,A,B,X,Z,O,P,L
!INPUT Y
!R=SQR(Y)/PI
!Print "RADIUS=";R
!INPUT A
!Input B
!F=A*B
!Print "FLAECHE=",F
!INPUT X
!Input Y
!Input Z
!Input O
!Input P
! L=X*Y*Z*O*P
!Print "ERGEBNIS=";L
!End

! So klappt es, aber der INPUT Code lasst sich sicher verkuerzen.
! Aha, der Programmierer scheibt in der Hilfe, es "ist zu empfehlen,
! immer nur eine Variable anzufordern". Weiter Unten steht zwar auch
! was vom Komma als Trennzeichen bei Anforderung mehrerer Variablen,
! aber bei mir hat es damit nicht funktioniert.
! Besteht da noch UpDate Bedarf oder liegt es an mir Dummie?

! Nebenbei faellt mir auf, dass sich der Hilfebildschirm immer
! im Vordergrund aufdraengt und das EDIT Fenster belagert.
! Ich habe keinen Breitbildmonitor.

! Zum Spass teste ich nun die InputBox...

DIM R,F,Y,A,B,X,Z,O,P,L
INPUTBox "Hau ne Zahl rein:"; Y
R=SQR(Y)/PI
Print "RADIUS=";R
INPUTBox "Hau die erste Zahl rein:"; A
InputBox "Hau die zweite Zahl rein:"; B
F=A*B
Print "DIE FLAECHE BETRAEGT=",F
INPUTBox "Box die erste Zahl durch:"; X
InputBox "Drueck die Zweite nach:"; Y
InputBox "Klatsch die Dritte drauf:"; Z
InputBox "Schieb ne Vierte drunter:"; O
InputBox "Schlag mich mit ner fünften Zahl k.O.:"; P
L=X*Y*Z*O*P
Print "Deine Punktzahl:";L
End

! Hey das klappt ja mit den Boxen. Ob meine Berechnungen
! überhaupt stimmen, kann ich aber beim besten Willen
! nicht versprechen...



:]

Euer Dummie

Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von »alexzop« (6. September 2012, 23:20)


15

Donnerstag, 6. September 2012, 23:51

RE: Ein Dummie experimentiert mit R-Basic

============================================================
Hallo Leute

das bin ich: ?(

also ein brutalst möglicher Dummie in Programmieren und daher auch R-Basic...
============================================================


!Ich versuche ein kleines Zahlenraten durch binaeres Suchen.
!Der Spieler merkt sich eine Zahl zwischen 1 und 100.
!Der Computer versucht sie zu "erraten" indem er
! das Intervall jeweils halbiert bis das Intervall
! nur noch aus einer Zahl besteht. Dann hat der Computer
! die Zahl des Spielers gefunden

DIM J1,J2,N,A$
Print "PC/GEOS KANN DEINE ZAHL ERRATEN":Print
J1=0:J2=100
LABEL L1
N=INT((J1+J2)/2)
PRINT "Ist Deine Zahl ";N;" ?"
LABEL L2
Print "Deine Antwort: 1 FUER ZU GROSS"
Print " 2 FUER ZU KLEIN"
Print " 3 FUER RICHTIG"
INPUT A$
IF A$="1" THEN J2=N:GOTO L3
IF A$="2" THEN J1=N:GOTO L3
IF A$="3" THEN END
GOTO L2
LABEL L3
IF ABS(J1-J2)<>2 THEN GOTO L1
Print "Deine Zahl ist ";INT((J1+J2)/2)
End

! Als Unverbesserlicher Dummie habe ich nun mit "Spaghetticode"-GOTO
! und Sprungmarken gearbeitet. Immerhin habe ich ja auf Zeilenummern
! verzichtet.

! Ob ich es auch mit Unterprogrammen SUB und damit ohne
! GOTO schaffe? Oder bietet R-Basic auch Abfragen wie
! IF THEN ELSE END ?


?(

Euer Dummie

Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von »alexzop« (7. September 2012, 00:00)


16

Freitag, 7. September 2012, 00:42

RE: Ein Dummie experimentiert mit R-Basic

============================================================
Hallo Leute

das bin ich: ?(

also ein brutalst möglicher Dummie in Programmieren und daher auch R-Basic...
============================================================


! Ich versuche es mal mit einem eindimensionalen Feld (Vektor)
! Das Feld soll 20 Zellen haben und der Inhalt der Zellen
! soll angezeigt werden koennen, wenn man diese zuvor gefuellt hat
! (Das Fuellen muss im Code erfolgen, ich bin ja kein Profiprogrammierer)

!REM DUMMIE ARRAY
!DIM I
!DIM NAM(20)
!FOR I=1 TO 20
!Print "NAM(";I;")=";NAM(I)
!REM Die Zellen leer lassen:
!NAM(I)=I
!REM Oder man kann z.B. Zelle 4 z.B. mit dem Wert 6 ausstatten
!NAM(4)=6
!NEXT I
!End

! Mit einer Variable fuer ansteigende Inhalte in 10 Zellen sieht es z.B. so aus:

REM DUMMIE ARRAY 2
DIM I,X
DIM VEKTOR(10)
FOR I=1 TO 10
Print "VEKTOR(";I;")=";VEKTOR(I)
FOR X=1 TO 10
VEKTOR(X)=X-1
NEXT X
NEXT I
End

! Obiges Geschreibsel erzeugt ein Vektor Feld und darin 10 Zellen.
! In diese Zellen fuellt das Programm automatisch ansteigend 0 bis 10

! GeoCalc kann sowas natuerlich besser, aehem.

:]

Euer Dummie

17

Freitag, 7. September 2012, 01:04

RE: Ein Dummie experimentiert mit R-Basic

============================================================
Hallo Leute

das bin ich: ?(

also ein brutalst möglicher Dummie in Programmieren und daher auch R-Basic...
============================================================


! Mal schauen ob ich einen Wuerfel simulieren kann und ob es Sinn ergibt:

DIM W,X,D,J
DIM T(6)
LABEL L1
INPUT "Wieviele Wuerfe";W
FOR X= 1 TO W
D=INT(6*(1+RND()))+1
T(D)=T(D)+1
NEXT X
FOR X=1 TO 6
Print X;"S:";T(X)
Next X
Print
FOR J=1 TO 6
T(J)=0
NEXT J
GOTO L1
END

! Tja, Laufzeitfehler in Zeile 9. Feldinhalt ausserhalb
! des zulaessigen Bereiches.

! Keine Ahnung, was da schief laeuft...


?(

Euer Dummie

18

Freitag, 7. September 2012, 18:20

RE: Ein Dummie experimentiert mit R-Basic

============================================================
Hallo Leute

das bin ich: ?(

also ein brutalst möglicher Dummie in Programmieren und daher auch R-Basic...
============================================================


! Ok, das Obige war gestern Nacht. Da haette ich laengst
! schlafen sollen...
! Der Fehler lag in dieser Zeile:
! D=INT(6*(1+RND()))+1
! Ich hatte vegessen SHIFT zu halten um zwischen 1 und RND
! das * Zeichen zu bekommen.

! Damit die Bildschirmausgabe des Programmes verstaendlicher
! wird, habe ich die PRINT Inhalte verbessert.

! Das ganze simuliert einen Wuerfel, der Zufallszahlen zwischen
! 1 und 6 liefert. Das Programm kann aber mehr. Der Benutzer
! gibt zuerst an, wie oft gewuerfelt werden soll.
! Das Programm listet dann auf, welche Zahl wie oft gewuerfelt
! wurde. Das Programm ist lediglich eine ARRAY Spielerei und
! kann zu einem Lottoprogramm ausgebaut werden.

DIM W,X,D,J
DIM T(6)
LABEL L1
INPUT "WIE OFT SOLL ICH WUERFELN";W
FOR X= 1 TO W
D=INT(6*(1*RND()))+1
T(D)=T(D)+1
NEXT X
FOR X=1 TO 6
Print "ZAHL ";X;"SO OFT GEWORFEN:";T(X)
Next X
Print
FOR J=1 TO 6
T(J)=0
NEXT J
GOTO L1
END

! Wenn man LABEL L1 und GOTO L1 weglaesst endet das Wuerfeln
! nach der ersten Runde. Hier wird der Spieler immer wieder
! gefragt, bis er das Programm unterbricht. Eleganter waere,
! den Spieler zu fragen, ob er noch eine Wuerfelrunde simuliert
! haben moechte.


:]

Euer Dummie

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »alexzop« (7. September 2012, 18:30)


19

Samstag, 8. September 2012, 11:50

Hallo Alex,

das Würfelprogramm sieht doch schon richtig gut aus! Die folgenden Bemerkungen sind daher keine "Fehlerkorrektur" oder "Verbesserung" sondern mir sind nur zwei Stellen aufgefallen, in denen du dir evt. etwas überflüssiges merkst.

1.
D=INT(6*(1*RND()))+1
R-BASIC kennt natürlich die Rechenregeln. Deswgen kannst du auch schreiben:
D=INT(6*RND())+1

2.
FOR J=1 TO 6
T(J)=0
NEXT J
Da gibst nichst dran zu meckern. Du darfst aber auch die Varibale X "recyclen", dh. du musst nicht für jede Schlefe eine "eigene" Laufvaribale mit DIM definieren.
FOR X=1 TO 6
T(X)=0
NEXT X

Ich persönlich habe mir angewöhnt für Schleifen immer ein N zu verwenden, aber das ist natürlich Geschnmackssache.

3.
INPUT A, B, C
geht natürtlich. Du musst dann aber auch die drei Zahlen nacheinader, getrennt durch Komma, eingeben.
? 12, 78, 34

Gruß
Rainer
Es gibt 10 Arten von Menschen - die einen wissen was binär ist, die anderen nicht.

Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von »Rainer« (8. September 2012, 11:51)


Thema bewerten