Piastrellatura più semplice del pavimento

Dovresti scrivere un programma o una funzione che riceva una stringa che descriva il pavimento come input e output o restituisca l'area della meta-piastrellatura più semplice che potrebbe creare il modello dato del pavimento.

Il pavimento fa parte di una griglia quadrata. Ogni quadratino è colorato in azzurro o nero (rappresentato da ae bnell'input).

Un esempio di pavimento:

  aaaa
ababab
aaaaa

Una meta-piastrellatura

• è costruito da un Nby Mrettangolare meta-piastrelle di quadrati azzurre e nere
• le meta-tessere utilizzate sono identiche alla traduzione (non è possibile ruotarle o rispecchiarle)
• se i lati di due meta-tessere sono collegati, dovrebbero connettersi per tutta la loro lunghezza (cioè meta-tessere affiancare lo spazio in modo simile a una griglia)

Una meta-piastrella di esempio:

ba
aa

e la meta-piastrellatura da essa creata:

       .
       .
       .
    babababa
    aaaaaaaa
... babababa ...
    aaaaaaaa    
    babababa
    aaaaaaaa
       .
       .
       .

Questa meta-piastrellatura crea il piano mostrato in alto come mostrano le lettere a sinistra:

       .
       .
       .
    ********
    ***aaaa*
... *ababab* ...
    *aaaaa**    
    ********
    ********
       .
       .
       .

Una meta-piastrellatura è più semplice di un'altra se l'area della sua meta-piastrella è più piccola. Il nostro esempio ha un'area di 2*2 = 4cui è il più piccolo possibile per il piano di esempio. Quindi l'output dovrebbe essere 4per l'esempio.

Ingresso

• Una stringa composta dai caratteri a b spacee newlinecontenente almeno uno ao b.
• Le lettere ( ab) formano una forma a 4 connessioni (affiancate).
• Non ci saranno spazi non necessari nella parte anteriore delle righe, cioè ci sarà almeno una riga che inizia con ao b.

• Puoi scegliere tra due formati di input:

  • Nessuno spazio bianco non necessario alla fine delle righe (come mostrato negli esempi).
  • Spazi sul lato destro delle righe per rendere tutte le righe della stessa lunghezza della riga più lunga.

• Il trascinamento di newline è facoltativo.

Produzione

• Un singolo numero intero, l'area della più piccola possibile meta-piastrella la cui piastrellatura contiene il piano di input.

Esempi

Gli esempi sono delimitati da trattini. Le tre parti di un esempio sono input, output e una delle possibili meta-tessere più piccole.

a

1

a
-----------------
 aaaa
aaa
a

1

a
-----------------
aabaab
abaa
aaba

6

aab
aba
-----------------
aabaab
a  a a
aabab

18

aabaab
aaaaaa
aababa
-----------------
ba
aaab

8

baaa
aaab
-----------------
 aaaa
ababb
aaaa

10

aaaaa
ababb
-----------------
 a aa
ab ba
 aba

6

aa
ab
ba
-----------------
 aaaa
abab
aaaa

4

aa
ab
-----------------
ba
 ba
  b

4

ba
ab
-----------------
baa
aba
aab

9

baa
aba
aab
-----------------
 aaaa
aabaa
aaaa

6

aaa
aab

Questo è il codice golf, quindi vince l'ingresso più breve.

C - 208 byte

w,q,n,m,r,g,u;t(char*f){for(w=0;f[w++]-10;);for(q=1;;q++)for(n=1;m=q/n,n<=q;++n)if(n*m==q){char t[q];bzero(t,q);r=q;for(g=0;f[g];++g){u=g/w%m*n+g%w%n;r=t[u]+f[g]-195?r:0;if(f[g]&64)t[u]=f[g];}if(r)return r;}}

Codice equivalente prima del golf:

#include <stdio.h>
#include <strings.h>

int t(char* f) {
    int w = 0;
    for ( ; f[w++] - 10; );

    for (int q = 1; ; q++) {
        char t[q];
        for (int n = 1; n <= q; ++n) {
            int m = q / n;
            if (n * m == q) {
                bzero(t, q);
                int r = q;
                for (int g = 0; f[g]; ++g) {
                    int u = g / w % m * n + g % w % n;
                    if (t[u] + f[g] == 195) {
                        r = 0;
                    }
                    if (f[g] & 64) {
                        t[u] = f[g];
                    }
                }
                if (r) {
                    return r;
                }
            }
        }
    }
}

L'algoritmo è una forza abbastanza bruta, quindi dovrebbe essere ragionevolmente ovvio come funziona in base al codice. Ecco comunque alcuni commenti:

• Ci si aspetta che l'input abbia la forma con spazi finali in modo che tutte le linee abbiano la stessa lunghezza.
• Il primo ciclo trova la larghezza cercando il primo carattere di nuova riga.
• Il loop esterno supera le dimensioni dei meta-tile candidati q. Esce con un returnquando una meta-piastrella può coprire il pavimento. Si noti che il loop non necessita di un'altra condizione di uscita poiché esiste sempre una soluzione (il caso peggiore è la dimensione dell'input).
• Il primo ciclo nidificato e il seguente ifenumera le combinazioni larghezza / altezza del meta-tile valide per dimensione q.
• Una matrice di caratteri che corrisponde alla dimensione del meta-tile candidato viene inizializzata con zero.
• L'anello interno scorre su tutte le piastrelle del pavimento.
• u è l'indice nella meta-piastrella che corrisponde alla piastrella per pavimento.
• Se sia la piastrella per pavimento che la piastrella per meta-piastrella sono ao bdiverse (somma dia = 97 e b = 98è 195), si verifica una mancata corrispondenza e la dimensione della piastrella con le dimensioni tentate non funzionerà.
• Altrimenti, se la piastrella è a o b, il colore della piastrella viene copiato nella meta-piastrella candidata.
• Restituisce la dimensione del meta-riquadro quando è stata effettuata una corrispondenza corretta, ovvero se la corrispondenza tentata non è stata contrassegnata come non riuscita.

Codice test utilizzato:

#include <stdio.h>

extern int t(char* s);

int main()
{
    printf("%d\n", t(
        "a\n"
    ));
    printf("%d\n", t(
        " aaaa\n"
        "aaa  \n"
        "a    \n"
    ));
    printf("%d\n", t(
        "aabaab\n"
        "abaa  \n"
        "aaba  \n"
    ));
    printf("%d\n", t(
        "aabaab\n"
        "a  a a\n"
        "aabab \n"
    ));
    printf("%d\n", t(
        "ba  \n"
        "aaab\n"
    ));
    printf("%d\n", t(
        " aaaa\n"
        "ababb\n"
        "aaaa \n"
    ));
    printf("%d\n", t(
        " a aa\n"
        "ab ba\n"
        " aba \n"
    ));
    printf("%d\n", t(
        " aaaa\n"
        "abab \n"
        "aaaa \n"
    ));
    printf("%d\n", t(
        "ba \n"
        " ba\n"
        "  b\n"
    ));
    printf("%d\n", t(
        "baa\n"
        "aba\n"
        "aab\n"
    ));
    printf("%d\n", t(
        " aaaa\n"
        "aabaa\n"
        "aaaa \n"
    ));
    return 0;
}

Produzione:

1
1
6
18
8
10
6
4
4
9
6