Hilfe bei QB Programm ?!

[Julatsch]

Hoi, ich soll mich mal laut Arbeitgeber an ein Programm wagen, welches ich mal eben schnell erläuter:

x = 1 bis 100

wenn die Zahl x gerade ist, dann x durch 2 teilen..... x = x / 2

wenn die Zahl x ungerade ist, dann x mal 3 plus 1..... x = x*3+1

Jede neue ausgerechnete Zahl wird wieder geprüft ob gerade oder ungerade und dann wird wieder entsprechend gerechnet. Das ganze soll so lange gehn, bis jede Zahl zwischen 1 und 100 bei 1 ankommt. Die Häufigkeit der Rechnungen soll ebenfalls erfasst werden.
Zum Beispiel braucht die 97; 118 Rechenschritte um zur 1 zu gelangen.

Ich hab bis jetzt:

CLS

y = 0

For x = 1 to 100

Pruef:

IF x Mod 2 = 0 THEN
x = x / 2
ELSE
x = x * 3 + 1
END IF

y = y + 1

..... ??


GOTO Pruef:


Next x



Ich komm einfach net weiter... weiß net... vllt fehlt mir nurn Denkansatz...

 

[Loopo]

du machst eine Schleife mit x, aber veränderst x innerhalb der Schleife, das heißt x in der Schleife läuft nicht von 1 nach 100 sondern springt wild umher

in Pseudocode:

n = 0

für x = 1 bis 100
{
	y = x

	solange y ungleich 1
	{
		wenn y modulo 2 gleich 0 dann y = y / 2
		sonst y = y * 3 + 1
		n = n + 1
	}
}

n gibt jetzt die Summe ALLER Berechnungen an, wenn du die Anzahl noch einzeln für jedes x brauchst, dann musst du die Extra zB in einem Array speichern

 

[Julatsch]

jetz sieht das ganze dann so aus... nich viel geändert...


CLS
n= 0
FOR x = 1 to 100
y = x

Punkt:
While y <> 1
IF y MOD 2 = 0 THEN
y = y / 2
ELSE
y = y *3 + 1
END IF
n = n + 1
Wend
IF y <> 1 GOTO Punkt:
NEXT

Print ?


wie meinst du das mit den Arrays? hab mir das mal angeschaut... nur nich so verstanden irgendwie... -.-

 

[moagnus]

Ein Array ist praktisch die Verkettung von mehreren Variablen gleichen Datentyps zu einer Großen. Bsp.: int a, b; -> int x [2];
Das Klammerpaar ist das Kennzeichen eines Arrays und enthält bei der Initialisierung desselben die Feldgröße, also 2 in dem Fall. Die Werte der Felder hingegen werden über die Angabe eines Index' in eckigen Klammern aufgerufen, wobei zu beachten ist, dass das erste Feld den Index 0 trägt.

Und: Bist du dir sicher, dass diese Zeile stimmt?
IF y MOD 2 = 0 THEN

Ist ein = nicht eine Zuweisung oder geht das auch als Vergleichsoperator in QB?

 

[Loopo]

Arrays

 

[Julatsch]

ja doch das mit dem

y Mod 2 = 0 Then... bla

kann man so schreiben.

Also den Sinn des Array hab ich glaub ich nu begriffen.
Nur weiß ich echt nicht weiter... sprich wie verbinde ich den Array mit meinem Programm.

 

[DragonIce]

Ganz easy, ich hab das Ganze für dich mal unter VBA gemacht

Sub test()
Dim rechenschritte(100) As Integer     ' Ich bin ein Array mit 101 Plätzen (Hier wird die Anzahl der Rechenschritte eingetragen)
    [COLOR="Red"]For[/COLOR] i = 1 To 100                                ' Beginn der Schleife von 1 - 100
        y = i                                              ' y ist anfangs immer der i-Wert
        zaehl = 0                                      ' zählt die Rechenschritte
        [COLOR="Lime"]Do[/COLOR]                                                 ' Beginn einer fußgesteuerten Schleife
            If y Mod 2 = 0 Then
                y = y / 2
            Else
                y = y * 3 + 1
            End If
            zaehl = zaehl + 1                     ' Wieder ein Rechenschritt mehr
        [COLOR="Lime"]Loop[/COLOR] Until y = 1                            ' Wiederhole das Ganze solange bis "y" = 1
        rechenschritte(i) = zaehl              ' Im Array mit dem Platz der dem aktuellen i-Wert entspricht, wird die Anzahl der Rechenschritte eingetragen
    [COLOR="Red"]Next[/COLOR]
End Sub

Hoffe ich konnte dir helfen und dass das Ganze so auch unter QB ohne umschreiben funktioniert
Viel wichtiger ist aber, dass du weißt was du nun passiert. Wenn nicht, frag nach!
So schwer wars ja nun nicht

 

[Julatsch]

ah super =) dank dir

 

[Julatsch]

So xD , Programm funktioniert jetzt, allerdings soll ich jetzt die Zahlen in einer TOP10 Liste ausgeben.
Das heisst die 10 Zahlen mit den meisten Rechenschritten sollen ausgegeben werden.

Gibts da irgendwie nen Befehl für der das vereinfacht?
Ansonsten muss ich ma überlegen

 

[DragonIce]

Da gibts verschiedene Ansätze. Der einfachste wäre eine Schleife drüber laufen zu lassen die jeden einzelnen Eintrag im Array durchforstet und ein zweites Array füllt

for-Schleife 1 - 100 -- Anfang
    "e" ist eintrag "i" aus vorher erstelltem Array(rechenschritte)
    for-Schleife 10 - 1 -- Anfang
        wenn e > als Eintrag x aus Array(meiste)
            lauf so weit bis e < als eintrag x ist und tausche den rest aus + letzten eintrag rausschmeißen
    for schleife 1 - 10 -- Ende
for-Schleife 1 - 100 -- Ende

In das Array (welches bei mir den Namen "meiste" hat) musst du die Nummer eintragen, auf der die for-Schleife 1 - 100 steht!

 

[Julatsch]

Geht des auch ohne Arrays? weil hab das Programm noch mal überarbeitet und ohne Arrays hinbekommen.

 

[DragonIce]

Wie hast du es denn ohne Arrays? Musst schon damit rausrücken
Und m.E. sind Arrays einfach die sinnvollste Lösung in diesem Fall

 

[Julatsch]

Aso k ^^ also ohne Arrays hab ichs so gemacht.


CLS

For x = 1 TO 100
y = x
n = 0

While y <> 1
IF y MOD 2 = 0 Then
y = y / 2
ELSE
y = y * 3 + 1
END IF
n = n + 1
Wend
Print x, n
Next


So bekomme ich von 1 bis 100 alle Zahlen + deren Rechenschritte ausgegeben. Nun müsste ich von denen halt nur die Top10 ausgeben sortiert nach den Rechenschritten.
Also die meisten Rechenschritte + Zahl auf 1.

Das würde dann so aussehen:

97 (die Zahl) 118 (die Rechenschritte)
83 (die Zahl) 110 (die Rechenschritte)
etc... bis Nr.10

wobei nur die Zahlen hingeschrieben werden, die Wörter Zahl oder Rechenschritt nicht xD

 

[DragonIce]

Wie willste du denn den Rest ausgeben? Da du die Werte nirgends speicherst sondern direkt ausgibst, kann dein Programm später nie wieder gucken wie viele Rechenschritte die z.B. die Zahl 50 gemacht hat. Und dafür brauchst du halt Arrays
Und btw.: 100 einzelne Ausgaben sind ziemlich nervig

 

[Julatsch]

mh.. scheisse ^^

 

[DragonIce]

Wieso denn "scheisse"?
Das übt dich doch
Wie kommst du damit voran? Habe bereits eine erste Lösung (allerdings schon länger) fertig.
Was machst du eigentlich beruflich, sodass dein Arbeitgeber das von dir haben möchte?

 

[Julatsch]

Mh, momentan überleg ich grad wie ich das mit den Arrays mache, hapert grad bischn an der Umsetzung deines Beispiels ^^

Bin seit 1.8.07 in der Ausbildung als Fachinformatiker / Anwendungsentwicklung.
Da ich erst am 27.10. Schule hab, habe ich noch nicht soviel mit Basic gemacht. Ich soll mich da quasi schonmal bisschen reinfuchsen =)


Ich hab bis jetzt das

For z = 1 to 100
e = rechenschritte(i)
For a = 1 to 10
IF e > ... ? da häng ich wobei ich auch net weiß ob das bis hier richtig war?


und wie meinst du das mit dem array meiste?

 

[DragonIce]

Wir können das Ganze auch einfacher machen. Hätte man wissen müssen dass du gerade erst angefangen bist.
Was mir bei deinem Ansatz gleich auffällt ist, dass du für die For - Next-Schleife die Variable "z" als Zähler verwendest. Wenn du danach aber "e" einen Wert zuweisen willst, benutzt du komischerweise "i". Das bringt nichts, zwar hat "i" einen Wert (aus einer vorhergehenden Schleife), allerdings verändert sich dieser nicht mit jeder Wiederholung, weil du "z" Zähler verwendest. Also muss es "e = rechenschritte(z)" heißen!

Jetzt weiche ich von meinem eigenen Vorschlag ab: Wir nehmen die For-Next-Schleife (1-10) erst einmal wieder weg.
Das Kriterium, damit überhaupt geschaut werden soll, wo der Wert in der Top10-Liste hingehört, müssen wir schauen ob er größer als der Letzte in der Liste ist, lautet: "If e > top(10) then".
"top" ist das Array wo die 10 höchsten Rechenschritte gespeichert werden.
Parallel lassen wir später noch ein 2. Array laufen wo die entsprechende Zahl gespeichert wird (Vectoren will ich dir noch nicht zumuten, wobei es 'ne Frage Wert ist, ob es die unter VB(A) überhaupt gibt )

So, wenn jetzt ein Wert in "e" steht, der Größer ist als der letzte Eintrag in der Top10 Liste, brauchen wir eine Schleife, die so lange läuft, bis ein Wert gleich groß oder größer ist. Dort muss aber pro Durchlauf rückwärts gezählt werden damit man später die Zuordnung einfacher "gestalten" kann!

Mal schauen ob du das hinkriegst. Wird nicht das Problem sein
Der Ansatz lautet nach wie vor:

for z = 1 to 100
    e = rechenschritte([B]z[/B])
    {
          Jetzt geht es wie beschrieben weiter (ohne die [B]{}[/B]) ;)
     }
next

Immer kleine Schritte machen!