Wie Sie höchstwahrscheinlich jetzt wissen, gibt es 2339 Lösungen für Pentomino-Rätsel in einem 6x10-Raster. Es gibt verschiedene Markierungsschemata für die 12 Pentominos. Zwei davon sind in der folgenden Abbildung dargestellt:

Bildnachweis: Wikipedia

Für die Zwecke der aktuellen Aufgabe werden wir sagen, dass eine normalisierte Pentominolösung eine Lösung ist, die das zweite Markierungsschema (Conways) verwendet.

Beispiel:

O O O O O S S S Z Z
P P R R S S W W Z V
P P P R R W W Z Z V
U U X R T W Y V V V
U X X X T Y Y Y Y Q
U U X T T T Q Q Q Q

Das Stück mit 5 Quadraten in einer Reihe wird Olaut Schema mit Buchstaben bezeichnet . Gleiches gilt für alle Teile.

Aufgabe:

Bei einer Lösung für das 6x10-Pentomino, bei der die Teile mit einem zufälligen Schema gekennzeichnet sind, normieren Sie es so, dass alle Teile in Conways Kennzeichnungsschema gekennzeichnet sind. Sie müssen die Teile erkennen und jedes Quadrat eines bestimmten Teils mit dem Symbol des Teils markieren.

Eingang:

Die zu normalisierende Lösung in jedem für Sie passenden Format, zum Beispiel:

• Eine mehrzeilige Zeichenfolge

• Eine Liste von Zeichenfolgen

• Eine Liste mit Listen von Zeichen

und so weiter

Ausgabe:

Dieselbe Lösung (alle Positionen und Ausrichtungen der Teile bleiben erhalten), aber jedes Teil wird gemäß dem Beschriftungsschema von Conway beschriftet. Hinweis: Die Ausgabe MUSS als 6x10-Zeichenraster gedruckt werden. Führende und nachfolgende Zeilenumbrüche und Leerzeichen sind zulässig. Sie können auch ein Leerzeichen zwischen den Zeichen (aber keine Leerzeilen) drucken, wie im obigen Beispiel.

Testfälle:

1. Eingabe:

6623338888
6222344478
66A234BB70
1AAA94B770
11A99BB700
1199555550

Ausgabe:

UURTTTQQQQ
URRRTVVVSQ
UUXRTVZZSY
PXXXWVZSSY
PPXWWZZSYY
PPWWOOOOOY

2. Eingabe:

45ookkkk00
455ooogk00
4a55gggdd0
4aaa3gnnd.
4am333ndd.
mmmm3nn...

Ausgabe:

OWSSQQQQPP
OWWSSSRQPP
OTWWRRRUUP
OTTTXRZZUV
OTYXXXZUUV
YYYYXZZVVV

Gewinnkriterien:

Die kürzeste Lösung in Bytes in jeder Sprache gewinnt. Lassen Sie sich von den Golfsprachen nicht entmutigen. Erklärungen zu den Algorithmen und Implementierungen sind willkommen.

APL (Dyalog Classic) , 54 53 50 Bytes

⍴⍴{'OXRYTPZQUWSV'[⌊5÷⍨⍋⍋,{×/+⌿↑|(⊢-+/÷≢)⍸⍵}¨⍵=⊂⍵]}

Probieren Sie es online!

Berechnen Sie eine Invariante für jedes Pentomino in der Eingabe: Messen Sie (∆x, ∆y) von jedem seiner Quadrate bis zu seinem Schwerpunkt, nehmen Sie abs (∆x) und abs (∆y), addieren Sie die x-Komponenten und separat das y Komponenten und multiplizieren Sie die beiden Summen. Dies ergibt 12 unterschiedliche Ergebnisse. Dann finden Sie den Index der Invarianten jedes Pentominos in der sortierten Sammlung aller Invarianten. Ersetzen Sie 0 durch 'O', 1 durch 'X', 2 durch 'R'usw.

Jelly , 37 Bytes

ŒĠZÆmạƊ€ḅı§AỤỤị“æṂ⁾+’Œ?¤+78Ọ,@FQṢƊyⱮY

Ein vollständiges Programm, das eine Liste von Zeichenfolgen erstellt (weil wir drucken müssen - andernfalls entfernen Sie die nachfolgenden Zeichenfolgen Y und Sie haben eine Monade, die eine Liste von Zahlen- oder Zeichenlisten erstellt, die eine Liste von Zeichenlisten zurückgibt).

Probieren Sie es online!

Wie?

Ich glaube, dies funktioniert mit der gleichen Kategorisierung von Pentominos wie die APL-Lösung von ngn , wenn auch auf etwas andere Weise (ich kenne APL auch nicht, daher bin ich mir nicht sicher, wie ähnlich die Methode jenseits der Kategorisierung ist).

(Beachten Sie, dass dies “æṂ⁾+’Œ?¤+78Ọnur eine Ein-Byte-Speicherung ist “XRPTZWUYSVQO”!)

ŒĠZÆmạƊ€ḅı§AỤỤị“æṂ⁾+’Œ?¤+78Ọ,@FQṢƊyⱮY - Main Link: list of lists of characters L
ŒĠ                                    - group multidimensional indices by value
      Ɗ€                              - last three links as a monad for €ach i.e. f(x):
  Z                                   -   transpose x
   Æm                                 -   mean (vectorises) (i.e. the average of the coordinates)
     ạ                                -   absolute difference with x (vectorises) (i.e. [dx, dy])
         ı                            - square root of -1 (i)
        ḅ                             - convert from base (vectorises) (i.e a list of (i*dx+dy)s)
          §                           - sum each
           A                          - absolute value (i.e. norm of the complex number)
            Ụ                         - grade up (sort indices by value)
             Ụ                        - grade up (...getting the order from the result of A back,
                                      -              but now with one through to 12)
                       ¤              - nilad followed by links as a nilad:
               “æṂ⁾+’                 -   base 250 literal = 370660794
                     Œ?               -   permutation@lex-index = [10,4,2,6,12,9,7,11,5,8,3,1]
              ị                       - index into
                        +78           - add seventy-eight
                           Ọ          - cast to characters (character(1+78)='O', etc...)
                                 Ɗ    - last three links as a monad (i.e. f(L)):
                              F       -   flatten
                               Q      -   de-duplicate
                                Ṣ     -    sort
                            ,@        - pair (with sw@pped @rguments) (giving a list of 2 lists)
                                   Ɱ  - Ɱap across L with:
                                  y   -   translate i.e. swap the letters as per the the pair)
                                    Y - join with new lines
                                      - implicit print

Wolfram Language (Mathematica) , 103 Byte

""<>Riffle[(t=#)/.Thread[SortBy[Union@@t,Tr@Kurtosis@Position[t,#]&]->Characters@"UPSWZVRTQXYO"],"\n"]&

Nimmt die Eingabe als Liste von Zeichenlisten.

Probieren Sie es online!

Die Hauptidee dabei ist, dass wir für jedes Zeichen in der Eingabe die Koordinaten finden, wo es auftritt, die Kurtosis nehmen und seine Koordinaten summieren. Dies gibt uns eine Invariante für jedes Stück.

(Die Kurtosis ist ein meist irrelevanter Operator aus der Statistik - der Schlüssel ist, dass sie bei der Translation invariant ist, während Reflexion und Rotation die Reihenfolge der Koordinaten höchstens ändern können. Wir addieren die Koordinaten, sodass sich die Invariante nie ändert.)

Abgesehen von der seltsamen Invariante ähnelt diese Lösung den anderen: Wir sortieren die Zeichen und die Teile nach jeder Invariante und ersetzen dann jedes Zeichen durch das entsprechende Zeichen aus "UPSWZVRTQXYO": den Teilen, sortiert nach Kurtosis-Summe.

Schließlich ""<>Riffle[...,"\n"]ist der Print-as-a-Grid-Code.

Python 2 , 191 Bytes

def y(o):print"".join(['XPRTWZUYSVQO\n'[[w for v,w in sorted([sum(abs(u-sum(t)/5)for t in[[complex(r%11,r/11)for r,q in enumerate(o)if q==p]]for u in t),p]for p in o)].index(x)/5]for x in o])

Probieren Sie es online!

Nimmt eine mehrzeilige Zeichenfolge mit einer nachgestellten Zeile und führt sechs verschachtelte Listenerfassungen durch.

Ungolfed Version

def pentomino_normalizer(input_string):
    # input_string is a multi-line string with a trailing newline

    results = []  # For saving the results of the for loop
    for current_char in input_string:
        # current_char = p in the golfed version

        # The python data type complex stores a real and a imaginary value and
        # is used for storing the x and y coordinates.
        # In the end, the positions list contains a complex number for every
        # occurence of current_char in the string
        # positions_list = t in the golfed version
        positions_list = [complex(i % 11, i / 11) for i, c
                          in enumerate(input_string) if c == current_char]
        # average_pos is the midpoint of all occurences of current_char, 
        # to get rid of translations
        average_pos = sum(positions_list)/5
        # Calculates a value for each tile that is invariant under 
        # translations and rotations,
        # simply the sum of all the distances between the midpoint
        # and the positions
        invariant = sum(abs(pos - average_pos) for pos in positions_list)

        # Saves the invariant value to a list
        results.append(invariant, current_char)

    # This new list contains the characters occuring in the string, sorted
    # by the invariant value. Because this was done with each char in the 
    # input string, this lists contains every value five times and also 
    # contains six newlines
    # at the end of the list
    sorted_results = [w for v, w in sorted(results)]

    # This code snippet maps each char from the input string to its according
    # output and prints to stdout
    chars = ['XPRTWZUYSVQO\n'[sorted_results.index(c)/5] for c in input_string]
    print "".join(chars)