У моїх діточок є килимок з алфавітом, з яким можна грати:

Після місяців, коли плитки килимка були випадково розміщені, я втомився і розмістив усі плитки килимка, згруповані по секціях відповідно до їх кольорів фону. Отже, якщо букви представляють колір тла, у мене вийшов такий килимок:

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 для друку (не потрібно бути квадратним до тих пір, поки розмір обох розмірів дорівнює або перевищує 1), перевірте, чи масив представляє килимок, правильно згрупований за кольорами (кожен різний символ у масиві являє собою інший колір). Введення може бути в будь-якому розумному форматі до тих пір, поки воно представляє двовимірний масив символів (2D char масив, масив рядків однакової довжини тощо), а вихід повинен бути парою значень truthy та falsey (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

Вхід - це двовимірний масив знаків (рядки розділені між собою ;). Вихідний результат - це 0якщо введення кваліфіковано, чи 1іншим чином.

Спробуйте в Інтернеті! Або перевірити всі тестові випадки .

Пояснення

Код суттєво перевіряє, чи кожен char у вході має лише один підключений компонент, враховуючи 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~.@,

cвизначає дієслово, яке підказує, чи матриця одиниць і нулів є c приєднаною. Він трактує одиноких як особливий випадок справжнього. В іншому випадку потрібно взяти ортогональний підрахунок сусідів кожної комірки, потім сигнум цього підрахунку, а потім помножити це на вихідну матрицю: якщо цей продукт дорівнює оригінальній матриці, то він пов'язаний.

Підрахунок сусідів досягається зміщенням у всіх 4 напрямках, потім підсумовуванням. Зсув 4-х напрямків здійснюється за допомогою функції " x-арг за столом" обертання / зсуву|.

Нарешті, сама відповідь була досягнута шляхом створення матриці one / нулі для кожного унікального ~. елемента введення, а потім гарантування з’єднання всіх цих матриць. Це дієслово у другому рядку.

Спробуйте в Інтернеті!

JavaScript (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

Мова Вольфрама (Mathematica) , 96 байт

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

Спробуйте в Інтернеті!

Приймає вхідний сигнал у вигляді списку 2D символів: наприклад, {{"A","B"},{"C","D"}}.

The Характер \[Transpose].

Як це працює

Для кожного символу cна вході, бере Subgraphз GridGraphодного і того ж , Dimensionsяк на вході , який відповідає кожному , Positionв якому cвідбувається, і перевіряє , є чи це ConnectedGraphQ.

Python 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

Спробуйте в Інтернеті!

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