내 아이들은 다음과 같은 알파벳 매트를 가지고 있습니다.

매트 타일이 무작위로 배치 된 몇 달 후, 피곤하고 매트의 모든 타일을 배경색에 따라 섹션별로 그룹화했습니다. 따라서 글자가 배경색을 나타내는 경우 다음과 같은 매트를 얻습니다.

AABBCDDDE
ABBCCCDEE
ABCCCCDDE
AACCCDDEE
AAAACCCCE
AAAAAACCC

따라서 색상 A, B, C, D 및 E의 경우 매트에서 모든 타일을 동일한 배경색으로 가로 또는 세로로 연결할 수있는 방법이 항상 있습니다. 그것이 내가 색상으로 올바르게 그룹화 된 매트 라고 부르는 것입니다 . 다음 표에서 이전 예의 그룹을 볼 수 있습니다.

AA
A
A
AA
AAAA
AAAAAA

  BB
 BB
 B

    C
   CCC
  CCCC
  CCC
    CCCC
      CCC

     DDD
      D
      DD
     DD

        E
       EE
        E
       EE
        E

또한 모든 색상에 대해 하나의 그룹 만 있으므로 유효하지 않습니다.

ABA
ABA

색상 A 타일은 하나의 그룹으로 그룹화되지 않기 때문입니다. 타일이 수평 또는 수직으로 연결되지 않기 때문에 이것은 유효하지 않습니다.

AB
BA

도전

인쇄 가능한 ASCII 범위의 2 차원 문자 배열 (두 차원의 크기가 1 이상인 경우 정사각형 일 필요는 없음)이 주어지면 배열이 색상으로 올바르게 그룹화 된 매트를 나타내는 지 확인하십시오. (배열에서 각기 다른 문자는 다른 색을 나타냅니다). 입력은 2 차원 문자 배열 (2D 문자 배열, 길이가 같은 문자열 배열 등)을 나타내는 한 합리적인 형식 일 수 있으며 출력은 진실과 거짓 값의 쌍이어야합니다 (0 / 1, 't'/ 'f', true / false (물건이 반환되고 입력 값이 반환되는 한)

이것은 코드 골프이므로 각 언어마다 가장 짧은 프로그램 / 기능 / 방법 / 람다가 이길 수 있습니다!

예

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

내 매트가 색상별로 올바르게 그룹화되었습니다.

(아직도 그 경계를 고쳐야합니다 ...)

MATL , 16 15 바이트

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

입력은 2D 문자 배열입니다 (행은으로 구분됨 ;). 0입력이 자격을 갖추면 1그렇지 않으면 출력이 출력 됩니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

이 코드는 입력의 각 문자에 4 개의 연결성 (대각선 없음)을 고려하여 연결된 구성 요소가 하나만 있는지 확인합니다.

반복되는 문자는 반복적으로 처리됩니다 (중복 제거보다 골퍼입니다).

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 바이트

편집 : 적절한 바이트 수로 수정되었습니다. 또한 더 골프 수

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을 진실로, 0을 거짓으로 인쇄

온라인 시도

다음은 포인터가 취하는 경로의 시각화입니다

참고 : 이것은 이전 버전입니다

작동 원리

여기에 빠르고 더러운 의사 코드가 있습니다.

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

기본적으로 입력을 저장 한 후에는 전체를 통해 각 공간을 확인합니다. 문자가있는 공간을 찾으면 좌표를 스택에 추가합니다. 그런 다음 각 문자를 0으로 설정하여 동일한 문자가 있는지 주변의 공백을 재귀 적으로 검사합니다. 해당 문자의 섹션을 다 쓴 경우 해당 문자에 이미 섹션이 있는지 확인합니다. 그렇다면 0을 반환하십시오. 그렇지 않으면 문자 배열에 추가하십시오. 중복없이 전체 그리드를 통과하면 1을 반환합니다.

Befunge에 익숙한 사람들을 위해 다음은 코드 버전입니다.

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 바이트

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

c1과 0의 행렬이 경우를 알려줍니다 동사 정의 C가 onnected합니다. 싱글 톤을 특수한 경우로 취급합니다. 그렇지 않으면 모든 셀의 직교 인접 카운트를 취한 다음 해당 카운트의 부호를 곱한 다음 원래 행렬과 곱합니다. 해당 제품이 원래 행렬과 같으면 연결됩니다.

이웃 계수는 4 방향 모두로 이동 한 다음 합산하여 달성됩니다. x회전 / 시프트 의 " -arg can by a table"기능을 사용하여 4 방향 전환을 수행합니다.|.

마지막으로, 입력의 모든 고유 한 ~. 요소에 대해 1 / 제로 행렬을 만든 다음 모든 행렬이 연결되도록 하여 답을 얻습니다 . 이것은 두 번째 줄의 동사입니다.

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 114 바이트

입력을 문자열 배열로 취합니다. 반환 0또는 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)

테스트 사례

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

형식화 및 의견

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 바이트

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

온라인으로 사용해보십시오!

입력을 2D 문자 목록으로 가져옵니다 (예 :) {{"A","B"},{"C","D"}}.

문자는\[Transpose] .

작동 원리

각 문자 c입력에, 소요 Subgraph의 GridGraph동일의 Dimensions각에 대응 한 입력 등을 Position하는 c그것이 있다면 발생하여, 검사 ConnectedGraphQ.

파이썬 2 , 247 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 181 바이트

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