Meine Kinder haben eine Alphabet-Matte zum Spielen:

Nach Monaten, in denen die Fliesen der Matte nach dem Zufallsprinzip platziert wurden, wurde ich müde und legte alle Fliesen der Matte abschnittsweise nach ihren Hintergrundfarben gruppiert. Wenn die Buchstaben die Hintergrundfarbe darstellen, habe ich eine Matte wie diese:

AABBCDDDE
ABBCCCDEE
ABCCCCDDE
AACCCDDEE
AAAACCCCE
AAAAAACCC

Für die Farben A, B, C, D und E gibt es also immer eine Möglichkeit, alle Kacheln mit derselben Hintergrundfarbe horizontal oder vertikal in der Matte zu verbinden. Das ist, was ich eine Matte nenne, die richtig nach Farben gruppiert ist . Sie können die Gruppen für das vorherige Beispiel in den folgenden Tabellen sehen:

AA
A
A
AA
AAAA
AAAAAA

  BB
 BB
 B

    C
   CCC
  CCCC
  CCC
    CCCC
      CCC

     DDD
      D
      DD
     DD

        E
       EE
        E
       EE
        E

Außerdem gibt es nur eine Gruppe für jede Farbe, sodass dies nicht gültig wäre:

ABA
ABA

Weil Farbe-A-Kacheln nicht nur in einer Gruppe gruppiert sind. Dies gilt auch nicht, da die Kacheln weder horizontal noch vertikal verbunden sind:

AB
BA

Die Herausforderung

Überprüfen Sie bei einem zweidimensionalen Array von Zeichen im druckbaren ASCII-Bereich (muss kein Quadrat sein, solange die Größe beider Dimensionen gleich oder größer als 1 ist), ob das Array eine nach Farben richtig gruppierte Matte darstellt (Jedes andere Zeichen im Array repräsentiert eine andere Farbe.) Die Eingabe kann in jedem vernünftigen Format erfolgen, sofern es sich um ein zweidimensionales Array von Zeichen handelt (2D-Zeichen-Array, Array von Zeichenfolgen mit derselben Länge usw.). Die Ausgabe muss aus zwei Wahrheits- und Falschwerten (0) bestehen / 1, 't' / 'f', true / false, egal, solange etwas zurückgegeben wird und die Rückgabewerte für alle Eingaben konsistent sind).

Das ist Code-Golf, also kann das kürzeste Programm / Funktion / Methode / Lambda für jede Sprache gewinnen!

Beispiele

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

Meine Matte richtig nach Farben gruppiert

(Ich muss noch diese Grenzen reparieren ...)

MATL , 16 15 Bytes

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

Die Eingabe ist ein 2D-Zeichen-Array (mit durch getrennten Zeilen ;). Die Ausgabe erfolgt, 0wenn die Eingabe qualifiziert ist oder 1nicht.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Der Code überprüft im Wesentlichen, ob jedes Zeichen in der Eingabe nur eine verbundene Komponente enthält, wobei die 4-Konnektivität berücksichtigt wird (dh keine Diagonalen).

Wiederholte Zeichen werden wiederholt verarbeitet (was mehr Golf als Deduplizieren bedeutet).

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 Bytes

Bearbeiten: Korrigiert für die richtige Anzahl von Bytes. Auch könnte weiter Golf gespielt werden

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

Druckt 1 als wahr, 0 als falsch

Probieren Sie es online

Hier ist eine Visualisierung des Pfades, den der Zeiger nimmt

Hinweis: Dies ist eine alte Version

Wie es funktioniert

Hier ist ein schneller und schmutziger Pseudocode

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

Grundsätzlich wird nach dem Speichern der Eingabe das Ganze durchlaufen und die einzelnen Leerzeichen überprüft. Wenn ein Leerzeichen mit einem Zeichen gefunden wird, werden die Koordinaten zum Stapel hinzugefügt. Anschließend werden die umgebenden Leerzeichen rekursiv auf dasselbe Zeichen überprüft, wobei jedes Leerzeichen auf 0 gesetzt wird. Wenn der Abschnitt dieses Zeichens erschöpft ist, wird geprüft, ob für dieses Zeichen bereits ein Abschnitt vorhanden ist. Wenn dies der Fall ist, geben Sie 0 zurück. Wenn nicht, fügen Sie es dem Array von Zeichen hinzu. Wenn es das gesamte Raster ohne Duplikate durchlaufen hat, wird 1 zurückgegeben.

Für Leute, die mit Befunge vertraut sind, ist hier eine abgesetzte Version des Codes

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 Bytes

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

cdefiniert ein Verb , das , wenn man eine Matrix aus Einsen und Nullen erzählt wird c onnected. Singleton-Typen werden als Sonderfall von true behandelt. Andernfalls wird für jede Zelle eine orthogonale Nachbarzählung verwendet, dann wird das Signum dieser Zählung mit der ursprünglichen Matrix multipliziert. Wenn dieses Produkt der ursprünglichen Matrix entspricht, ist es verbunden.

Die Nachbarzählung wird durch Verschieben in alle 4 Richtungen und anschließende Summierung erreicht. Die Verschiebung in 4 Richtungen wird mit der Funktion " x-arg can by a table" zum Drehen / Verschieben erreicht|.

Schließlich wird die Antwort selbst erzielt, indem für jedes eindeutige ~. Element der Eingabe eine Einsen / Nullen-Matrix erstellt wird und anschließend sichergestellt wird, dass alle diese Matrizen verbunden sind. Dies ist das Verb in der zweiten Zeile.

Probieren Sie es online!

JavaScript (ES6), 114 Byte

Nimmt Eingaben als ein Array von Zeichenfolgen. Rückgabe 0oder 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)

Testfälle

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"
]))

Formatiert und kommentiert

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=#)))&

Probieren Sie es online!

Übernimmt die Eingabe als 2D-Liste von Zeichen: zum Beispiel {{"A","B"},{"C","D"}} .

Der Charakter ist\[Transpose] .

Wie es funktioniert

Nimmt für jedes Zeichen cin der Eingabe Subgraphdas GridGraphvon desselben Dimensionsals die Eingabe, die jedem Positionin dem cauftritt entspricht, und prüft, ob es ein ist ConnectedGraphQ.

Python 2 , 247 Bytes

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

Probieren Sie es 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(''))}

Wenn eine neue Farbkachel gefunden wird, füllen Sie die verbundenen mit leeren Zeichenfolgen. Wenn die Matte richtig nach Farben gruppiert ist, sollten alle Kacheln mit leeren Zeichenfolgen gefüllt werden.

Code testen

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
`)));