erzeugt eine Schleife, um zu einem bestimmten Ergebnis zu kommen

Ich habe eine Art Gehirn Nebel versucht, die folgende Struktur zu lösen und vielleicht kann jemand bei der Lösung dieses Problems helfen.erzeugt eine Schleife, um zu einem bestimmten Ergebnis zu kommen

10 11 12 00 11 12 13 01 12 13 14 02 13 14 15 03 14 15 16 04 15 16 17 05 

10 11 12 20 11 12 13 21 12 13 14 22 13 14 15 23 14 15 16 24 15 16 17 25 

10 11 12 02 11 12 13 03 12 13 14 04 13 14 15 05 14 15 16 06 15 16 17 07 

10 11 12 22 11 12 13 23 12 13 14 24 13 14 15 25 14 15 16 26 15 16 17 27

Wie würde ein Algorithmus/Satz von Schleifen aussehen, der diese Tabelle generiert? Die Reihenfolge der Erscheinung ist nicht wichtig. Nur alle Bündel von vier Paaren sollten auftauchen. Die Paare müssen tatsächlich einzelne Ziffern sein, d. H. Ein 10 ist ein 1 und ein 0, kein ten!

EDIT: Es gibt sicherlich ein Muster in den Zahlen. Aber ich habe es nicht geschafft, eine geeignete Schleife zu erstellen, um das Muster zu "fangen".

ein Muster in der ersten Reihe ist (wenn nur diese bereits helfen würde, gelöst werden):

x = 1 
i = 0 
xi x(i+1) x(i+2) (x-1)i  x(i+1) x(i+2) x(i+3) (x-1)(i+1) ...

Quelle

2016-11-10 Al_Iskander

Können Sie zeigen, was Sie ausprobiert haben, und auf das Problem hinweisen, mit dem Sie Probleme haben? – glibdud

ist das Hausaufgaben? – RickyA

Warum sind die letzten 2 Gruppen ('16 17 18 26' und' 17 18 19 27') und nicht ('14 15 16 26' und' 15 16 17 27')? Welche Art von Datenstruktur ist diese Tabelle? Ist es nur eine Zeichenfolge oder soll es eine Art Liste sein? –

Dieser Code erzeugt die gewünschten Daten als 3D-Liste von Strings .

a = (0, 0), (2, 0), (0, 2), (2, 2) 
b = 10, 11, 12 
result = [ 
    [ 
     [str(i + j) for j in b] + [str(u) + str(v+i)] for i in range(6) 
    ] for u, v in a 
] 

# Display the resulting list in a relatively compact way  
for row in result: 
    print([' '.join(u) for u in row])

Ausgang

['10 11 12 00', '11 12 13 01', '12 13 14 02', '13 14 15 03', '14 15 16 04', '15 16 17 05'] 
['10 11 12 20', '11 12 13 21', '12 13 14 22', '13 14 15 23', '14 15 16 24', '15 16 17 25'] 
['10 11 12 02', '11 12 13 03', '12 13 14 04', '13 14 15 05', '14 15 16 06', '15 16 17 07'] 
['10 11 12 22', '11 12 13 23', '12 13 14 24', '13 14 15 25', '14 15 16 26', '15 16 17 27']

Wenn diese Paare tatsächlich sollen Paare von ganzen Zahlen sein müssen wir eine etwas andere Strategie:

from pprint import pprint 

a = (0, 0), (2, 0), (0, 2), (2, 2) 
b = 10, 11, 12 
result = [ 
    [ 
     [divmod(i + j, 10) for j in b] + [(u, v+i)] for i in range(6) 
    ] for u, v in a 
] 

pprint(result)

Ausgang

[[[(1, 0), (1, 1), (1, 2), (0, 0)], 
    [(1, 1), (1, 2), (1, 3), (0, 1)], 
    [(1, 2), (1, 3), (1, 4), (0, 2)], 
    [(1, 3), (1, 4), (1, 5), (0, 3)], 
    [(1, 4), (1, 5), (1, 6), (0, 4)], 
    [(1, 5), (1, 6), (1, 7), (0, 5)]], 
[[(1, 0), (1, 1), (1, 2), (2, 0)], 
    [(1, 1), (1, 2), (1, 3), (2, 1)], 
    [(1, 2), (1, 3), (1, 4), (2, 2)], 
    [(1, 3), (1, 4), (1, 5), (2, 3)], 
    [(1, 4), (1, 5), (1, 6), (2, 4)], 
    [(1, 5), (1, 6), (1, 7), (2, 5)]], 
[[(1, 0), (1, 1), (1, 2), (0, 2)], 
    [(1, 1), (1, 2), (1, 3), (0, 3)], 
    [(1, 2), (1, 3), (1, 4), (0, 4)], 
    [(1, 3), (1, 4), (1, 5), (0, 5)], 
    [(1, 4), (1, 5), (1, 6), (0, 6)], 
    [(1, 5), (1, 6), (1, 7), (0, 7)]], 
[[(1, 0), (1, 1), (1, 2), (2, 2)], 
    [(1, 1), (1, 2), (1, 3), (2, 3)], 
    [(1, 2), (1, 3), (1, 4), (2, 4)], 
    [(1, 3), (1, 4), (1, 5), (2, 5)], 
    [(1, 4), (1, 5), (1, 6), (2, 6)], 
    [(1, 5), (1, 6), (1, 7), (2, 7)]]]

Hier ist eine Variation der zweiten Lösung, die „traditionelle“ for-Schleifen statt verschachtelte Liste Comprehensions verwendet. Hoffentlich ist es ein wenig leichter zu lesen. :)

a = (0, 0), (2, 0), (0, 2), (2, 2) 
b = 10, 11, 12 
result = [] 
for u, v in a: 
    row = [] 
    for i in range(6): 
     row.append([divmod(i + j, 10) for j in b] + [(u, v+i)]) 
    result.append(row)

Die integrierte Funktion in divmod Teilung und die Modul auf seinen Argumenten durchführt, so dass, wenn a und b ganze Zahlen sind, ist zu divmod(a, b)a // b, a % b äquivalent. Wenn x eine zweistellige Ganzzahl ist, gibt 'divmod (x, 10) ein Tupel zurück, das diese zwei Ziffern enthält.

Quelle

2016-11-10 14:47:13

Dieses Ergebnis ist über das, was ich gesucht habe. Aber ich verstehe den Code noch nicht. Ich muss graben. –

@Al_Iskander Ich werde eine Variante der 2. Lösung hinzufügen, die "traditionelle" for-Schleifen verwendet, die ein wenig einfacher zu verstehen sind. –

perfekt. sehr hilfreich. Danke vielmals –

Ich habe mit einem effizienten Algorithmus für dieses Problem kommen :)

for row in range(4): 
    extra = 0 
    if row >= 2: 
     extra = 2 
    for column in range(6): 
     print(10+column, 11+column, 12+column, str(2*(row%2))+"."+str(column + extra), end = " ") 
    print()

Denken Wie eine Tabelle möchten Sie Zeile für Zeile und dann Spalte für Spalte durcharbeiten. Ich benutzte die Spalte und die Zeile in dem Algorithmus, um zu bestimmen, was die Zahlen sollten

einen Kommentar hinzufügen, wenn es etwas gibt, die Sie nicht verstehen :)

Quelle

2016-11-10 14:39:18

Danke. Das Ergebnis ist in die richtige Richtung. Aber @PM 2Rings Antwort adressiert das Problem mit den Ziffern direkter. –

kein Problem :) –

erzeugt eine Schleife, um zu einem bestimmten Ergebnis zu kommen

Antwort

Verwandte Themen