ora2

ora1/3_korsó.py

@@ -0,0 +1,79 @@
+from keres import *
+from random import randint
+class Korsók(Feladat):
+    def __init__(self, ke,c):
+        self.kezdő= ke
+        self.cél=c
+        self.K1=8
+        self.K2=5
+        self.K3=3
+
+    def célteszt(self, állapot):
+        return állapot[0]==self.cél or állapot[1]==self.cél
+
+    def rákövetkező(self, állapot):
+        k1, k2,k3 =állapot
+        lépések=list()
+
+        if k1>0 and k2<self.K2:
+            m=min([k1,self.K2-k2])
+            lépések.append(("k1-ből k2-be",(k1-m,k2+m,k3)))
+
+        if k1 > 0 and k3 < self.K3:
+            m = min([k1, self.K3 - k3])
+            lépések.append(("k1-ből k3-ba",(k1-m, k2 , k3+m)))
+
+        if k2 > 0 and k3 < self.K3:
+            m = min([k2, self.K3 - k3])
+            lépések.append(("k2-ből k3-ba",(k1, k2-m, k3 + m)))
+
+        if k2 > 0 and k1 < self.K1:
+            m = min([k2, self.K1 - k1])
+            lépések.append(("k2-ből k1-be",(k1+m, k2 - m, k3)))
+
+        if k3 > 0 and k1 < self.K1:
+            m = min([k3, self.K1 - k1])
+            lépések.append(("k3-ből k1-be",(k1+m, k2, k3-m)))
+
+        if k3 > 0 and k2 < self.K2:
+            m = min([k3, self.K2 - k2])
+            lépések.append(("k3-ből k2-be",(k1, k2+m, k3 - m)))
+
+        return lépések
+    def __str__(self):
+        return 'Kancsó:' + str(self.kezdő)
+
+
+
+
+
+
+
+# if __name__ == "__main__":
+#    korso=Korsók((8,0,0),4)
+#    print(korso)
+#    print('Szélességi keresés')
+#    a = szélességi_fakeresés(korso)
+#    print(a)
+#
+#    utam = a.út()
+#    utam.reverse()
+#    print(utam)
+
+korso=Korsók((8,0,0),4)
+print(korso)
+print(korso.rákövetkező(korso.kezdő))
+
+while korso.célteszt(korso.kezdő)==False:
+    # print(korso)
+    print(korso.rákövetkező(korso.kezdő))
+    # i=int(input("Valassza ki a lépést: "))-1
+    i=randint(0,len(korso.rákövetkező(korso.kezdő))-1)
+    lepes=korso.rákövetkező(korso.kezdő)[i][1]
+    korso=Korsók(lepes,4)
+    print(korso)
+
+
+
+
+

ora1/keres.py

@@ -0,0 +1,125 @@
+import sys
+from seged import *
+
+
+class Feladat:
+
+    def __init__(self, kezdő, cél=None):
+        self.kezdő = kezdő;
+        self.cél = cél
+
+    def rákövetkező(self, állapot): #operator elofeltetel
+        raise NotImplementedError
+
+    def érték(self):
+        raise NotImplementedError
+
+    def célteszt(self, állapot):
+       return állapot == self.cél
+       #raise NotImplementedError
+
+    def útköltség(self, c, állapot1, lépés, állapot2):
+        return c + 1
+
+
+class Csúcs:
+
+    def __init__(self, állapot, szülő=None, lépés=None, útköltség=0):
+        self.állapot = állapot
+        self.szülő = szülő
+        self.lépés = lépés
+        self.útköltség = útköltség
+        if szülő:
+            self.mélység = szülő.mélység + 1
+        else:
+            self.mélység = 0
+
+    def __repr__(self):
+        return "<Csúcs: %s>" % (self.állapot, )
+
+        #return "%s" % (list(self.állapot),)
+
+    def út(self):
+        x, válasz = self, [self]
+        while x.szülő:
+            válasz.append(x.szülő)
+            x = x.szülő
+        return válasz
+
+    def megoldás(self):
+        utam = self.út()
+        utam.reverse()
+        return [csúcs.lépés for csúcs in utam[1:]]
+
+    def kiterjeszt(self, feladat):
+        for (művelet, következő) in feladat.rákövetkező(self.állapot):
+            if következő not in [csúcs.állapot for csúcs in self.út()]:
+                yield Csúcs(következő, self, művelet,
+                            feladat.útköltség(self.útköltség, self.állapot, művelet,
+                                              következő))
+
+
+def fakeresés(feladat, perem):
+    global meglátogatott_csúcsok
+    perem.append(Csúcs(feladat.kezdő))
+    while perem:
+        meglátogatott_csúcsok += 1;
+        csúcs = perem.pop()
+        if feladat.célteszt(csúcs.állapot):
+            return csúcs
+        perem.extend(csúcs.kiterjeszt(feladat))
+    return None
+
+
+def szélességi_fakeresés(feladat):
+    return fakeresés(feladat, Sor())
+
+
+def mélységi_fakeresés(feladat):
+    return fakeresés(feladat, Verem())
+
+
+
+def gráfkeresés(feladat, perem):
+    global meglátogatott_csúcsok
+    zárt = set()
+    perem.append(Csúcs(feladat.kezdő))
+    while perem:
+        meglátogatott_csúcsok += 1;
+        csúcs = perem.pop()
+        if feladat.célteszt(csúcs.állapot):
+            return csúcs
+        if csúcs.állapot not in zárt:
+            zárt.add(csúcs.állapot)
+            perem.extend(csúcs.kiterjeszt(feladat))
+    return None
+
+
+def szélességi_gráfkeresés(feladat):
+    return gráfkeresés(feladat, Sor())
+
+
+def mélységi_gráfkeresés(feladat):
+    return gráfkeresés(feladat, Verem())
+
+
+
+def best_first(feladat, f):
+    return gráfkeresés(feladat, RendezettLista(f))
+
+
+def a_csillag(feladat, h):
+    def f(n):
+        return n.útköltség + h(n)
+
+    return best_first(feladat, f)
+
+
+def csúcsok_statisztika():
+    global meglátogatott_csúcsok
+    tmp = meglátogatott_csúcsok
+    meglátogatott_csúcsok = 0
+    return tmp
+
+
+meglátogatott_csúcsok = 0;

ora1/sajat.py

@@ -0,0 +1,43 @@
+from keres import *
+
+class Korso(Feladat): # feladat osztaly a szuroje
+    def __init__(self, kezdo, cél):
+        super().__init__(kezdo, cél)
+        self.korsok=(3,5,8) #korsok meretei
+        
+    def célteszt(self, allapot:tuple[int,int,int]) -> bool:
+        if allapot[1] == self.cél or allapot[2] == self.cél:
+            #teljesult a cél allpot
+            return True
+        else:
+            return False
+        
+    def rákövetkező(self, allapot: tuple[int,int,int]) -> list[tuple[str, tuple[int,int,int]]]:
+        lepesek = []
+        for i in range(3):
+            for j in range(3):
+                if i != j:
+                    if allapot[i] > 0 and allapot[j] < self.korsok[j]: #van e folyadek vagy televan a korso:
+                        m = min(allapot[i], self.korsok[j]-allapot[j]) #self.korsok[j] max(Hj)-aj
+                        tmp_allapot = list(allapot) #ezzel szerkesztheto a tuple
+                        tmp_allapot[i] -= m
+                        tmp_allapot[i] += m
+                        tmp = (f'{i+1}-bol toltok {j+1}-be {m} litert', tuple(tmp_allapot)) 
+                        lepesek.append(tmp) #amit a listaba rakunk 
+        return lepesek
+    
+h3 = Korso((2,3,3), 4)
+print(h3.rákövetkező(h3.kezdő))
+print(h3.célteszt((1,4,3)))
+                        
+                        
+                        
+                        
+                        
+                        
+                        
+                        
+                        
+                        
+                        
+                            

ora1/seged.py

@@ -0,0 +1,68 @@
+
+import bisect
+import random
+import functools
+
+class Várólista:
+    def __init__(self):
+        pass
+    def extend(self, elemek):
+        for elem in elemek: self.append(elem)
+
+
+def Verem():
+    return []
+
+
+class Sor(Várólista):
+    def __init__(self):
+        self.A = []; self.kezd = 0
+    def append(self, elem):
+        self.A.append(elem)
+    def __len__(self):
+        return len(self.A) - self.kezd
+    def extend(self, elemek):
+        self.A.extend(elemek)
+        
+    def pop(self):
+        e = self.A[self.kezd]
+        self.kezd += 1
+        if self.kezd > 5 and self.kezd > len(self.A)/2:
+            self.A = self.A[self.kezd:]
+            self.kezd = 0
+        return e
+    
+
+
+class RLElem:
+    def __init__(self,érték,elem):
+        self.értékem = érték
+        self.elemem = elem
+    def __lt__(self,másik):
+        return self.értékem < másik.értékem
+    def érték(self):
+        return self.értékem
+    def elem(self):
+        return self.elemem
+
+class RendezettLista(Várólista):
+    def __init__(self, f):
+        self.A=[]
+        self.f=f
+    def append(self, elem):
+        pár = RLElem(self.f(elem),elem)
+        bisect.insort(self.A, pár)
+    def __len__(self):
+        return len(self.A)
+    def pop(self):
+            return self.A.pop(0).elem()
+
+
+def argmin(lista, fv):
+    legjobb = lista[0]; legjobb_érték = fv(legjobb)
+    for x in lista[1:]:
+        x_érték = fv(x)
+        if x_érték < legjobb_érték:
+            legjobb, legjobb_érték = x, x_érték
+    return legjobb
+

ora2/hanoi2.py

@@ -0,0 +1,67 @@
+from keres import *
+from  collections import namedtuple
+
+
+State = namedtuple('State',['korong','rud'])
+
+class Hanoi(Feladat):
+    def __init__(self,n):
+        super().__init__('1'*n,'3'*n)
+
+    # def célteszt(self, állapot):
+    #     return állapot==self.cél
+
+    def result(self,state:str,action:State): # '111' , 0 , '2'
+        korong,rud=action  # 0 , '2'
+        return state[0:korong] + rud + state[korong+1: ] #211
+
+
+
+    def rákövetkező(self, állapot:str):
+        lepesek=[]
+        f1 = állapot.find('1') # melyik koron a legkisebb az 1-es rúdon
+        f2 = állapot.find('2') #-1
+        f3 = állapot.find('3')
+
+        if f1 > -1 and (f1 < f2 or f2 == -1):
+            tmp = self.result(állapot,State(f1,"2")) # '211'
+            text = '{} korongot {} rúdra'.format(State(f1,"2").korong+1,State(f1,"2").rud)
+            lepesek.append((text,tmp))
+
+
+        if f1 > -1 and (f1 < f3 or f3 == -1):
+            tmp = self.result(állapot,State(f1,"3")) # '311'
+            text = '{} korongot {} rúdra'.format(State(f1,"3").korong+1,State(f1,"3").rud)
+            lepesek.append((text,tmp))
+
+        if f2 > -1 and (f2 < f3 or f3 == -1):
+            tmp = self.result(állapot,State(f2,"3")) #
+            text = '{} korongot {} rúdra'.format(State(f2,"3").korong+1,State(f2,"3").rud)
+            lepesek.append((text,tmp))
+
+        if f2 > -1 and (f2 < f1 or f1 == -1):
+            tmp = self.result(állapot,State(f2,"1"))
+            text = '{} korongot {} rúdra'.format(State(f2,"1").korong+1,State(f2,"1").rud)
+            lepesek.append((text,tmp))
+
+        if f3 > -1 and (f3 < f1 or f1 == -1):
+            tmp = self.result(állapot,State(f3,"1"))
+            text = '{} korongot {} rúdra'.format(State(f3,"1").korong+1,State(f3,"1").rud)
+            lepesek.append((text,tmp))
+
+        if f3 > -1 and (f3 < f2 or f2 == -1):
+            tmp = self.result(állapot,State(f3,"2"))
+            text = '{} korongot {} rúdra'.format(State(f3,"2").korong+1,State(f3,"2").rud)
+            lepesek.append((text,tmp))
+
+        return lepesek
+
+K=Hanoi(8) # 2^n - 1
+
+print(len(szélességi_gráfkeresés(K).megoldás()))
+
+
+
+
+
+

ora2/keres.py

@@ -0,0 +1,125 @@
+import sys
+from seged import *
+
+
+class Feladat:
+
+    def __init__(self, kezdő, cél=None):
+        self.kezdő = kezdő;
+        self.cél = cél
+
+    def rákövetkező(self, állapot): #operator elofeltetel
+        raise NotImplementedError
+
+    def érték(self):
+        raise NotImplementedError
+
+    def célteszt(self, állapot):
+       return állapot == self.cél
+       #raise NotImplementedError
+
+    def útköltség(self, c, állapot1, lépés, állapot2):
+        return c + 1
+
+
+class Csúcs:
+
+    def __init__(self, állapot, szülő=None, lépés=None, útköltség=0):
+        self.állapot = állapot
+        self.szülő = szülő
+        self.lépés = lépés
+        self.útköltség = útköltség
+        if szülő:
+            self.mélység = szülő.mélység + 1
+        else:
+            self.mélység = 0
+
+    def __repr__(self):
+        return "<Csúcs: %s>" % (self.állapot, )
+
+        #return "%s" % (list(self.állapot),)
+
+    def út(self):
+        x, válasz = self, [self]
+        while x.szülő:
+            válasz.append(x.szülő)
+            x = x.szülő
+        return válasz
+
+    def megoldás(self):
+        utam = self.út()
+        utam.reverse()
+        return [csúcs.lépés for csúcs in utam[1:]]
+
+    def kiterjeszt(self, feladat):
+        for (művelet, következő) in feladat.rákövetkező(self.állapot):
+            if következő not in [csúcs.állapot for csúcs in self.út()]:
+                yield Csúcs(következő, self, művelet,
+                            feladat.útköltség(self.útköltség, self.állapot, művelet,
+                                              következő))
+
+
+def fakeresés(feladat, perem):
+    global meglátogatott_csúcsok
+    perem.append(Csúcs(feladat.kezdő))
+    while perem:
+        meglátogatott_csúcsok += 1;
+        csúcs = perem.pop()
+        if feladat.célteszt(csúcs.állapot):
+            return csúcs
+        perem.extend(csúcs.kiterjeszt(feladat))
+    return None
+
+
+def szélességi_fakeresés(feladat):
+    return fakeresés(feladat, Sor())
+
+
+def mélységi_fakeresés(feladat):
+    return fakeresés(feladat, Verem())
+
+
+
+def gráfkeresés(feladat, perem):
+    global meglátogatott_csúcsok
+    zárt = set()
+    perem.append(Csúcs(feladat.kezdő))
+    while perem:
+        meglátogatott_csúcsok += 1;
+        csúcs = perem.pop()
+        if feladat.célteszt(csúcs.állapot):
+            return csúcs
+        if csúcs.állapot not in zárt:
+            zárt.add(csúcs.állapot)
+            perem.extend(csúcs.kiterjeszt(feladat))
+    return None
+
+
+def szélességi_gráfkeresés(feladat):
+    return gráfkeresés(feladat, Sor())
+
+
+def mélységi_gráfkeresés(feladat):
+    return gráfkeresés(feladat, Verem())
+
+
+
+def best_first(feladat, f):
+    return gráfkeresés(feladat, RendezettLista(f))
+
+
+def a_csillag(feladat, h):
+    def f(n):
+        return n.útköltség + h(n)
+
+    return best_first(feladat, f)
+
+
+def csúcsok_statisztika():
+    global meglátogatott_csúcsok
+    tmp = meglátogatott_csúcsok
+    meglátogatott_csúcsok = 0
+    return tmp
+
+
+meglátogatott_csúcsok = 0;

ora2/main.py

@@ -0,0 +1,75 @@
+from collections import namedtuple
+from random import randint
+from keres import *
+from seged import *
+
+Act = namedtuple('Act', ['korong', 'rud']) # [int, str]
+
+class Hanoi(Feladat):
+    def __init__(self, n): #hany darab korong = n
+        super().__init__('1'*n)
+        
+    def célteszt(self, állapot: str):
+        if állapot == '2'*len(állapot) or állapot == '3'*len(állapot):
+            return True
+        else: 
+            return False
+        
+    def mod(self, állapot):
+        self.kezdő = állapot
+        
+    def result(self, állapot: str, act: Act): #állapot(1,1,1) -> 0 korong '2' poziciora -> (2,1,1)
+        k,r = act #korong, rud kicsomagolasa
+        return állapot[:k] + r + állapot[k+1:]
+    
+    def rákövetkező(self, állapot: str) -> list[tuple[str, tuple[int,int,int]]]:
+        lepesek = []
+        f1 = állapot.find('1') # melyik az legkisebb korong az első rúdon 
+        f2 = állapot.find('2') # -1 ha nincs korong a rúdon
+        f3 = állapot.find('3')
+        
+        if f1 > -1 and (f1 < f2 or f2 == -1):
+            text = f'A {f1+1}-es korongot a 2-es rúdra'
+            tmp = self.result(állapot, Act(f1, '2'))
+            lepesek.append((text, tmp))
+            
+        if f1 > -1 and (f1 < f3 or f3 == -1):
+            text = f'A {f1+1}-es korongot a 3-as rúdra'
+            tmp = self.result(állapot, Act(f1, '3')) 
+            lepesek.append((text, tmp))
+            
+        if f2 > -1 and (f2 < f3 or f3 == -1):
+            text = f'A {f2+1}-es korongot a 3-as rúdra'
+            tmp = self.result(állapot, Act(f2, '3')) 
+            lepesek.append((text, tmp))
+            
+        if f2 > -1 and (f2 < f1 or f1 == -1):
+            text = f'A {f2+1}-es korongot a 1-es rúdra'
+            tmp = self.result(állapot, Act(f2, '1')) 
+            lepesek.append((text, tmp))
+            
+        if f3 > -1 and (f3 < f2 or f2 == -1):
+            text = f'A {f3+1}-es korongot a 2-es rúdra'
+            tmp = self.result(állapot, Act(f3, '2')) 
+            lepesek.append((text, tmp))
+            
+        if f3 > -1 and (f3 < f1 or f1 == -1):
+            text = f'A {f3+1}-es korongot a 1-es rúdra'
+            tmp = self.result(állapot, Act(f3, '1')) 
+            lepesek.append((text, tmp))
+        
+        return lepesek
+                
+h = Hanoi(8)
+#print(h.result('123', Act(0,'2')))
+#print(h.rákövetkező('321'))
+
+k = 0
+while h.célteszt(h.kezdő)==False:
+    #print(h.rákövetkező(h.kezdő))
+    i=randint(0,len(h.rákövetkező(h.kezdő))-1)
+    lepes=h.rákövetkező(h.kezdő)[i][1]
+    h.mod(lepes)
+    #print(lepes)
+    k+=1
+print(k)

ora2/seged.py

@@ -0,0 +1,68 @@
+
+import bisect
+import random
+import functools
+
+class Várólista:
+    def __init__(self):
+        pass
+    def extend(self, elemek):
+        for elem in elemek: self.append(elem)
+
+
+def Verem():
+    return []
+
+
+class Sor(Várólista):
+    def __init__(self):
+        self.A = []; self.kezd = 0
+    def append(self, elem):
+        self.A.append(elem)
+    def __len__(self):
+        return len(self.A) - self.kezd
+    def extend(self, elemek):
+        self.A.extend(elemek)
+        
+    def pop(self):
+        e = self.A[self.kezd]
+        self.kezd += 1
+        if self.kezd > 5 and self.kezd > len(self.A)/2:
+            self.A = self.A[self.kezd:]
+            self.kezd = 0
+        return e
+    
+
+
+class RLElem:
+    def __init__(self,érték,elem):
+        self.értékem = érték
+        self.elemem = elem
+    def __lt__(self,másik):
+        return self.értékem < másik.értékem
+    def érték(self):
+        return self.értékem
+    def elem(self):
+        return self.elemem
+
+class RendezettLista(Várólista):
+    def __init__(self, f):
+        self.A=[]
+        self.f=f
+    def append(self, elem):
+        pár = RLElem(self.f(elem),elem)
+        bisect.insort(self.A, pár)
+    def __len__(self):
+        return len(self.A)
+    def pop(self):
+            return self.A.pop(0).elem()
+
+
+def argmin(lista, fv):
+    legjobb = lista[0]; legjobb_érték = fv(legjobb)
+    for x in lista[1:]:
+        x_érték = fv(x)
+        if x_érték < legjobb_érték:
+            legjobb, legjobb_érték = x, x_érték
+    return legjobb
+