Ich übe momentan auf einen Test in dem irgendein Algorithmus implementiert werden muss und gehe dazu alte Aufgaben durch.
Momentan überlege ich mir eine gute Lösung zu folgendem Problem:
Die Zahl 125874 enthält die gleichen Ziffern wie ihr 2-Faches 251748. Es soll die kleinste Zahl gefunden werden, bei der x*1 - x*6 die gleichen Ziffern beinhalten
Ich würde es so angehen, dass ich eine Schleife definiere, die bei n=1000 beginnt und solange eine Bedingung(z) nicht erfüllt ist, laufen lassen.
Bei jedem durchlauf soll n in Variable a und ihr doppeltes in Variable b gespeichert werden. Nun muss ich die einzelnen Ziffern rausbekommen.
Dafür brauch ich Liste 1 und Liste 2.
Ich füge diesen Listen immer das ergebnis von a bzw. b % 10 hinzu, solange a bzw. b >=1 ist (mehr als eine Stelle hat).
Diese sortiere ich (zB. mit Bubblesort) und vergleiche die einzelnen Stellen der Listen.
Wenn dies für alle Listen (natürlich dann eben in 6-Facher ausührung) zutrifft, Bedingung z auf True setzen und die Zahl n zurück geben.
Ich habe es mal laut meinen Vorstellungen wie unten nur für das Doppelte ausgeführt.
Code: Alles auswählen
def bubbleSort(alist):
for passnum in range(len(alist)-1,0,-1):
for i in range(passnum):
if alist[i]>alist[i+1]:
temp = alist[i]
alist[i] = alist[i+1]
alist[i+1] = temp
return alist
def pal():
print("klasdjf")
a1 = []
a2 = []
pal = False
n = 873491
m = 2
while pal != True:
print(n)
a = n
b = n * m
while a > 1 and b > 1:
a1.append(a % 10)
a2.append(b % 10)
a = int(a / 10)
b = int(b / 10)
a1 = bubbleSort(a1)
a2 = bubbleSort(a2)
if a1 == a2:
pal = True
else:
a1 = []
a2 = []
n = n + 1
return n
print(pal())
Ein Weg, das ohne je ein Array für ein Vielfaches zu verwenden, wäre in einer Schleife Prüfen, ob die Bedingung a1 == a2 passt, dann b mit dem m-fachen von a überschreiben und wieder von vorne, bis es für das 6-fache passt. Bin ich da richtig?
Bin für jede Hilfe dankbar.
Edit: Bin auf einen kleinen Fehler gestoßen und hab den Code / meine Frage angepasst.