Anak-anak saya memiliki alas alfabet untuk dimainkan, sesuatu seperti ini:

Setelah berbulan-bulan dengan ubin tikar ditempatkan secara acak, saya lelah dan menempatkan semua ubin tikar dikelompokkan berdasarkan bagian sesuai dengan warna latar belakang mereka. Jadi, jika huruf mewakili warna latar belakang, saya mendapat tikar seperti ini:

AABBCDDDE
ABBCCCDEE
ABCCCCDDE
AACCCDDEE
AAAACCCCE
AAAAAACCC

Jadi, untuk warna A, B, C, D, dan E selalu ada cara untuk menghubungkan semua ubin dengan warna latar yang sama baik secara horizontal atau vertikal di matras. Itulah yang saya sebut tikar dengan benar dikelompokkan berdasarkan warna . Anda dapat melihat grup untuk contoh sebelumnya di tabel berikut:

AA
A
A
AA
AAAA
AAAAAA

  BB
 BB
 B

    C
   CCC
  CCCC
  CCC
    CCCC
      CCC

     DDD
      D
      DD
     DD

        E
       EE
        E
       EE
        E

Selain itu, hanya ada satu grup untuk setiap warna, jadi ini tidak valid:

ABA
ABA

Karena ubin warna A tidak dikelompokkan hanya dalam satu grup. Ini juga tidak akan valid karena ubin tidak terhubung secara horizontal atau vertikal:

AB
BA

Tantangan

Diberikan susunan karakter 2 dimensi dalam rentang ASCII yang dapat dicetak (tidak harus berbentuk bujur sangkar asalkan ukuran kedua dimensi sama atau lebih besar dari 1), periksa apakah susunan mewakili matras yang dikelompokkan dengan baik oleh warna. (setiap karakter yang berbeda dalam array mewakili warna yang berbeda). Input mungkin dalam format wajar apa pun asalkan mewakili karakter 2 dimensi (array char 2D, array string dengan panjang yang sama, dan sebagainya), dan output harus berupa sepasang nilai kebenaran dan nilai falsey (0 / 1, 't' / 'f', benar / salah, apa pun asalkan sesuatu dikembalikan dan nilai kembali konsisten di seluruh input).

Ini adalah kode-golf, jadi semoga program / fungsi / metode / lambda terpendek untuk setiap bahasa menang!

Contohnya

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

Mataku dikelompokkan berdasarkan warna

(Aku masih harus memperbaiki perbatasan itu ...)

MATL , 16 15 byte

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

Input adalah array char 2D (dengan baris dipisahkan oleh ;). Output adalah 0jika input memenuhi syarat, atau 1sebaliknya.

Cobalah online! Atau verifikasi semua kasus uji .

Penjelasan

Kode ini pada dasarnya memeriksa apakah setiap karakter dalam input hanya memiliki satu komponen yang terhubung, mempertimbangkan 4-konektivitas (yaitu, tidak ada diagonal).

Karakter berulang diulangi berulang-ulang (yang lebih golf daripada deduplikasi).

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

Sunting: Diperbaiki untuk jumlah byte yang tepat. Juga bisa bermain golf lebih lanjut

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

Mencetak 1 sebagai kebenaran, 0 sebagai falsey

Cobalah secara Online

Berikut ini visualisasi jalur yang diambil pointer

Catatan: ini untuk versi lama

Bagaimana itu bekerja

Inilah beberapa kodesemu yang cepat dan kotor

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

Pada dasarnya, setelah menyimpan input, ia melewati semuanya, memeriksa setiap ruang. Ketika menemukan ruang dengan karakter di dalamnya, ia menambahkan koordinat ke stack. Kemudian ia memeriksa ruang di sekitarnya untuk karakter yang sama secara rekursif, mengatur setiap ruang menjadi 0. Ketika telah menghabiskan bagian karakter itu, ia memeriksa apakah karakter itu sudah memiliki bagian. Jika demikian, kembali 0. Jika tidak, tambahkan ke array karakter. Setelah melewati seluruh grid tanpa duplikat, ia mengembalikan 1.

Untuk orang-orang yang akrab dengan Befunge, inilah versi kode yang diberi spasi

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~.@,

cmendefinisikan kata kerja yang memberitahu Anda jika matriks dari satu dan nol adalah c onnected. Ini memperlakukan yang singleton sebagai kasus khusus yang benar. Kalau tidak, ia membutuhkan hitungan tetangga ortogonal dari setiap sel, lalu signum dari hitungan itu, lalu mengalikannya dengan matriks asli: jika produk itu sama dengan matriks asli, maka itu terhubung.

Hitungan tetangga dicapai dengan menggeser ke 4 arah, lalu menjumlahkan. Pergeseran 4 arah dicapai dengan menggunakan fitur " x-arg can by a table" dari rotate / shift|.

Akhirnya, jawaban itu sendiri dicapai dengan membuat matriks satu / nol untuk setiap elemen unik ~. dari input, dan kemudian memastikan bahwa semua matriks tersebut terhubung. Ini adalah kata kerja di baris kedua.

Cobalah online!

JavaScript (ES6), 114 byte

Mengambil input sebagai array string. Pengembalian 0atau 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)

Uji kasus

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

Diformat dan dikomentari

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

Bahasa Wolfram (Mathematica) , 96 byte

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

Cobalah online!

Mengambil input sebagai daftar karakter 2D: misalnya {{"A","B"},{"C","D"}},.

The karakter \[Transpose].

Bagaimana itu bekerja

Untuk setiap karakter cdalam input, ambilSubgraph dari GridGraphyang sama Dimensionssebagai masukan yang bersesuaian dengan setiap Positiondi mana cterjadi, dan memeriksa apakah itu 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

Cobalah 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(''))}

Setiap kali ubin warna baru ditemukan, isi yang terhubung dengan string kosong. Jika keset dikelompokkan berdasarkan warna, semua ubin harus diisi dengan senar kosong.

Kode Uji

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