Pyramidenbauen

Sonstiges Theoretisches
1

Hi ihr :smiley:
Ich bin wieder mit einem neuen Problem da :smiley:
Eine Kiste enthält viele gleifarbige gleichgroße Kugeln. Aus 4 beliebigen Kugeln aus der Kiste wird eine Pyramide auf einem Drehteller gebaut. (Eine oben, unten 3, berühren sich paarweise.)
Nun ist die Frage wieviele unterschiedliche pyramiden gebaut werden können. (Unterschiedlich: 2 Pyramiden kònnen nicht durch drehen des Drehtellers ineinander überführt werden).
Klar, wenn man pro pyramide eine farbe nimmt sinds 5 Pyramiden die gebaut werden können. Bei 2 farben die man nimmt
80. Aber ab 3 wirds dann kompliziert :I
Gibts da ne Formel / gleichung für?

Grüße

2

Interessant sind bei der Aufgabe die Permutationen der unteren 3 Kugeln durch den Drehteller.
Wenn du die Anzahl ausrechnen kannst (für n Farben), musst du die Zahl nur noch mit n multiplizieren (Unterschiedliche Möglichkeiten für die Spitze -> wird durch Rotation nicht verändert).

Stellt man die Kugeln auf dem Drehteller als Liste dar, wäre z.B.

R-B-G (rot, blau, grün)
identisch mit G-R-B
aber nicht mit R-G-B

Eine Formel dafür fällt mir auf die Schnelle allerdings nicht ein.

Gruß

3

Hm… :confused: wirkt mein Kaffee noch nicht?! Gleichfarbige (oder auch „gleifarbige“) Kugeln, und dann doch unterschiedliche Farben?! Wie viele Farben gibt es denn nun?

4

Sry, statt gleichfarbig einfarbig :smiley:

5

Trotzdem kann ich “wenn man pro pyramide eine farbe nimmt sinds 5 Pyramiden” nicht einordnen - oder heißt das gerade, dass es genau 5 Farben gibt?

6

Schande über mich :I
Ja, es sind 5 Farben und man baut immer aus 4 beliebigen Kugeln eine Pyramide. Sry :smiley:

Grüße

7

Nettes Problem. Mit dem Binomialkoeffizienten bekommst du auf jeden Fall einmal die Kombinationsmöglichkeiten der Farben. Das müsstest du dann noch mit der Formel multiplizieren wieviele verschiedene Pyramiden möglich sind wenn man eben eine, zwei, drei, etc. Farben hat.

Die Kombinationsmöglichkeiten der vier Kugeln ist klarerweise davon abhängig wie viele Farben man zur Auswahl hat. Dafür muss jetzt noch eine Formel gefunden werden. Da hab ich kurz überlegt, aber mir ist noch nichts brauchbares dazu eingefallen.

8

Wenn man aus n Elementen k Stück zieht mit Zurücklegen, und die Reihenfolge keine Rolle spielt, gibt es dafür (n+k-1)!/(k!(n-1)!) Möglichkeiten. Hier also für die ersten beiden Kugeln:
(n+k-1)!/(k!(n-1)!)
(5+2-1)!/(2!*(5-1)!)
(6)! / (2! * 4!)
720 / (2 * 24)
15
Jedes dieser Pärchen kann man mit einer weiteren Farbe kombinieren, das müßten dann 75 mögliche “Pyramidenbasen” sein, und alle anderen Kombinationen ergeben sich aus Drehungen daraus.
Auf diese Basen kann man dann noch 5 verschiedene Spitzen setzen, d.h. es müßte 375 Möglichkeiten geben.

9

Hallo Marco13,

die Originalaufgabe lautet: Eine Kiste enthält viele gleich große, einfarbige Kugeln in 5 verschiedenen Farben. Jemand entnimmt der Kiste 4 Kugeln und baut daraus auf einem Drehteller eine Kugelpyramide. Eine solche Pyramide besteht aus 3 unteren Kugeln, welche auf dem Drehteller liegen und einander paarweise berühren, sowie einer oberen Kugel, welche die 3 unteren berührt. 2 Kugelpyramiden gelten als verschieden, wenn sie nicht durch Drehen des Tellers ineinander überführt werden können. Ermittle, wie viele verschiedene Kugelpyramiden sich errichten lassen.
Bist du dir sicher, dass das Ergebnis von 375 Möglichkeiten richtig ist. Warum setzt man in deine Formel nur die ersten beiden Kugeln ein, warum setzt man nicht sofort 4 Kugeln ein. Natürlich kommt dann etwas anderes heraus, aber warum ist dein Rechenweg richtig. In welche Klasse gehst du, dass du die Aufgabe so gut lösen kannst? Ich bin in der 8. Klasse und wir haben Kombinatorik noch gar nicht durchgenommen.

10

Beachte, dass ich meine Formulierungen häufig mit Bedacht wähle. Oder ganz direkt: Da kommt mehrmals das Wort „müßte“ vor, also… NEIN, ich bin mir NICHT sicher, dass es richtig ist.

Wenn man direkt 4 einsetzen würde, wäre das Ergebnis falsch, weil da ja Pyramiden dabei wären, die „dreh-gleich“ sind. Ich habe überlegt, wie man die Drehungen wegnehmen könnte. Da gibt’s sicher auch andere Möglichkeiten, vielleicht auch direktere (irgendwie darauf aufbauend, dass es immer 3 Drehungen gibt oder so…). Und ich habe überlegt, was die (bzg. Drehung) unterschiedlichen Pyramiden ausmacht. Die Spitze ist erstmal egal: Wenn es X „Basen“ gibt, dann gibt’s jede noch mit einer andersfarbigen Spitze, also X5 insgesamt. Wie viele „Basen“ gibt es? Eine Basis besteht aus einer Farbe, die zwei andere Farben berührt. Wenn es also Y zweier-Pärchen gibt, gibt es 5Y Basen. Und… es gibt 15 zweier-Pärchen. Hatte das aber auch nur recht schnell aufgestellt, und bin mir insbesondere nicht sicher, ob die Reihenfolge dieser zweier-Pärchen eine Rolle spielt, aber ich denke, dass nicht. Kann man sich nochmal aufmalen. Aber nicht um diese Uhrzeit :wink:

11

Ich komme ohne Binomialkoeffizienten auf 1100 verschiedene Pyramiden.

Einfarbige Basen (die drei Kugeln, die unten liegen): 5
Zweifarbige Basen (2 gleichfarbige, eine andersfarbige): [tex]5 \cdot 4 = 20[/tex]
Dreifarbig (drei unterschiedlich farbige Kugeln, davon je zwei Permutationen): [tex]5 \cdot 4 \cdot 3 \cdot 2 = 120[/tex]
Aufsummiert und mit einer beliebigen Spitze versehen: [tex]\left( 5 + 20 + 120\right) \cdot 5 = 1100[/tex]

 @Marco13 : du hast noch nicht beantwortet, in welche Klasse du gehst :o)

Edit: 100% sicher bin ich mit mit den dreifarbigen Basen aber auch nicht, es kann sein, dass da einige Kombinationen mehrfach drin vorkommen :wink:

*** Edit ***

Bin mit mittlerweile sicher, dass das mit den drei unterschiedlich farbigen Kugeln nicht passt. Das müsste eher [tex]\frac{5 \cdot 4 \cdot 3}{3}=20[/tex] sein (drei Kugeln mit Beachtung der Reihenfolge, aber drei Permutationen (die Rotationen) als gleich angesehen). Das Endergebnis ändert sich dann auf 225.

12

Oh man,

ich hab ein weiteres Ergebnis in den Raum zu werfen, dass sich von den anderen Unterscheidet.

Habe es mit Clojure mit Hilfe von core.logic gecoded. Core.logic hat mich immer schon interessiert, da tat so ein Anwendungsfall ganz gut.

(ns pyramides.core
  (:use [clojure.core.logic])
  (:require [clojure.core.logic.fd :as fd]))

(defn count-number-of-diff-numbers [coll]  
  (count (set coll)))

(defn all-possibilities []
  (run* [a b c d]
           (fd/in a b c d (fd/interval 1 5))
           (fd/<= b c) 
           (fd/<= b d))) 

(defn map-by-number-of-colors [coll] 
  (map (fn [x] [(count-number-of-diff-numbers x) x]) coll))

Die verschiedenen Farben sind als Zahlen von 1 bis 5 versehen. Mit Farben ginge es wohl auch :slight_smile: dann müsste man alphabetisch sortieren.

Die erste Funktion zählt einfach wieviel verschiedene Farben in einer Kombination vorkommen.
Die zweite Funktion all-possibilites nutzt core.logic, also Logisches Programmieren.
Die verschiedenen Kugelpositionen a (Spitze) und b c d die unteren werden definiert.
Dann werden 3 Constraint bestimmungen gesetzt.
Dann wird festgelegt, dass diesen die Farben (Zahlen) von 1 bis 5 zugeordnet werden dürfen.
Die zwei weiteren Zeilen definieren dass der Drehteller immer soweit gedreht werden muß dass Position b die niedrigste Kugel bestimmt. (b <= c und b <= d)

Das andere ist einfach ein Mapping von den verschiedenen Kombinationen auf ein Tuppel anzahl der Farben und der genauen definition der Pyramide.

Das Ergebnis, Speclj macht echt Spaß, wenn die Testcases automatisch aufgerufen werden.

(ns pyramides.core-spec
  (:require [speclj.core :refer :all]
            [pyramides.core :refer :all]))

(describe "testing pyramides"
  (it "275 pyramides"
      (should= 275 (count (all-possibilities))))
  (it "5 1 colored pyramides"
      (should= 5 (count (filter #(== 1 (first %)) (map-by-number-of-colors (all-possibilities))))))
  (it "80 2 colored pyramides"
      (should= 80 (count (filter #(== 2 (first %)) (map-by-number-of-colors (all-possibilities))))))
  (it "150 3 colored pyramides"
      (should= 150 (count (filter #(== 3 (first %)) (map-by-number-of-colors (all-possibilities))))))
  (it "40 4 colored pyramides"
      (should= 40 (count (filter #(== 4 (first %)) (map-by-number-of-colors (all-possibilities))))))
  (it "0 5 colored pyramides"
      (should= 0 (count (filter #(== 5(first %)) (map-by-number-of-colors (all-possibilities)))))))

Das Ergebnis:
Es gibt danach 275 verschiedene Pyramiden
5 Einfarbige
80 Zweifarbige
150 Dreifarbige
40 Vierfarbige
und 0 Fünffarbige.

Alle Möglichkeiten
[spoiler]

([1 [1 1 1 1]] [2 [2 1 1 1]] [2 [1 2 2 2]] [2 [3 1 1 1]] [2 [1 1 2 1]] [1 [2 2 2 2]] [2 [1 1 1 2]] [2 [1 3 3 3]] [2 [4 1 1 1]] [2 [2 1 2 1]] [3 [1 2 3 2]] [2 [1 1 1 3]] [2 [3 2 2 2]] [2 [2 1 1 2]] [2 [1 1 3 1]] [3 [1 2 2 3]] [2 [2 3 3 3]] [2 [1 4 4 4]] [2 [1 1 2 2]] [2 [5 1 1 1]] [2 [1 1 1 4]] [3 [3 1 2 1]] [2 [2 2 3 2]] [2 [1 1 1 5]] [3 [1 3 4 3]] [3 [2 1 1 3]] [2 [4 2 2 2]] [3 [1 2 2 4]] [3 [3 1 1 2]] [3 [2 1 3 1]] [3 [1 1 2 3]] [3 [1 2 4 2]] [2 [2 2 2 3]] [2 [1 1 4 1]] [1 [3 3 3 3]] [3 [1 3 3 4]] [2 [2 4 4 4]] [3 [1 1 3 2]] [2 [1 5 5 5]] [2 [2 1 2 2]] [3 [1 1 2 4]] [3 [1 2 3 3]] [3 [2 1 1 4]] [3 [1 2 2 5]] [3 [1 1 2 5]] [2 [5 2 2 2]] [3 [4 1 2 1]] [2 [1 1 3 3]] [2 [1 1 5 1]] [2 [3 2 3 2]] [3 [2 1 1 5]] [3 [1 1 4 2]] [3 [2 3 4 3]] [3 [1 1 3 4]] [2 [3 1 1 3]] [3 [1 4 5 4]] [4 [1 2 3 4]] [2 [2 2 2 4]] [3 [1 3 3 5]] [3 [4 1 1 2]] [3 [1 2 5 2]] [3 [1 1 3 5]] [2 [3 1 3 1]] [3 [1 4 4 5]] [3 [2 1 2 3]] [3 [5 1 2 1]] [2 [2 2 4 2]] [2 [3 2 2 3]] [3 [1 3 5 3]] [3 [2 1 4 1]] [3 [1 1 4 3]] [2 [4 3 3 3]] [4 [1 2 4 3]] [3 [2 3 3 4]] [3 [1 1 5 2]] [4 [1 2 3 5]] [2 [3 4 4 4]] [3 [2 1 3 2]] [2 [1 1 4 4]] [2 [2 5 5 5]] [3 [1 1 5 3]] [3 [3 1 2 2]] [3 [2 1 2 4]] [3 [5 1 1 2]] [2 [2 2 3 3]] [3 [1 3 4 4]] [3 [1 1 4 5]] [3 [1 1 5 4]] [3 [3 1 1 4]] [2 [5 3 3 3]] [2 [2 2 2 5]] [2 [1 1 5 5]] [3 [1 2 4 4]] [3 [1 4 5 5]] [3 [2 1 2 5]] [4 [1 2 5 3]] [4 [1 2 4 5]] [4 [1 3 4 5]] [4 [1 2 5 4]] [4 [1 3 5 4]] [3 [2 1 3 3]] [3 [1 2 5 5]] [3 [1 3 5 5]] [3 [2 1 5 1]] [3 [4 2 3 2]] [3 [3 1 1 5]] [3 [2 1 4 2]] [2 [3 3 4 3]] [4 [2 1 3 4]] [3 [4 1 1 3]] [3 [2 4 5 4]] [3 [2 2 3 4]] [3 [3 2 2 4]] [3 [2 3 3 5]] [3 [5 2 3 2]] [2 [2 2 5 2]] [4 [2 1 3 5]] [3 [4 1 3 1]] [3 [2 4 4 5]] [3 [3 1 2 3]] [3 [5 1 1 3]] [3 [3 2 4 2]] [3 [4 2 2 3]] [3 [2 3 5 3]] [3 [3 1 4 1]] [4 [2 1 4 3]] [3 [2 2 4 3]] [2 [3 3 3 4]] [3 [2 1 5 2]] [3 [5 1 3 1]] [3 [2 2 3 5]] [1 [4 4 4 4]] [3 [3 1 3 2]] [3 [2 1 4 4]] [3 [5 2 2 3]] [2 [3 5 5 5]] [4 [2 1 5 3]] [3 [4 1 2 2]] [4 [3 1 2 4]] [2 [3 2 3 3]] [3 [2 3 4 4]] [4 [2 1 4 5]] [2 [5 4 4 4]] [4 [2 1 5 4]] [2 [4 1 1 4]] [3 [5 1 2 2]] [3 [3 2 2 5]] [3 [2 1 5 5]] [2 [2 2 4 4]] [3 [2 4 5 5]] [4 [3 1 2 5]] [3 [2 2 5 3]] [3 [5 1 1 4]] [3 [2 2 4 5]] [4 [2 3 4 5]] [3 [2 2 5 4]] [4 [2 3 5 4]] [2 [3 1 3 3]] [2 [2 2 5 5]] [3 [2 3 5 5]] [3 [3 1 5 1]] [3 [4 1 1 5]] [4 [3 1 4 2]] [2 [4 3 4 3]] [3 [3 1 3 4]] [3 [3 4 5 4]] [2 [5 1 1 5]] [3 [3 2 3 4]] [2 [4 2 2 4]] [3 [5 3 4 3]] [2 [3 3 3 5]] [3 [3 2 5 2]] [3 [3 1 3 5]] [3 [5 2 2 4]] [3 [3 4 4 5]] [4 [4 1 2 3]] [2 [4 2 4 2]] [2 [3 3 5 3]] [2 [4 1 4 1]] [3 [3 1 4 3]] [4 [5 1 2 3]] [3 [3 2 4 3]] [2 [4 3 3 4]] [4 [3 1 5 2]] [3 [5 2 4 2]] [3 [5 1 4 1]] [3 [3 2 3 5]] [3 [5 3 3 4]] [4 [4 1 3 2]] [3 [3 1 4 4]] [2 [4 5 5 5]] [3 [3 1 5 3]] [3 [4 1 2 4]] [4 [5 1 3 2]] [3 [4 2 3 3]] [1 [5 5 5 5]] [2 [3 3 4 4]] [4 [3 1 4 5]] [4 [5 1 2 4]] [4 [3 1 5 4]] [3 [5 2 3 3]] [3 [4 2 2 5]] [3 [3 1 5 5]] [3 [3 2 4 4]] [2 [5 2 2 5]] [3 [3 4 5 5]] [4 [4 1 2 5]] [3 [3 2 5 3]] [3 [5 1 2 5]] [4 [3 2 4 5]] [3 [3 3 4 5]] [4 [3 2 5 4]] [3 [3 3 5 4]] [3 [4 1 3 3]] [3 [3 2 5 5]] [2 [3 3 5 5]] [3 [4 1 5 1]] [3 [5 1 3 3]] [2 [5 1 5 1]] [3 [4 1 4 2]] [3 [4 1 3 4]] [4 [5 1 4 2]] [2 [4 4 5 4]] [4 [5 1 3 4]] [3 [4 2 3 4]] [2 [5 4 5 4]] [3 [4 3 3 5]] [4 [5 2 3 4]] [3 [4 2 5 2]] [2 [5 3 3 5]] [4 [4 1 3 5]] [2 [4 4 4 5]] [2 [5 2 5 2]] [3 [5 1 3 5]] [2 [5 4 4 5]] [3 [4 3 5 3]] [3 [4 1 4 3]] [3 [4 2 4 3]] [2 [5 3 5 3]] [4 [4 1 5 2]] [4 [5 1 4 3]] [4 [5 2 4 3]] [3 [5 1 5 2]] [4 [4 2 3 5]] [3 [5 2 3 5]] [2 [4 1 4 4]] [4 [4 1 5 3]] [3 [5 1 4 4]] [3 [5 1 5 3]] [2 [4 3 4 4]] [3 [4 1 4 5]] [3 [5 3 4 4]] [3 [4 1 5 4]] [3 [5 1 4 5]] [3 [5 1 5 4]] [3 [4 1 5 5]] [2 [4 2 4 4]] [2 [5 1 5 5]] [2 [4 4 5 5]] [3 [5 2 4 4]] [4 [4 2 5 3]] [2 [5 4 5 5]] [3 [5 2 5 3]] [3 [4 2 4 5]] [3 [4 3 4 5]] [3 [4 2 5 4]] [3 [5 2 4 5]] [3 [4 3 5 4]] [3 [5 3 4 5]] [3 [5 2 5 4]] [3 [5 3 5 4]] [3 [4 2 5 5]] [3 [4 3 5 5]] [2 [5 2 5 5]] [2 [5 3 5 5]])

[/spoiler]

[1 [1 1 1 1]] bedeutet hierbei eine Farbe kommt vor und die jeweiligen Kugeln haben jeweils die Farbe 1.

13

Das hat mich jetzt nicht mehr losgelassen, daher habe ich auch noch ein kleines Javaprogrämmchen geschrieben, das die Pyramiden zählt. Ich komme damit auf 225.

@Majora : du hast vielleicht nicht alle doppelten Basen eliminiert. Mag aber auch sein, dass ich mich nochmal irre. Daher hier der Code:


public class Main {
    public static void main(String[] args) {
        Set<Triple> pyramids = new HashSet<Triple>();
        for (int a = 0; a < 5; a++) {
            for (int b = 0; b < 5; b++) {
                for (int c = 0; c < 5; c++) {
                    pyramids.add(new Triple(a, b, c).normalize());
                }
            }
        }
        System.out.println(pyramids.size() * 5);
    }

    private static class Triple {
        private final int a;
        private final int b;
        private final int c;

        public Triple(int a, int b, int c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }

        public Triple normalize() {
            List<Triple> candidates = new ArrayList<Triple>();

            candidates.add(this);
            candidates.add(this.rotate());
            candidates.add(this.rotate().rotate());

            Collections.sort(candidates, new Comparator<test.Main.Triple>() {
                @Override
                public int compare(Triple o1, Triple o2) {
                    if (o1.a < o2.a) return -1;
                    if (o1.a > o2.a) return 1;
                    if (o1.b < o2.b) return -1;
                    if (o1.b > o2.b) return 1;
                    if (o1.c < o2.c) return -1;
                    if (o1.c > o2.c) return 1;
                    return 0;
                }
            });

            return candidates.get(0);
        }

        @Override
        public boolean equals(Object o) {
            if (o == null || getClass() != o.getClass()) return false;

            Triple triple = (Triple) o;

            return a == triple.a && b == triple.b && c == triple.c;
        }

        @Override
        public int hashCode() {
            int result = a;
            result = 31 * result + b;
            result = 31 * result + c;
            return result;
        }

        private Triple rotate() {
            return new Triple(b, c, a);
        }
    }
}```

Die gefundenen Basen:

[1 1 1] [1 1 2] [1 1 3] [1 1 4] [1 1 5] [1 2 2] [1 2 3] [1 2 4] [1 2 5] [1 3 2] [1 3 3] [1 3 4] [1 3 5] [1 4 2] [1 4 3] [1 4 4] [1 4 5] [1 5 2] [1 5 3] [1 5 4] [1 5 5] [2 2 2] [2 2 3] [2 2 4] [2 2 5] [2 3 3] [2 3 4] [2 3 5] [2 4 3] [2 4 4] [2 4 5] [2 5 3] [2 5 4] [2 5 5] [3 3 3] [3 3 4] [3 3 5] [3 4 4] [3 4 5] [3 5 4] [3 5 5] [4 4 4] [4 4 5] [4 5 5] [5 5 5]

14

Ja, hab’s auch noch mal ausimplementiert, und komme dann auf 45 Basen d.h. auch 225 Pyramiden

@Majora :
([1 [1 1 1 1]] [2 [2 1 1 1]] [2 [1 2 2 2]] [2 [3 1 1 1]]** [2 [1 1 2 1]]** [1 [2 2 2 2]] [2 [1 1 1 2]] [2 [1 3 3 3]] [2 [4 1 1 1]] [2 [2 1 2 1]] [3 [1 2 3 2]] [2 [1 1 1 3]] [2 [3 2 2 2]] …
haben die rotationsgleiche Basis, 121 und 112… (und noch weitere)

15

@Marco13 : ich wäre gespannt, wie du das umgesetzt hast. Kannst du deinen Code posten?

16

NEIN! :eek: :wink: Ich hatte das nur schnell hingehackt, mit verschiedenen Anzätzen die ich mal probieren wollte, und mit verschiedenen „Verallgemeinerungen“, die völlig sinnlos sind. Ausgegangen war ich ursprünglich von meinen „Combinatorics“-Utilities (die ich nochmal hier irgendwo posten muss), speziell dem „CombinationIterable“ für Ziehen mit Zurücklegen, und da hab’ ich noch ein paar Methoden im Stil von

    private static <T> boolean equalsRotated(List<T> list0, List<T> list1)
    {
        List<T> current = new ArrayList<T>(list0);
        for (int j=0; j<list0.size(); j++)
        {
            if (current.equals(list1))
            {
                return true;
            }
            current = rotated(current);
        }
        return false;
    }
    
    
    private static <T> List<T> rotated(List<T> list)
    {
        List<T> result = new ArrayList<T>(list.subList(1, list.size()));
        result.add(list.get(0));
        return result;
    }

dazugepfuscht. Da das irgendwann krampfig wurde, hat es mir auch schon in den Fingern gejuckt, die schrecklich nahe liegende Klasse

class Pyramid {
    String top;
    String base0, base1, base2;

    boolean rotationEquivalen(Pyramid other) { ... }
    ...
}

zu erstellen, hab’s aber dann doch gelassen…

17

Jup, da hatte ich zu wenig eliminiert.

testing pyramides

  • 225 pyramides
  • 5 1 colored pyramides
  • 60 2 colored pyramides
  • 120 3 colored pyramides
  • 40 4 colored pyramides
  • 0 5 colored pyramides

Zu anfangs dachte ich bei der Bedingung dass sie auch so aussehen muß wie sie nun aussehen muß. Als ich das dann aufgeschrieben hatte, dachte ich mir dass muß auch einfacher gehen und hab es an einem einfachen Beispiel durchgespielt.

(defn all-possibilities []
  (run* [a b c d]
           (fd/in a b c d (fd/interval 1 5))
           (conde ((fd/<= b c) (fd/<= c d) )
                  ((fd/< b d) (fd/< d c)))))

Das Conde ist ein OR.
Es gibt zwei Fälle die man durch drehen erreichen kann
b <= c <= d
oder
b < d < c

Das Problem war, dass ich bei den “Basen” einmal 112 und auch 121 gezählt habe.
112 trifft auf den ersten Fall zu.
121 trifft weder auf den ersten noch den zweiten zu da
1 < 1 < 2 nicht zutrifft.
und aus 112 kann durch Drehung 121 werden.

Die Bedingung die ich vorher hatte lautete
c >= b <= d, das auf 112 und 121 matcht.

18

@Marco13 : danke für deinen Code, die rotate-Methode war das, was mich am meisten interessierte.
@Majora : deinen Code kann ich nicht lesen :ka: Aber du hast vielleicht gesehen, dass ich deinen in Prosa formulierten Ansatz, die Pyramiden zu normalisieren, übernommen habe. Das mit den zweifarbigen Basen hatte ich als Problem bei dir vermutet, das hätte meiner Rechnung nach aber eine noch größere Abweichung ergeben müssen, daher hatte ich da nichts zu geschrieben.

19

Durch das Wort “dazugepfuscht” wollte ich andeuten, dass man das schon hinterfragen kann. Das war eine der Verallgemeinerungen, von denen ich geredet hatte. Die Methode erstellt eine “rotierte Kopie” einer Liste. Im Vergleich zu einer auf diesen Fall spezialisierten Lösung ist das vielleicht ein Overkill.

20

Hab heute auch in der schule mal geschaut und komme auf 225.
Erklärung kommt später, bin grad mim handy on :slight_smile: