Als jemand, der sich nicht die Mühe macht, auf seine Pentominos zu schauen, um festzustellen, ob sie eine rechteckige Form haben, habe ich beschlossen, dass Sie ein Programm schreiben, das dies tut.

Deine Aufgabe

Entscheiden Sie, ob es sich um eine gültige Lösung handelt, wenn einige Eingaben durch Zeilenumbrüche mit 12 eindeutigen Zeichen unterteilt sind.

Eine gültige Lösung MUSS

• Haben Sie 5 von jedem Zeichen (außer Zeilenumbrüchen)
• Jeder Zeichensatz muss vollständig verbunden sein
• Jeder Zeichensatz muss eine eindeutige Form haben
• Seien Sie in einer regelmäßigen rechteckigen Form

Wenn es sich um eine gültige Lösung handelt, geben Sie einen Wahrheitswert aus, andernfalls einen Falschwert.

Ihr Programm kann eine Funktion oder ein vollständiges Programm sein, muss jedoch die Eingabe von stdin und die Ausgabe von stdout übernehmen.

Testfälle

Gültige Lösungen

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

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

Ungültige Konfigurationen

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 Bytes dank @DankMemes gespart !

Verwendungszweck

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

Erläuterung

Ein paar Anmerkungen zu dieser Lösung:

• Möglicherweise ist diese Antwort nicht gültig. Es wird nicht überprüft, ob gedrehte Pentominos dieselbe Form haben. Ich habe jedoch versucht, aber kein gültiges Pentomino-Rechteck gefunden, das den Anforderungen in den Regeln entspricht und zwei oder mehr derselben gedrehten Form enthält. Aber ich bin kein Pentomino-Experte. Wenn Sie also eine gültige Kombination finden, bei der dies fehlschlägt, lassen Sie es mich wissen.
• Die Regeln erfordern auch Antworten für die Verwendung STDINsowie STDOUTfür die Eingabe und Ausgabe, sind jedoch prompt()nur für die Eingabe in einer einzelnen Zeile vorgesehen. Mein (Windows-) Computer fügt \r\nbeim Einfügen automatisch Zeichen in jede neue Zeile ein, sodass ich sie zu einer Funktion gemacht habe, die eine Zeichenfolge akzeptiert.

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
)