I miei figli hanno un tappetino con cui giocare, qualcosa del genere:

Dopo mesi con le tessere del tappetino posizionate casualmente, mi sono stancato e ho posizionato tutte le tessere del tappetino raggruppate per sezioni in base al colore di sfondo. Quindi, se le lettere rappresentano il colore di sfondo, ho un tappetino come questo:

AABBCDDDE
ABBCCCDEE
ABCCCCDDE
AACCCDDEE
AAAACCCCE
AAAAAACCC

Quindi, per i colori A, B, C, D ed E c'è sempre un modo per collegare tutte le tessere con lo stesso colore di sfondo sia in orizzontale che in verticale nel supporto. Questo è quello che chiamo un tappetino correttamente raggruppato per colore . Puoi vedere i gruppi per l'esempio precedente nelle seguenti tabelle:

AA
A
A
AA
AAAA
AAAAAA

  BB
 BB
 B

    C
   CCC
  CCCC
  CCC
    CCCC
      CCC

     DDD
      D
      DD
     DD

        E
       EE
        E
       EE
        E

Inoltre, esiste un solo gruppo per ogni colore, quindi questo non sarebbe valido:

ABA
ABA

Perché le tessere di colore A non sono raggruppate in un solo gruppo. Anche questo non sarebbe valido perché i riquadri non si collegano né in orizzontale né in verticale:

AB
BA

La sfida

Dato un array bidimensionale di caratteri nell'intervallo ASCII stampabile (non è necessario che sia quadrato se le dimensioni di entrambe le dimensioni sono uguali o maggiori di 1), verificare se l'array rappresenta un tappetino correttamente raggruppato per colore (ogni carattere diverso nell'array rappresenta un colore diverso). L'input può essere in qualsiasi formato ragionevole purché rappresenti un array di caratteri bidimensionale (array di caratteri 2D, array di stringhe della stessa lunghezza e così via) e l'output deve essere una coppia di valori di verità e falsità (0 / 1, 't' / 'f', vero / falso, qualunque cosa fintanto che viene restituito qualcosa e i valori di ritorno sono coerenti tra gli input).

Questo è code-golf, quindi può vincere il programma / funzione / metodo / lambda più breve per ogni lingua!

Esempi

A    truthy

AB
AB   truthy

AB
BA   falsey

ABCDE    truthy

ABCDC    falsey

**::dd22
***:d222
*:::::22    truthy

$$$%%%&&
$$%%&&&&
&&$$$%&&    falsey

AABBCDDDE
ABBCCCDEE
ABCCCCDDE
AACCCDDEE
AAAACCCCE
AAAAAACCC   truthy

AABB
ABBA
AAAA    truthy

AAAB
AAAA
AAAA    truthy

Il mio tappetino correttamente raggruppato per colore

(Devo ancora correggere quei bordi ...)

MATL , 16 15 byte

1e"G@=4&1ZI1>vzg

L'input è un array di caratteri 2D (con righe separate da ;). L'output è 0se l'input si qualifica o 1meno.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Il codice controlla essenzialmente se ogni carattere nell'input ha un solo componente connesso, considerando la 4-connettività (cioè senza diagonali).

I caratteri ripetuti vengono elaborati ripetutamente (che è più golfoso della deduplicazione).

1e       % Implicit input. Reshape into a row vector of chars
"        % For each char
  G      %   Push input again
  @      %   Push current char
  =      %   Equal (element-wise)? Gives a matrix of zeros and ones, where one
         %   represents the presence of the current char
  4      %   Push 4. This will indicate 4-connectivity
  &1ZI   %   Matrix with labels of connected componnents. Inputs are a number (4)
         %   to indicate connectivity, and a binary matrix. The output is a matrix
         %   the same size as the input where each connected componnent of ones
         %   in the input is replaced by a different integer starting at 1
  1>     %   Greater than 1 (element-wise)? The result is a matrix. If the result 
         %   is true for some entry the input doesn't qualify
  v      %   Concatenate vertically with results from previous iterations
  z      %   Number of nonzero/true values
  g      %   Logical. Converts nonzero to true
         % Implicit end. Implicit display. False / true are displayed as 0 / 1

Befunge-93, 317 byte

Modifica: risolto per il corretto conteggio dei byte. Inoltre potrebbe essere ulteriormente giocato a golf

93+:10pv  +93p01+1g01_  v@.1<
gp00g1+>00p~1+:93+`!#^_1-00g10
50p93+:vv_v#!:gg03:p02:<>40p#
!`g01: <>\ 1+:vvp05:+<@^p03_^#
v93$_v# !- g00<4v04g<^1<vp06:<
>+\!\>\ 3v> 40v0>g-v^<.g>:70vp
07_v#:<^ >#+0# g#\<  10\v4gg<^
!#v _$^  g03p <\ v1_#:^5>0g  -
   <    ^ g02p1< >-:#^_^#:g05
-1<   ^p\g06\0\+1:\g06\-1:\g06:\+1g06:g07

Stampa 1 come verità, 0 come falsità

Provalo online

Ecco una visualizzazione del percorso seguito dal puntatore

Nota: questo è per una versione precedente

Come funziona

Ecco alcuni pseudocodici veloci e sporchi

a = 2Darray() # from 12,12 down and to the right
arrayLocation = 12
x = arrayLocation #stored at 0,0
y = arrayLocation #stored at 1,0
i = input()       #stored in the stack
while (i != 0):
    if (i == 10):
        y++
        x = init
    else
        a[x][y] = i
        x++
    i = input

new.x = init    #stored at 2,0
new.y = init    #stored at 3,0

currentChar = 0    #stored at 4,0
chars = array()    #stored at 1,1 onwards
charnum = 0        #stored 5,0
ToCheck = array()  #stored in the stack

current.x = null   #stored at 6,0
current.y = null   #stored at 7,0

while (new.y < y):
    if (a[new] != 0)
        currentChar = a[new]
        toCheck[] = new
        while (toCheck)
            current = toCheck.pop()
            if (a[current] == currentChar)
                toCheck.append(adjacent(current))
                a[current] = 0
        foreach (chars as char)
            if (char == currentChar)
                return 0
        charNum++
        chars[charNum] = char
    new.x++
    if (new.x > x)
        new.x = init
        new.y++

return 1

Fondamentalmente, dopo aver memorizzato l'input, passa attraverso tutto, controllando ogni spazio. Quando trova uno spazio con un personaggio, aggiunge le coordinate alla pila. Quindi controlla ricorsivamente gli spazi attorno ad esso per lo stesso personaggio, impostando ogni spazio su 0. Quando ha esaurito la sezione di quel personaggio, controlla se quel personaggio ha già avuto una sezione. In tal caso, restituire 0. In caso contrario, aggiungerlo alla matrice di caratteri. Una volta che ha attraversato l'intera griglia senza duplicati, restituisce 1.

Per le persone che hanno familiarità con Befunge, ecco una versione distanziata del codice

96+:10p    v    +69p01+1g01_v
`+96:+1~p00<+1g00pg01g00-1_^#
v                           <
>40p50p96+:v                ^
v    @.1<  >
>:10g `#^_30p:20p:30gg:#v_$>1+:00g-!#v_0   >30g+
v                       <  ^         >$96+1^
>40p30gv                   ^
       >:!#v_70p:60p:70gg40 g-!#v_$>
           v               ^     > ^
1:\g06\+1:g 07\g07\-1:\g07\ +1: <^p\g06\0\-
v          <               ^
>50gv   >5\g1+:50p40g\1p20g^
    >:!#^_:1g40g-!#v_1-
                   >0.@

J, 66 byte

c=.1=+/@,+.]-:]*[:*@+/((,|."1)0,.1 _1)&(|.!.0)
[:*/[:c"2[="_ 0~.@,

cdefinisce un verbo che indica se una matrice di uno e zero è c onnected. Tratta quelli singleton come un caso speciale di vero. Altrimenti prende un conteggio ortogonale vicino di ogni cella, quindi il segno di quel conteggio, quindi lo moltiplica per la matrice originale: se quel prodotto è uguale alla matrice originale, allora è collegato.

Il conteggio dei vicini si ottiene spostando in tutte e 4 le direzioni, quindi sommando. Lo spostamento in 4 direzioni è ottenuto usando la funzione " x-arg can by a table" di rotazione / spostamento|.

Infine, la risposta stessa è stata ottenuta creando una matrice one / zero per ogni elemento univoco ~. dell'input e assicurando quindi che tutte queste matrici siano connesse. Questo è il verbo nella seconda riga.

Provalo online!

JavaScript (ES6), 114 byte

Accetta input come una matrice di stringhe. Restituisce 0o 1.

a=>(C={},F=x=>!C[c=a[y][x]]|(g=v=>(a[y+v]||[])[x]==c)(-1)|g(1)|g(0,x--)|g(0,x+=2)?a[y+=!c]?F(C[c]=c?x:0):1:0)(y=0)

Casi test

let f =

a=>(C={},F=x=>!C[c=a[y][x]]|(g=v=>(a[y+v]||[])[x]==c)(-1)|g(1)|g(0,x--)|g(0,x+=2)?a[y+=!c]?F(C[c]=c?x:0):1:0)(y=0)

console.log(f([ // 1
  "A"
]))

console.log(f([ // 1
  "AB",
  "AB"
]))

console.log(f([ // 0
  "AB",
  "BA"
]))

console.log(f([ // 1
  "ABCDE"
]))

console.log(f([ // 0
  "ABCDC"
]))

console.log(f([ // 1
  "**::dd22",
  "***:d222",
  "*:::::22"
]))

console.log(f([ // 0
  "$$$%%%&&",
  "$$%%&&&&",
  "&&$$$%&&"
]))

console.log(f([ // 1
  "AABBCDDDE",
  "ABBCCCDEE",
  "ABCCCCDDE",
  "AACCCDDEE",
  "AAAACCCCE",
  "AAAAAACCC"
]))

console.log(f([ // 1
  "AABB",
  "ABBA",
  "AAAA"
]))

console.log(f([ // 1
  "AAAB",
  "AAAA",
  "AAAA"
]))

Formattato e commentato

a => (                            // given an array of strings a
  C = {},                         // C = object holding encountered characters
  F = x =>                        // F = recursive function taking x:
    !C[c = a[y][x]]               //   c = current character; is it a new one?
    | (g = v =>                   //   g = helper function taking v
        (a[y + v] || [])[x] == c  //       and testing whether a[y + v][x] == c
      )(-1)                       //   test a[y - 1][x]
    | g(1)                        //   test a[y + 1][x]
    | g(0, x--)                   //   test a[y][x - 1]
    | g(0, x += 2) ?              //   test a[y][x + 1]; if at least one test passes:
      a[y += !c] ?                //     increment y if c is undefined; if a[y] exists:
        F(C[c] = c ? x : 0)       //       update C, update x and do a recursive call
      :                           //     else:
        1                         //       all characters have been processed -> success
    :                             //   else:
      0                           //     invalid character detected -> failure
)(y = 0)                          // initial call to F, starting with x = y = 0

Wolfram Language (Mathematica) , 96 byte

And@@(ConnectedGraphQ@Subgraph[GridGraph@Dimensions[t],Tr/@Position[c,#]]&/@(c=Join@@(t=#)))&

Provalo online!

Accetta input come un elenco di caratteri 2D: ad esempio {{"A","B"},{"C","D"}},.

Il  personaggio è \[Transpose].

Come funziona

Per ogni carattere cnell'input, prende il Subgraphdello GridGraphdello stesso Dimensionscome input che corrisponde a tutti Positionin cui csi verifica, e controlla se è un ConnectedGraphQ.

Python 2 , 247 byte

def f(a):
 b=map(list,a.split('\n'));l=len(b[0])
 for c in set(a):i=a.find(c);g(b,i/l,i%l,c)
 print all(set(l)<={0}for l in b)
def g(a,i,j,c):
 if len(a)>i>-1<j<len(a[0])and a[i][j]==c:
	for x,y in(0,1),(0,-1),(1,0),(-1,0):g(a,i+x,j+y,c);a[i][j]=0

Provalo online!

JavaScript (ES6), 181 byte

(d,o={})=>{f=(i,j,c,l=d[i])=>{if(c&&l&&l[j]==c){l[j]='';f(i-1,j,c);f(i+1,j,c);f(i,j-1,c);f(i,j+1,c);o[c]=1}};d.map((e,i)=>e.map((c,j)=>o[c]||f(i,j,c)));return!d.some(e=>e.join(''))}

Ogni volta che viene trovata una nuova tessera colore, riempire quelle collegate con stringhe vuote. Se il tappetino è correttamente raggruppato per colore, tutte le tessere devono essere riempite con stringhe vuote.

Codice test

const t =
(d,o={})=>{f=(i,j,c,l=d[i])=>{if(c&&l&&l[j]==c){l[j]='';f(i-1,j,c);f(i+1,j,c);f(i,j-1,c);f(i,j+1,c);o[c]=1}};d.map((e,i)=>e.map((c,j)=>o[c]||f(i,j,c)));return!d.some(e=>e.join(''))}
;

const mat = s=>s.split('\n').filter(l=>l).map(l=>l.split(''));
console.log('true?', t(mat(`
A
`)));
console.log('true?', t(mat(`
AB
AB
`)));
console.log('false?', t(mat(`
AB
BA
`)));
console.log('true?', t(mat(`
ABCDE
`)));
console.log('false?', t(mat(`
ABCDC
`)));
console.log('true?', t(mat(`
**::dd22
***:d222
*:::::22
`)));
console.log('false?', t(mat(`
$$$%%%&&
$$%%&&&&
&&$$$%&&
`)));
console.log('true?', t(mat(`
AABBCDDDE
ABBCCCDEE
ABCCCCDDE
AACCCDDEE
AAAACCCCE
AAAAAACCC
`)));
console.log('true?', t(mat(`
AABB
ABBA
AAAA
`)));
console.log('true?', t(mat(`
AAAB
AAAA
AAAA
`)));