Come qualcuno a cui non si può disturbare a guardare i loro pentominos per vedere se ha una forma rettangolare, ho deciso di farti scrivere un programma che lo fa.

Il tuo compito

Dato un certo input diviso per le nuove righe contenenti 12 caratteri univoci, decidere se si tratta di una soluzione valida.

Una soluzione valida DEVE

• Hai 5 di ogni personaggio (tranne le nuove righe)
• Ogni set di caratteri deve essere completamente collegato
• Ogni set di personaggi deve avere una forma unica
• Essere in una normale forma rettangolare

Se è una soluzione valida, genera un valore di verità, altrimenti genera un valore di falsa.

Il tuo programma può essere una funzione o un programma completo ma deve portare l'input da stdin e l'output a stdout.

Casi test

Soluzioni valide

000111
203331
203431
22 444
2   46
57 666
57769!
58779!
58899!
5889!!

00.@@@ccccF111//=---
0...@@c))FFF1//8===-
00.ttttt)))F1/8888=-

Configurazioni non valide

invalid (doesn't contain 12 unique characters)

111112222233333444445555566666
77777888889999900000qqqqqwwwww (Each set has the same shape)

1234567890qw
w1234567890q
qw1234567890
0qw123456789
90qw12345678 (None of the characters are connected)

1234567890qw (Not 5 characters in every set)

1111122222333334444455555666666
77777888889999900000qqqqqwwwwww (More than 5 characters in some sets)

00
0                   
00.@@@ccccF111//=---
 ...@@c))FFF1//8===-
  .ttttt)))F1/8888=- (Doesn't form a rectangular shape)

JavaScript (ES6), 237 235 222 byte

f=p=>(m=[],s=[],d=0,l=p.indexOf`
`+1,[...p].map((c,i)=>(i+1)%l&&!m[i]?g=d-2<s.indexOf((t=a=>m[a]|p[a]!=c?r=0:(m[a]=y.push(a),n=a<n?a:n,t(a+1)+t(a-1)+t(a+l)+t(a-l)+1))(n=i,y=[])!=5?g=0:s[d++]=y.map(a=>r+=a-n)|r):0),d==12&g)

2 byte salvati grazie a @DankMemes !

uso

f(`000111
203331
203431
22 444
2   46
57 666
57769!
58779!
58899!
5889!!`);
=> true

Spiegazione

Un paio di note su questa soluzione:

• È possibile che questa risposta non sia valida. In realtà non controlla se i pentomino ruotati hanno la stessa forma, tuttavia ho provato ma non sono riuscito a trovare un rettangolo pentomino valido che soddisfi i requisiti delle regole e includa due o più della stessa forma ruotata. Ma non sono un esperto di pentomino, quindi se trovi una combinazione valida con cui fallisce, fammi sapere.
• Le regole richiedono anche risposte per l'uso STDINe STDOUTper l'input e l'output ma prompt()sono progettate solo per l'input a riga singola e il mio computer (Windows) inserisce automaticamente i \r\ncaratteri in ogni nuova riga durante l'incollaggio, quindi l'ho trasformata in una funzione che accetta una stringa.

f=p=>(
  m=[],                      // m = map of checked characters
  s=[],                      // s = list of shapes found (stored as integer)
  d=0,                       // d = number shapes found
  l=p.indexOf`
`+1,                         // l = length of each line (including newline character)
  [...p].map((c,i)=>         // iterate through each character of the input
    (i+1)%l&&                // skip newline characters
      !m[i]?                 // skip the character if it has already been mapped
        g=                   // g = pentomino is valid
          d-2<s.indexOf(     // check if shape already existed before just now
            (t=a=>           // t() checks if character is part of the shape then maps it
              m[a]|          // skip if character is already mapped
                p[a]!=c      //    or if the current character is part of the shape
              ?r=0:(
                m[a]=        // mark the character as mapped
                  y.push(a), // y = list of shape character indices
                n=a<n?a:n,   // n = minimum index of all characters in the shape
                t(a+1)+      // check and map adjacent characters
                t(a-1)+
                t(a+l)+
                t(a-l)+
                1
              )
          )(n=i,y=[])
            !=5?g=0:         // make sure there are only 5 characters in the shape
            s[d++]=          // add the shape to the list
              y.map(a=>      // sum of (index of each character in the shape - minimum
                r+=a-n)|r    //     index) = unique integer representing the shape
        ):0
  ),
  d==12&g                    // ensure there is 12 shapes and return the 'is valid' result
)