Çocuklarımın oynayacağı bir alfabe matı var, böyle bir şey:

Matın karoları rastgele yerleştirilmiş aylardan sonra, yoruldum ve paspasın tüm karolarını arka plan renklerine göre bölümlere göre gruplandırdım. Yani, harfler arka plan rengini temsil ediyorsa, şöyle bir paspas aldım:

AABBCDDDE
ABBCCCDEE
ABCCCCDDE
AACCCDDEE
AAAACCCCE
AAAAAACCC

Bu nedenle, A, B, C, D ve E renkleri için, aynı arka plan rengine sahip tüm karoları matta yatay veya dikey olarak bağlamanın her zaman bir yolu vardır. Renklere göre düzgün bir şekilde gruplandırılmış bir paspas diyorum . Önceki örnek için grupları aşağıdaki tablolarda görebilirsiniz:

AA
A
A
AA
AAAA
AAAAAA

  BB
 BB
 B

    C
   CCC
  CCCC
  CCC
    CCCC
      CCC

     DDD
      D
      DD
     DD

        E
       EE
        E
       EE
        E

Ayrıca, her renk için sadece bir grup vardır, bu yüzden bu geçerli olmaz:

ABA
ABA

Çünkü A rengi döşemeleri yalnızca bir grupta gruplandırılmaz. Döşemeler yatay veya dikey olarak bağlanmadığı için bu da geçerli olmaz:

AB
BA

Meydan okuma

Yazdırılabilir ASCII aralığındaki 2 boyutlu bir karakter dizisi verildiğinde (her iki boyutun boyutu 1'e eşit veya daha büyük olduğu sürece kare olması gerekmez), dizinin renklere göre düzgün bir şekilde gruplandırılmış bir altlığı temsil edip etmediğini kontrol edin (dizideki her farklı karakter farklı bir rengi temsil eder). Giriş, 2 boyutlu bir karakter dizisini (2D karakter dizisi, aynı uzunlukta dizeler dizisi vb.) Temsil ettiği sürece makul herhangi bir biçimde olabilir ve çıktı bir çift doğruluk ve falsey değeri olmalıdır (0 / 1, 't' / 'f', true / false, bir şey döndürüldüğünde ve dönüş değerleri girdiler arasında tutarlı olduğu sürece).

Bu kod golf, bu yüzden her dil için en kısa program / fonksiyon / yöntem / lambda kazanmak olabilir!

Örnekler

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

Matım renklere göre düzgün bir şekilde gruplandırılmış

(Hala bu sınırları düzeltmem gerekiyor ...)

MATL , 16 15 bayt

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

Giriş, 2B karakter dizisidir (satırlar birbirinden ayrılır ;). Çıktı, 0girdi uygunsa veya 1başka bir şekilde yapılır.

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın .

açıklama

Kod, girişteki her karakterde 4 bağlantı (yani köşegenler olmadan) dikkate alındığında yalnızca bir bağlı bileşen olup olmadığını kontrol eder.

Tekrarlanan karakterler tekrar tekrar işlenir (bu, tekilleştirmeden daha golfçüdür).

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 bayt

Düzenleme: Doğru bayt sayımı düzeltildi. Ayrıca daha fazla golf olabilir

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

1 doğruluk olarak, 0 falsey olarak basar

Çevrimiçi Deneyin

İşte işaretçinin izlediği yolun bir görselleştirmesi

Not: Bu eski bir sürüm içindir

Nasıl çalışır

İşte bazı hızlı ve kirli sahte kod

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

Temel olarak, girdiyi sakladıktan sonra, her alanı kontrol ederek her şeyi kontrol eder. İçinde karakter bulunan bir boşluk bulduğunda yığına koordinatları ekler. Daha sonra, her bir karakteri 0 olarak ayarlayarak, aynı karakteri sürekli olarak aynı karakter için kontrol eder. Öyleyse 0 değerini döndürün. Değilse, karakter dizisine ekleyin. Kopya olmadan tüm ızgaradan geçtikten sonra 1 döndürür.

Befunge'ye aşina olan insanlar için, kodun aralıklı bir sürümü

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 bayt

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

cbirler ve sıfırlar bir matris olup olmadığını belirten bir fiil tanımlar c onnected. Singleton'lara özel bir gerçek durumu olarak davranır. Aksi takdirde, her hücrenin dik bir komşu sayısını alır, ardından o sayının işareti, daha sonra bunu orijinal matrisle çarpar: eğer bu ürün orijinal matrise eşitse, o zaman bağlanır.

Komşu sayımı, 4 yöne de kaydırılarak toplanır. 4 yön kaydırma, xdöndürme / kaydırma işleminin " -arg can a table" özelliği kullanılarak gerçekleştirilir|.

Son olarak, cevabın kendisi , girdinin her benzersiz ~. elemanı için bir / sıfır matrisi oluşturarak ve sonra tüm bu matrislerin birbirine bağlı olmasını sağlayarak elde etti. Bu ikinci satırdaki fiildir.

Çevrimiçi deneyin!

JavaScript (ES6), 114 bayt

Girdiyi dizeler dizisi olarak alır. 0Veya döndürür 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)

Test senaryoları

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

Biçimlendirilmiş ve yorumlanmış

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 Dili (Mathematica) , 96 bayt

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

Çevrimiçi deneyin!

Girişi 2B karakter listesi olarak alır: örneğin {{"A","B"},{"C","D"}},.

Karakterdir \[Transpose].

Nasıl çalışır

Her bir karakter için cgirdi alır Subgraphve GridGraphaynı Dimensionsher hangi tekabül girdi olarak Positionhangi cbir olmadığını ortaya çıkar ve kontrol eder ConnectedGraphQ.

Python 2 , 247 bayt

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

Çevrimiçi deneyin!

JavaScript (ES6), 181 bayt

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

Yeni bir renk döşemesi bulunduğunda, bağlı olanları boş dizelerle doldurun. Paspas renklere göre düzgün bir şekilde gruplandırılmışsa, tüm karolar boş dizelerle doldurulmalıdır.

Test Kodu

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