ora4 download

dsa

ora1gyak/obj/ora1gyak.csproj.nuget.dgspec.json

@@ -1,17 +1,17 @@
 {
   "format": 1,
   "restore": {
-    "/home/tom/Dev/MestInt/ora1gyak/ora1gyak.csproj": {}
+    "/home/tom/Dev/mestint/ora1gyak/ora1gyak.csproj": {}
   },
   "projects": {
-    "/home/tom/Dev/MestInt/ora1gyak/ora1gyak.csproj": {
+    "/home/tom/Dev/mestint/ora1gyak/ora1gyak.csproj": {
       "version": "1.0.0",
       "restore": {
-        "projectUniqueName": "/home/tom/Dev/MestInt/ora1gyak/ora1gyak.csproj",
+        "projectUniqueName": "/home/tom/Dev/mestint/ora1gyak/ora1gyak.csproj",
         "projectName": "ora1gyak",
-        "projectPath": "/home/tom/Dev/MestInt/ora1gyak/ora1gyak.csproj",
+        "projectPath": "/home/tom/Dev/mestint/ora1gyak/ora1gyak.csproj",
         "packagesPath": "/home/tom/.nuget/packages/",
-        "outputPath": "/home/tom/Dev/MestInt/ora1gyak/obj/",
+        "outputPath": "/home/tom/Dev/mestint/ora1gyak/obj/",
         "projectStyle": "PackageReference",
         "configFilePaths": [
           "/home/tom/.nuget/NuGet/NuGet.Config"
@@ -53,7 +53,7 @@
               "privateAssets": "all"
             }
           },
-          "runtimeIdentifierGraphPath": "/usr/lib/dotnet/sdk/8.0.112/PortableRuntimeIdentifierGraph.json"
+          "runtimeIdentifierGraphPath": "/usr/lib/dotnet/sdk/8.0.114/PortableRuntimeIdentifierGraph.json"
         }
       }
     }

ora1gyak/obj/project.assets.json

@@ -13,11 +13,11 @@
   "project": {
     "version": "1.0.0",
     "restore": {
-      "projectUniqueName": "/home/tom/Dev/MestInt/ora1gyak/ora1gyak.csproj",
+      "projectUniqueName": "/home/tom/Dev/mestint/ora1gyak/ora1gyak.csproj",
       "projectName": "ora1gyak",
-      "projectPath": "/home/tom/Dev/MestInt/ora1gyak/ora1gyak.csproj",
+      "projectPath": "/home/tom/Dev/mestint/ora1gyak/ora1gyak.csproj",
       "packagesPath": "/home/tom/.nuget/packages/",
-      "outputPath": "/home/tom/Dev/MestInt/ora1gyak/obj/",
+      "outputPath": "/home/tom/Dev/mestint/ora1gyak/obj/",
       "projectStyle": "PackageReference",
       "configFilePaths": [
         "/home/tom/.nuget/NuGet/NuGet.Config"
@@ -59,7 +59,7 @@
             "privateAssets": "all"
           }
         },
-        "runtimeIdentifierGraphPath": "/usr/lib/dotnet/sdk/8.0.112/PortableRuntimeIdentifierGraph.json"
+        "runtimeIdentifierGraphPath": "/usr/lib/dotnet/sdk/8.0.114/PortableRuntimeIdentifierGraph.json"
       }
     }
   }

ora1gyak/obj/project.nuget.cache

@@ -1,8 +1,8 @@
 {
   "version": 2,
-  "dgSpecHash": "TmB9rBKg2O3dJIEyjAoFHeHzE4yeHzDGtzDXp6FD5dgvRPnHhiiDl3UcbmoJRuK4sHRdNFwixioP5NT+dLYafw==",
+  "dgSpecHash": "LSXKkYbEipDi2s34hjkPtcWuBZ27yJ4Op86IJQq/RFsEzaWLkRF6Q2McL+pRI2MfMlk8wgXE4+1ITCwK8Tc9cw==",
   "success": true,
-  "projectFilePath": "/home/tom/Dev/MestInt/ora1gyak/ora1gyak.csproj",
+  "projectFilePath": "/home/tom/Dev/mestint/ora1gyak/ora1gyak.csproj",
   "expectedPackageFiles": [],
   "logs": []
 }

ora3/hanoi2.py

@@ -66,20 +66,20 @@ class Hanoi(Feladat):
         n = állapot.count('1') #hany darab korong van az egyes rudon | megoldaskor 0
         return n - állapot.count('2') - 2*állapot.count('3')
     
-    def útköltség(self, c, állapot1, lépés, állapot2):
+    #def útköltség(self, c, állapot1, lépés, állapot2):
-        #return super().útköltség(c, állapot1, lépés, állapot2)
+    #    #return super().útköltség(c, állapot1, lépés, állapot2)
-        egy = 2*(állapot1.count('1') - állapot2.count('1'))
+    #    egy = 2*(állapot1.count('1') - állapot2.count('1'))
-        ketto = 1.5*(állapot2.count('2') - állapot1.count('2'))
+    #    ketto = 1.5*(állapot2.count('2') - állapot1.count('2'))
-        harom = 0*(állapot2.count('3') - állapot1.count('3'))
+    #    harom = 0*(állapot2.count('3') - állapot1.count('3'))
-        return c+ egy + ketto + harom
+    #    return c+ egy + ketto + harom
                 
-h = Hanoi(5)
+h = Hanoi(3)
 print("szelessegi kereses")
 print(szélességi_fakeresés(h))
 #print("melysegi kereses")
 #print(mélységi_fakeresés(h))
-print("melysegi graf")
+#print("melysegi graf")
-print(mélységi_gráfkeresés(h))
+#print(mélységi_gráfkeresés(h))
 print("best first")
 print(best_first(h, h.érték), len(best_first(h, h.érték).út()[::-1])-1)
 print('a*')

ora3/sajat.py

@@ -1,46 +0,0 @@
-#a* vagy valami informalt keresovel
-
-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[0] == self.cél or 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: #nem toltunk onmagabol onamagaba
-                    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[j] += 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,2,3), 4)
-
-#print(h3.rákövetkező(h3.kezdő))
-#print(h3.célteszt((2,5,6)))
-                        
-                        
-                        
-                        
-                        
-                        
-                        
-                        
-                        
-                        
-                        
-                            

ora4/8kiralyno.py

@@ -0,0 +1,68 @@
+from keres import *
+
+class kiralyno(Feladat):
+    def __init__(self,ke,c):
+        super().__init__(ke,c)
+        self.S=8
+
+
+    def céltesz(self, állapot):
+        return állapot[self.S] == self.cél
+
+
+    def rákövetkező(self, állapot):
+
+        lépések= list()
+
+        s=állapot[8]
+
+        for i in range(1,9):
+            előfeltétel = True
+            for m in range(1,állapot[self.S]):
+                all=állapot[m-1]
+                abs1=abs(m-s)
+                abs2=abs(i-állapot[m-1])
+                if állapot[m-1] != i and abs(m-s) != abs(i-állapot[m-1]):
+                    előfeltétel = True
+                else:
+                    előfeltétel = False
+                    break
+
+            if előfeltétel:
+                állapot_uj=list(állapot)
+
+                állapot_uj[s-1] =i
+                állapot_uj[8]=állapot_uj[8]+1
+
+                állapot_uj2 = tuple(állapot_uj)
+                lépések.append(állapot_uj2)
+
+        return lépések
+
+    def __str__(self):
+        str=''
+        for i in self.kezdő[:self.S]:
+            if i==0:
+                str += 'x  '*self.S+'\n'
+            else:
+                str += 'x  '*(i-1) + 'Q  ' + 'x  '*(self.S-i)+'\n'
+
+
+        return str
+
+
+
+ha = kiralyno((0,0,0,0,0,0,0,0,1),9)
+
+
+while ha.célteszt(ha.kezdő)==False:
+    print(ha)
+    rakov=ha.rákövetkező(ha.kezdő)
+    if len(rakov)!= 0:
+        print(rakov)
+    else:
+        print('Vége')
+        break
+    lepes=int(input('Adjon meg egy lépést: '))
+    lepes=rakov[lepes-1]
+    ha=kiralyno(lepes,9)

ora4/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;

ora4/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
+