Seite 3 von 5
Verfasst: Dienstag 16. Dezember 2008, 23:17
von Nocta
chris27 hat geschrieben:Wie kann ich machen das er die bereits geratenen Zahlen nicht wieder benutzt?
Dazu müsstest du die Werte einfach irgendwo abspeichern. Zum Beispiel in einer Liste oder einem Set oder weiß ich, was am performantesten ist.
Dann rätst du einfach so lange eine neue Zahl, bis du eine hast, die noch nicht in der Liste gespeichert ist. (in-Operator dürfte da helfen)
chris27 hat geschrieben:Und wie geht das mit Python Flag?
Wenn man einen Beitrag schreibt, gibt es doch oben die Buttons. Drücke da einfach auf den Button mit der Aufschrift "Python".
Verfasst: Dienstag 16. Dezember 2008, 23:18
von numerix
chris27 hat geschrieben:Zahlen von 1 - 10000 findet er in Sekunden. Aber bei Zahlen von 1 - Millionen, wird es fast zu einer endlos - Schleife. Wie kann ich machen das er die bereits geratenen Zahlen nicht wieder benutzt?
Dazu musst du die schon einmal geratenen Zahlen z.B. in einer Liste oder (besser) in einer Menge (set) speichern.
ABER: Das, was du da machst, hat mit KI nun wirklich nichts zu tun!
Denk mal darüber nach, wie du selbst systematisch eine dir unbekannte Zahl suchen würdest, wenn der Computer dir jedesmal immer nur sagt, ob dein Tipp zu groß oder zu klein ist. Und dann bringst du das dem Computer bei ...

Verfasst: Dienstag 16. Dezember 2008, 23:21
von chris27
Danke für die Tipps. Man bin ich doof

werd das noch hinkriegen:)
Verfasst: Dienstag 16. Dezember 2008, 23:21
von Hyperion
Wieso beachtest Du Hinweise so wenig? So wirst Du sicherlich eher weniger Tipps denn mehr bekommen
Naja, ein Hinweis noch: Wieso lässt Du die "KI" nur dumm raten? Gib ihr doch auch die Hinweise mit größer tiefer usw. Dann kann man den Ratebereich doch schnell einschränken.
Anstatt blind zu tippen könntest Du auch den Rateraum immer halbieren (Nennt sich iirc Intervallschachtelung oder auch binäre Suche).
Bsp:
Gesuchte Zahl ist 27
Rechner rät im Bereich 1 - 100
1.) 100/2 = 50, Rechner tippt 50
-> Zahl ist kleiner
2.) 50 / 2 = 25, Rechner tippt 25
-> Zahl ist größer
3.) 50-(25/2) = 50-13 = 37, Tipp 37
-> Zahl ist kleiner
4.) ...
Man muss sich dabei imho nur die aktuell obere Rategrenze und die untere merken. So sollte man auch bei großen Suchräumen schnell zum Erfolg kommen ...
Verfasst: Mittwoch 17. Dezember 2008, 00:16
von chris27
Also ehrlich gesagt versuche ich alle Hinweise umzusetzen, soweit es mir möglich ist. Davon ab hab ich doch alle deine letzten Hinweise befolgt.
hab jetzt noch kleiner, grösser in mein script eingebaut, trotzdem ist mein Prg noch verhältnismässig dumm.
Nicht desto trozt hat es eine zahl zwischen 1 und 10000000000000 in ein paar sekunden berechnet. Hab die print Anweisung nach jedem Versuch weggelassen um es schneller zu machen.
Die gesuchte Zahl ist: 6511526382945
______________________
Das Programm versucht nun die Zahl zu erraten
Bitte um einen Augenblick Geduld
-------------------------------------------------------
Das Programm hat 7128583 Versuche gebraucht, in 34 Sekunden
Werde das Script erst wieder reinstellen wenns ausgerift ist, bevor ich wieder geschimpft bekomme

Verfasst: Mittwoch 17. Dezember 2008, 06:14
von chris27
So hab den K.I. nicht ganz so schlau gemacht, wie Hyperion empfohlen hatte, weil ichs irgendwie nicht hinbekam, aber so klappts jetzt auch ganz gut, werde mal posten wie es inzwischen aussieht. Habe versucht alle Hinweise von euch umzusetzen.
Code: Alles auswählen
import random
import time
def zahlenraten1():
secret = random.randint(1,1000)
print
print "Die gesuchte Zahl ist: ", secret
print "_" * 35
print
guess1 = random.randint(1,1000)
guess2 = random.randint(1,1000)
guess3 = random.randint(1,1000)
guess4 = random.randint(1,1000)
i = 1
startzeit = time.time() #Zeit startet
print """Das Programm versucht nun die Zahl zu erraten
Bitte um einen Augenblick Geduld"""
print "-" * 55
while guess1 != secret and guess2 != secret and guess3 != secret and guess4 != secret:
zeit = int(time.time() - startzeit) #Zeitzaehler
#-K.I.1-----------------------------------------------------------------------
if guess1 > secret:
guess1 = guess1 - 1
if guess1 < secret:
guess1 = guess1 + 1
#-K.I.2-----------------------------------------------------------------------
if guess2 > secret:
guess2 = guess2 -1
if guess2 < secret:
guess2 = guess2 +1
#-K.I.3-----------------------------------------------------------------------
if guess3 > secret:
guess3 = guess3 -1
if guess3 < secret:
guess3 = guess3 +1
#-K.I.4-----------------------------------------------------------------------
if guess4 > secret:
guess4 = guess3 -1
if guess4 < secret:
guess4 = guess3 +1
#-------------------------------------------------------------------------------
print "Versuch ", i, ":", "guess1\t-\t", guess1
print "Versuch ", i, ":", "guess2\t-\t", guess2
print "Versuch ", i, ":", "guess3\t-\t", guess3
print "Versuch ", i, ":", "guess4\t-\t", guess4
print "-" *30
i += 1
if guess1 == secret:
print "K.I.-1 hat die Zahl zuerst erraten"
if guess2 == secret:
print "K.I.-2 hat die Zahl zuerst erraten"
if guess3 == secret:
print "K.I.-3 hat die Zahl zuerst erraten"
if guess4 == secret:
print "K.I.-4 hat die Zahl zuerst erraten"
print """Das Programm hat ", i, " Versuche gebraucht, in", zeit, Sekunden.
Die gesuchte Zahl war , secret"""
#-------------------------------------------------------------------------------
def zahlenraten2():
print "Zahlenraten!"
print "_"*10
print
print "Versuchen Sie die vom Programm zufaellig ausgesuchte Zahl zu erraten"
print "-"*80
secret = random.randint(1, 100)
nachname = raw_input("Gib deinen Vornamen ein:")
vorname = raw_input("Nun gib bitte deinen Nachnamen ein:")
name = vorname + " " + nachname
print "Hallo %s %s, schoen, dass Du hier spielen willst" % (vorname, nachname)
startzeit = time.time() #Zeit startet
while True:
try:
guess = int(raw_input("Bitte geben Sie eine Zahl ein: "))
except ValueError, exception:
print exception.message
continue
zeit = int(time.time() - startzeit) #Zeitzaehler
if guess < secret:
print "zu tief"
elif guess > secret:
print "zu hoch"
else:
print "Richtig, Sie haben das Spiel gewonnen"
break
print u"Fuer die Aufgabe haben sie ", zeit, "Sekunden benoetigt"
print "Danke fuers spielen %s %s" % (vorname, nachname)
print """Willkommen im Menue
Wenn sie sehen wollen wie der Computer eine Zahl erraet druecken Sie bitte die 1
Wenn Sie Zahlenraten spielen wollen druecken Sie bitte die 2 """
eingabe = int(raw_input("Geben sie eine Zahl ein: "))
if eingabe == 1:
zahlenraten1()
if eingabe == 2:
zahlenraten2()
werde die K.I. noch mal bearbeiten.
@Hyperion
Achja was meinst du mit Code auf modulebene, hab auch unter wiki gesucht, versteh nicht was das eigentlich ist.
Ich programmiere übrigens jetzt erst seit 3 Wochen, hab vorher nie etwas in der Richtung gemacht. Ist das Script dafür ok, oder sollte das schon wesentlich besser aussehn?
Verfasst: Mittwoch 17. Dezember 2008, 08:51
von Hyperion
Also Du bekommst ja nicht geschimpft - manchmal mutet Kritik einfach negativ an, dabei ist das ganz normal im Lernprozess, dass man Dinge auch mal "falsch" oder wenig elegant umsetzt. Wenn man darauf reagiert will man Dir ja nur helfen
Also Code auf Modul-Ebene ist folgendes:
Wenn nun jemand Deine Datei als Modul importiert, dann wird die print Anweisung ausgeführt - und das will man dann ja nicht wirklich. Oder fändest Du es gut, wenn das random-Modul erst einmal zig Sachen printen würde, bevor Du Deine Zufallszahl hast?
Verfasst: Mittwoch 17. Dezember 2008, 12:19
von BlackJack
@chris27: Ich war mal so frei die eine "Trennlinie" in Deinem Quelltext auf normale Länge zu kürzen. Bei so langen Zeilen bekommen einige Leute einen vertikalen Scrollbalken im Browser für die gesamte Seite und es ist echt mühsam Beiträge zu lesen, wenn man dauernd hin und her scrollen muss.
Wenn man anfängt Namen zu nummerieren, will man meistens eine Liste benutzen. Das wäre hier bei `guess1` bis `guess4` der Fall. Damit würde der Quelltext kürzer weil man die dann "guesses" dann in einer Schleife verarbeiten kann und man auch mehr als vier verwenden in dem man einfach an der Stelle wo die Liste erstellt wird, mehr Elemenete erzeugt.
Die Bedingung in der ``while``-Schleife (Zeile 19) kann man kürzer ausdrücken: ``while secret not in (guess1, guess2, guess3, guess4):`` oder wenn man mit einer Liste arbeitet ``while secret not in guesses:``.
Es wird bei jedem Schleifendurchlauf die Zeit ermittelt, aber nur das letzte Ergebnis davon *nach* der Schleife ausgegeben.
ie KI ist ineffizient, weil nur einer der "guesses" sein Ziel erreichen kann und man kann nach dem ersten Schritt die beiden einzigen möglichen Kandidaten dafür bestimmen.
Verfasst: Mittwoch 17. Dezember 2008, 14:44
von numerix
Nochmal zu deiner KI:
Hyperion meint folgendes: Eine effiziente Suchstrategie kann so aussehen, dass man als Startwert den Mittelwert des in Frage kommenden Intervalls nimmt. Nachdem man die Rückmeldung erhalten hat, ob die Zahl zu groß oder zu klein war, weiß man, in welcher der beiden Hälften des Intervalls sie liegen muss.
Dann nimmt man wieder den Mittelwert diese neuen (halb so großen) Intervalls und das Ganze wiederholt sich, bis man die gesuchte Zahl so weit eingeschachtelt hat, dass keine andere mehr übrig bleibt.
Mit dieser Methode findet man z.B. mit max. 30 Rateversuchen jede beliebige Zahl bis 1 Mrd.
(Falls der Mittelwert keine natürliche Zahl ist, muss man entsprechend runden oder abschneiden.)
Verfasst: Donnerstag 18. Dezember 2008, 00:23
von chris27
Hab den ganzen Nachmittag ander KI gesessen, aber bekomm es einfach nicht so hin wie ihr es beschrieben habt.
Verfasst: Donnerstag 18. Dezember 2008, 09:53
von chris27
Ihr werdet jetzt wahrscheinlich den Kopf schütteln, aber ich versuch grad ein Programm zu schreiben, ähnlich wie das zahlenraten nur das es ein wort raten soll

, womit man eventuell auch passwörter knacken könnte.
hab jetzt nur das Problem das mein Prog nur einzelne Buchstaben rät.
Wäre das überhaupt umsetzbar was ich wieder vorhabe, was mach ich falsch.
Code: Alles auswählen
import random
def zufallsbuchstabe():
secret = "chris"
guess = 0
buchstaben = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
while guess != secret:
guess = buchstaben[random.randint(0,25)]
print guess
zufallsbuchstabe()
Verfasst: Donnerstag 18. Dezember 2008, 09:58
von chris27
Ah mom so bin ich der Sache schon näher.
Code: Alles auswählen
import random
def zufallsbuchstabe():
secret = "CHR"
guess = 0
buchstaben = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
while guess != secret:
guess = buchstaben[random.randint(0,25)] + buchstaben[random.randint(0,25)] + buchstaben[random.randint(0,25)]
print guess
zufallsbuchstabe()
ich müsste die K.I. so entwickeln das er ein buchstabe nach dem anderem rät.mal schauen. Bis 4 Buchstaben klappt es noch, aber das wars dann, wenn ich nicht Jahre warten will
Verfasst: Donnerstag 18. Dezember 2008, 10:14
von BlackJack
Wie wär's wenn Du mal eine Sache zuende führst und nicht ständig Neues anfängst und vor allem endlich mal anfängst diese "copy'n'paste"-Programmierung durch ordentliche Schleifen zu ersetzen!?
Wenn man x mal (fast) das gleiche machen muss, dann kopiert man den Quelltext dafür nicht x mal, sondern schreibt eine Schleife.
Verfasst: Donnerstag 18. Dezember 2008, 10:35
von chris27
ja ok ok. werd das andere noch beenden, brauchte etwas abwechslung
Verfasst: Donnerstag 18. Dezember 2008, 11:03
von Nergal
Ich an deiner Stelle würde mir erstmal Gedanken machen wie man schnell und effektiv die Zahl (den Weg von Hyperion) / den Buchstaben findet und nicht sofort immer blind drauf lostippen.
In deinem Buchstabenfinder steckt z.B. nicht ein Hauch von Logik.
Verfasst: Donnerstag 18. Dezember 2008, 12:31
von Konrad Wenzel
Als Beispiel zur dualen Suche habe ich was in hpl (Hewlett Packard) ausgegraben
und umgeschrieben:
so ein Sprung per return aus der Schleife ist nicht gerade fein, aber kurz
(hpl hat keine Schleifen, nur jmp (jump) und goto
Code: Alles auswählen
# binaere, ( oder duale) Suche
# fuer sortierte Sequenzen
def binsuch(suchW):
global geordnetS
hinten=len(geordnetS) # Grenzen, aufpassen !
mitte=hinten/2
vorn= -1
while(hinten - vorn) > 1:
if suchW > geordnetS[mitte]:
vorn=mitte
elif suchW < geordnetS[mitte]:
hinten=mitte
else:
return mitte # Position gefunden
mitte = (hinten + vorn)/2
return -1 # nicht gefunden
# ------------------------------------
geordnetS = ('Apfel','Birne','Cocos','Dattel','Esche','Fallobst','Gurke',
'Ha','Ih','Jot','Ka','Lehm','Moehre','Nase','Oh','Pe','Qu','Rot','Suse',
'Te','Uuh','Vau','We','Xi','Yp','Zet')
for i in('A','Apfel','Ka','Karton','Oh','Z','Zet'):
k= binsuch(i)
if k != -1:
print k, geordnetS[k]
else:
print i, ' nicht in g.S'
Verfasst: Donnerstag 18. Dezember 2008, 13:56
von Leonidas
Ihgitt, ``global``. Alles andere als ein gutes Beispiel.
Verfasst: Donnerstag 18. Dezember 2008, 17:36
von chris27
Kann mir bitte jemand für die K.I. die Hyperion beschrieben hat helfen. Häng schon ewig dran und komm net weiter. Bestimmt ist es noch ziemlich simple nur ich komm nicht drauf. Kleinen Tipp please

Verfasst: Donnerstag 18. Dezember 2008, 17:42
von chris27
BlackJack hat geschrieben:und vor allem endlich mal anfängst diese "copy'n'paste"-Programmierung durch ordentliche Schleifen zu ersetzen!?
Was meinst du mit diesem copy and paste programmierung, was ist das?
hier das?
Code: Alles auswählen
guess = buchstaben[random.randint(0,25)] + buchstaben[random.randint(0,25)] + buchstaben[random.randint(0,25)] + ...
Verfasst: Donnerstag 18. Dezember 2008, 17:55
von numerix
chris27 hat geschrieben:Was meinst du mit diesem copy and paste programmierung, was ist das?
Wenn sich in einem Code bestimmte Teile (fast) bis aufs Haar gleichen ...
Das ist fast immer ein Zeichen schlechten Codes und lässt sich häufig durch eine Funktion oder eine geeignete Datenstruktur (Liste, Dictionary) beheben.
Das mit dem binären Suchen könnte so aussehen:
Code: Alles auswählen
from random import randrange
maximum = 1000000000
geheimzahl = randrange(maximum)
def findezahl(intervall):
versuche = 0
while True:
versuche += 1
mitte = (intervall[0]+intervall[1]) // 2
if mitte == geheimzahl:
return mitte, versuche
elif mitte < geheimzahl:
intervall[0] = mitte
else:
intervall[1] = mitte
zahl, versuche = findezahl([0,maximum])
print geheimzahl, zahl, versuche