เขาวงกตจะได้รับเป็นเมทริกซ์ 0s (ผนัง) และ 1s (พื้นที่เดิน) ในรูปแบบที่สะดวกใด ๆ แต่ละเซลล์จะถูกพิจารณาว่าเชื่อมต่อกับเพื่อนบ้านของ orthogonal 4 ตัว (หรือน้อยกว่า) คอมโพเนนท์ที่ต่อเป็นชุดของเซลล์ walkable ทั้งหมดที่เชื่อมต่อสกรรมกริยากับแต่ละอื่น ๆ งานของคุณคือการระบุcutpoints - เซลล์ walkable ซึ่งหากกลายเป็นผนังจะเปลี่ยนจำนวนขององค์ประกอบที่เกี่ยวโยงกัน เอาท์พุทเมทริกซ์บูลีนแบบ 1 วินาทีที่ตำแหน่งเหล่านั้นเท่านั้น เป้าหมายคือการทำในรหัสไบต์น้อยที่สุด

เมทริกซ์การป้อนข้อมูลจะประกอบด้วยอย่างน้อย 3 แถวและ 3 คอลัมน์ เซลล์อย่างน้อยหนึ่งเซลล์จะเป็นกำแพงและอย่างน้อยหนึ่งเซลล์ก็สามารถเดินได้ ฟังก์ชั่นหรือโปรแกรมของคุณจะต้องสามารถประมวลผลตัวอย่างใด ๆ ด้านล่างในเวลาไม่เกินหนึ่งนาทีในTIO (หรือในคอมพิวเตอร์ของคุณเองหาก TIO ไม่รองรับภาษา)

in:
11101001
11011101
00000001
11101111
11110101
00011111
10110001
11111111
out:
01000000
00001001
00000001
00000101
00110000
00010000
00000000
11100000

in:
1111111111111111
1000000000000001
1111111111111101
0000000000000101
1111111111110101
1000000000010101
1011111111010101
1010000001010101
1010111101010101
1010101111010101
1010100000010101
1010111111110101
1010000000000101
1011111111111101
1000000000000001
1111111111111111
out:
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000

in:
1011010001111010
1111111011101101
1110010101001011
1111001110010010
1111010000101001
0111101001000101
0011100111110010
1001110011111110
0101000011100011
1110110101001110
0010100111000110
1000110111011010
0100101000100101
0001010101100011
1001010000111101
1000111011000010
out:
0000000000111010
1011110001001000
0000000000000011
0000000100010000
0000010000101000
0000001000000100
0000000011000000
1001100000011110
0000000001000010
0110100001000110
0000100101000010
1000100000000000
0100001000000100
0000000100100001
0000010000111000
0000010000000010

Stax , 40 ไบต์

Çóê↓â.Φ}╞│*w<(♦◙¼ñ£º█¢,D`ì♥W4·☺╛gÇÜ♠╗4D┬

เรียกใช้และดีบักกรณีทดสอบ

โปรแกรมนี้รับอินพุตเป็นสตริงที่คั่นด้วยช่องว่างที่มีแถว เอาต์พุตอยู่ในรูปแบบเดียวกัน นี่คือการเป็นตัวแทน ASCII ที่ยังไม่ได้แพ็ค

{2%{_xi48&GxG=-}_?m}{'1'2|e{"12|21".22RjMJguHgu%

การดำเนินการขั้นพื้นฐานสำหรับการนับเกาะทำงานเช่นนี้

1. แทนที่อันแรก'1'ด้วย a '2'.
2. regex แทนที่ด้วย'12|21''22'
3. แยกบนช่องว่าง
4. เมทริกซ์ขนย้าย
5. ทำซ้ำตั้งแต่ 2 จนกว่าจะมีการทำซ้ำสตริง
6. ทำซ้ำตั้งแต่ 1 จนกระทั่งไม่มี'1'ในสตริงอีกต่อไป จำนวนการทำซ้ำคือจำนวนเกาะ

.

{               start map block over input string, composed of [ 01]
  2%            mod by 2. space and 0 yield 0. 1 yields 1. (a)
  {             start conditional block for the 1s.
    _           original char from string (b)
    xi48&       make copy of input with current character replaced with 0
    G           jump to unbalanced }, then return; counts islands (c)
    xG          counts islands in original input (d)
    =           are (c) and (d) equal? 0 or 1 (e)
    -           b - e; this is 1 iff this character is a bridge
  }             end conditional block
  _?            execute block if (a) is 1, otherwise use original char from string
m               close block and perform map over input
}               goto target - count islands and return
{               start generator block
  '1'2|e        replace the first 1 with a 2
  {             start generator block
    "12|21".22R replace "12" and "21" with "22"
    jMJ         split into rows, transpose, and rejoin with spaces
  gu            generate values until any duplicate is encountered
  H             keep the last value
gu              generate values until any duplicate is encountered
%               count number of iterations it took

โปรแกรมโบนัส 44 ไบต์ - อินพุตและเอาท์พุตรุ่นนี้ใช้รูปแบบกริด

MATL , 26 ไบต์

n:"GG0@(,w4&1ZIuz]=~]vGZye

อินพุตเป็นเมทริกซ์เชิงตัวเลขโดยใช้;เป็นตัวคั่นแถว

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

n           % Implicit input: matrix. Push number of elements, N
:           % Range: gives [1 2 ... N]
"           % For each k in [1 2 ... N]
  GG        %   Push input matrix twice
  0@(       %   Write 0 at position k (in column-major order: down, then across).
            %   The stack now contains the original matrix and a modified matrix
            %   with 0 at position k
  ,         %   Do twice
    w       %     Swap
    4       %     Push 4. This specifies 4-element neighbourhood
    &1ZI    %     Label each connected component, using the specified
            %     neighbourhood. This replaces each 1 in the matrix by a
            %     positive integer according to the connected component it
            %     belongs to
    u       %     Unique: gives a vector of deduplicate elements
    z       %     Number of nonzeros. This is the number of connected components
  ]         %   End
  =~        %   Are they different? Gives true of false
]           % End
v           % Concatenate stack into a column vector
GZye        % Reshape (in column-major order) according to size of input matrix.
            % Implicit display

Perl 5 , -p0 105 101 96 93 90 89 ไบต์

ใช้bแทน1อินพุต

ตรวจสอบให้แน่ใจว่าเมทริกซ์ใน STDIN ถูกยกเลิกด้วยการขึ้นบรรทัดใหม่

#!/usr/bin/perl -p0
s%b%$_="$`z$'";s:|.:/
/>s#(\pL)(.{@{-}}|)(?!\1)(\pL)#$&|a.$2.a#se&&y/{c/z />0:seg&/\B/%eg

ลองออนไลน์!

ใช้การทดแทน 3 ระดับ!

เวอร์ชัน 87 ไบต์นี้มีทั้งในรูปแบบอินพุตและเอาต์พุตที่ตีความได้ง่ายกว่า แต่ไม่สามารถแข่งขันได้เนื่องจากใช้อักขระต่างกัน 3 ตัวในเอาต์พุต:

#!/usr/bin/perl -0p
s%b%$_="$`z$'";s:|.:/
/>s#(\w)(.{@{-}}|)(?!\1)(\w)#$&|a.$2.a#se&&y/{c/z />0:seg&/\B/%eg

ลองออนไลน์!

เป็นการง่ายที่จะบันทึกไบต์อื่น ( sตัวแก้ไขregex ) ในทั้งสองเวอร์ชันโดยใช้อักขระ (ไม่ใช่ตัวอักษรและตัวเลข) ที่แตกต่างกันเป็นตัวยุติแถว (แทนที่จะขึ้นบรรทัดใหม่) แต่นั่นทำให้อินพุตไม่สามารถอ่านได้อีกครั้ง

มันทำงานอย่างไร

พิจารณาการทดแทน

s#(\w)(.{columns}|)(?!1)(\w)#c$2c#s

นี้จะได้พบกับตัวอักษรสองตัวที่มีความแตกต่างกันและติดกันในแนวนอนหรือแนวตั้งอื่น ๆ cและแทนที่พวกเขาด้วย ในเขาวงกตที่มีเส้นทางที่ประกอบด้วยทั้งตัวอักษรbอะไรจะเกิดขึ้นตั้งแต่ตัวอักษรที่เหมือนกัน แต่ทันทีที่หนึ่งของตัวอักษรจะถูกแทนที่ด้วยอีกคนหนึ่ง (เช่นz) ตัวอักษรที่และเพื่อนบ้านจะถูกแทนที่ด้วยcและทำซ้ำการประยุกต์ใช้เป็น น้ำท่วมเติมขององค์ประกอบที่เชื่อมต่อกับจากเมล็ดcz

ในกรณีนี้ฉันไม่ต้องการเติมน้ำท่วมทั้งหมด ฉันต้องการเติมแขนข้างหนึ่งเพียงข้างzเดียวดังนั้นหลังจากขั้นตอนแรกฉันก็อยากจะzหายไป ใช้งานได้แล้วกับการc$2cแทนที่ แต่ภายหลังฉันต้องการเริ่มต้นเติมน้ำท่วมตามแขนอีกข้างโดยเริ่มจากจุดเดิมและฉันไม่รู้ว่าcs อันไหนเป็นของเดิมzอีกต่อไป ดังนั้นฉันจะใช้แทน

s#(\w)(.{columns}|)(?!\1)(\w)#$&|a.$2.a#se

b | aเป็นc, b | cเป็นcและเป็นz | a {ดังนั้นในเขาวงกตที่ประกอบด้วยเส้นทางbและเมล็ดzในขั้นตอนแรกbจะถูกแทนที่ด้วยcและzจะถูกแทนที่ด้วย{ซึ่งไม่ใช่ตัวอักษรและไม่ตรงกัน\wและจะไม่ทำให้เกิดการเติมเพิ่มเติม cแต่จะทำให้น้ำท่วมต่อเติมไปและเพื่อนบ้านแขนข้างหนึ่งของเมล็ดพันธุ์ที่ได้รับการเติมเต็ม เช่นเริ่มจาก

  b                      c
  b                      c
bbzbb       becomes    bb{bb
  b                      b
  b                      b

ฉันสามารถแทนที่ c ทั้งหมดด้วยตัวอักษรที่ไม่ใช่ (เช่น-) และแทนที่{ด้วยzอีกครั้งเพื่อเริ่มการเติมน้ำท่วม:

  -                      -
  -                      -
bbzbb       becomes    cc{bb
  b                      b
  b                      b

และทำซ้ำขั้นตอนนี้จนกว่าเพื่อนบ้านทั้งหมดของเมล็ดจะถูกแปลง ถ้าฉันอีกครั้งแทนที่{ด้วยzและเติมน้ำท่วม:

  -                      -
  -                      -
--z--       stays      --z--
  -                      -
  -                      -

สิ่งที่zเหลืออยู่ข้างหลังในตอนท้ายเพราะไม่มีเพื่อนบ้านที่จะเปลี่ยนแปลงด้วย ทำให้ชัดเจนว่าเกิดอะไรขึ้นในส่วนของรหัสต่อไปนี้:

/\n/ >                                    

ค้นหา newline แรก ออฟเซ็ตเริ่มต้นมาถึงแล้ว@-

s#(\w)(.{@{-}}|)(?!\1)(\w)#$&|a.$2.a#se

regex ที่กล่าวถึงข้างต้นด้วย@{-}จำนวนคอลัมน์ (ตั้งแต่ธรรมดา@-ทำให้สับสน parser perl และไม่ถูกแทนอย่างถูกต้อง)

&&

/\n/เสมอประสบความสำเร็จและเปลี่ยนตัวเป็นจริงตราบใดที่เรายังสามารถเติมน้ำท่วม ดังนั้นการดำเนินการส่วนหลัง&&หากการเติมน้ำท่วมของแขนข้างหนึ่งเสร็จสิ้น หากไม่ใช่ด้านซ้ายจะประเมินเป็นสตริงว่าง

y/{c/z / > 0

รีสตาร์ทการเติมน้ำท่วมและกลับ 1 ถ้าเติมน้ำท่วมก่อนหน้านี้ทำอะไร มิฉะนั้นส่งคืนสตริงว่าง โค้ดทั้งหมดนี้ห่ออยู่ข้างใน

s:|.: code :seg

ดังนั้นหากสิ่งนี้ถูกดำเนินการในสตริงเริ่มต้น$_ด้วยzที่ตำแหน่งเมล็ดชิ้นส่วนของรหัสภายในจะถูกดำเนินการหลายครั้งส่วนใหญ่กลับไม่มีอะไร แต่1ทุกครั้งที่แขนเพื่อนบ้านได้รับน้ำท่วม ได้อย่างมีประสิทธิภาพ$_ได้รับการทำลายและถูกแทนที่ด้วยเป็นจำนวนมากในฐานะที่มีส่วนประกอบที่เกี่ยวโยงกันที่แนบมากับ1 zขอให้สังเกตว่าการวนซ้ำจะต้องดำเนินการจนถึงผลรวมของขนาดส่วนประกอบ + จำนวนครั้งของอาวุธ แต่ก็ตกลงเพราะจะ "จำนวนตัวอักษรรวมถึงการขึ้นบรรทัดใหม่ * 2 + 1" ครั้ง

เขาวงกตจะถูกตัดการเชื่อมต่อหากไม่มี1(สตริงว่างเปล่า, จุดยอดที่แยกได้) หรือหากมีมากกว่า 1 แขน (มากกว่า 2 1วินาที) สิ่งนี้สามารถตรวจสอบได้โดยใช้ regex /\B/(สิ่งนี้ให้0แทนที่จะเป็น1รุ่น Perl ที่เก่ากว่ามันพิสูจน์ได้ว่าอันไหนผิด) 0แต่น่าเสียดายถ้ามันไม่ตรงนี้จะให้เป็นสตริงว่างแทน แต่s:|.: code :segได้รับการออกแบบเสมอกลับเป็นเลขคี่เช่นนั้นโดยทำ&กับ/\B/นี้จะให้หรือ01

สิ่งที่เหลืออยู่ก็คือการเดินเข้าไปในอาเรย์ทั้งหมดและในแต่ละตำแหน่งเมล็ดที่สามารถเดินได้ด้วยzและนับแขนที่เชื่อมต่อ สามารถทำได้อย่างง่ายดายด้วย:

s%b%$_="$`z$'"; code %eg

ปัญหาเดียวคือในตำแหน่งที่ไม่สามารถเดินได้ค่าเก่าจะถูกเก็บไว้ เนื่องจากเราต้องการ0ที่นั่นนั่นหมายถึงอาร์เรย์อินพุตดั้งเดิมต้อง0อยู่ในตำแหน่งที่ไม่สามารถเดินได้และ0จับคู่\wในการทดแทนเดิมและจะทำให้เกิดการเติมน้ำท่วม นั่นเป็นเหตุผลที่ฉันใช้\pLแทน (จับคู่ตัวอักษรเท่านั้น)

Java 8, 503 489 459 455 ไบต์

int R,C,v[][];m->{int c[][]=new int[R=m.length][C=m[0].length],r[][]=new int[R][C],i=R*C,t,u;for(;i-->0;)c[t=i/C][u=i%C]=m[t][u];for(;++i<R*C;r[t][u]=i(c)!=i(m)?1:0,c[t][u]=m[t][u])c[t=i/C][u=i%C]=0;return r;}int i(int[][]m){int r=0,i=0,t,u;for(v=new int[R][C];i<R*C;)if(m[t=i/C][u=i++%C]>v[t][u]){d(m,t,u);r++;}return r;}void d(int[][]m,int r,int c){v[r][c]=1;for(int k=-3,t,u;k<4;k+=2)if((t=r+k/2)>=0&t<R&(u=c+k%2-k/2)>=0&u<C&&m[t][u]>v[t][u])d(m,t,u);}

-18 ไบต์ขอบคุณที่@ceilingcat

คำอธิบาย:

ลองออนไลน์

int R,C,                    // Amount of rows/columns on class-level
    v[][];                  // Visited-matrix on class-level

m->{                        // Method with int-matrix as both parameter and return-type
  int c[][]=new int[R=m.length][C=m[0].length],
                            //  Create a copy-matrix, and set `R` and `C`
      r[][]=new int[R][C],  //  Create the result-matrix
      i=R*C,                //  Index-integer
      t,u;                  //  Temp integers
  for(;i-->0;)              //  Loop `i` over each cell:
    c[t=i/C][u=i%C]=m[t][u];//   And copy the values of the input to the copy-matrix
  for(;++i<R*C              //  Loop over the cells again:
      ;                     //    After every iteration:
       r[t][u]=i(c)!=i(m)?  //     If the amount of islands in `c` and `m` are different
        1                   //      Set the current cell in the result-matrix to 1
       :                    //     Else:
        0,                  //      Set it to 0
       c[t][u]=m[t][u])     //     And set the copy-value back again
    c[t=i/C][u=i%C]=0;      //   Change the current value in the copy-matrix to 0
  return r;}                //  Return the result-matrix

// Separated method to determine the amount of islands in a matrix
int i(int[][]m){
  int r=0,                  //  Result-count, starting at 0
      i=0,                  //  Index integer
      t,u;                  //  Temp integers
  for(v=new int[R][C];      //  Reset the visited array
      i<R*C;)               //  Loop over the cells
    if(m[t=i/C][t=i++%C]    //   If the current cell is a 1,
       >v[t][u]){           //   and we haven't visited it yet:
      d(m,i,j);             //    Check every direction around this cell
      r++;}                 //    And raise the result-counter by 1
   return r;}               //  Return the result-counter

// Separated method to check each direction around a cell
void d(int[][]m,int r,int c){
  v[r][c]=1;                //  Flag this cell as visited
  for(int k=-3,u,t;k<4;k+=2)//  Loop over the four directions:
    if((t=r+k/2)>=0&t<R&(u=c+k%2-k/2)>=0&u<C
                            //   If the cell in the direction is within bounds,
       &&m[t][u]            //   and it's a path we can walk,
         >v[t][u])          //   and we haven't visited it yet:
      d(m,i,j);}            //    Do a recursive call for this cell

Python 2 , 290 ไบต์

lambda m:[[b([[C and(I,J)!=(i,j)for J,C in e(R)]for I,R in e(m)])!=b(eval(`m`))for j,c in e(r)]for i,r in e(m)]
def F(m,i,j):
	if len(m)>i>=0<=j<len(m[i])>0<m[i][j]:m[i][j]=0;F(m,i,j+1);F(m,i,j-1);F(m,i+1,j);F(m,i-1,j)
b=lambda m:sum(F(m,i,j)or c for i,r in e(m)for j,c in e(r))
e=enumerate

ลองออนไลน์!

-11 ไบต์ขอบคุณ Rod
-11 ไบต์ขอบคุณ Lynn

ภาษา Wolfram (Mathematica) , 118 ไบต์

(r=ReplacePart)[0#,Cases[#~Position~1,p_/;(c=Max@MorphologicalComponents[#,CornerNeighbors->1<0]&)@r[#,p->0]>c@#]->1]&

ลองออนไลน์!

Javascript 122 ไบต์

อินพุต / เอาต์พุตเป็นสตริงหลายบรรทัด

m=>m.replace(/./g,(v,p,m,n=[...m],f=p=>n[p]==1&&(n[p]=0,v=f(p-1)+f(p+1)+f(p-w)+f(p+w)-1?1:0,1))=>(f(p),v),w=~m.search`\n`)

สำหรับแต่ละเซลล์ที่เดินได้ให้วางบล็อกแล้วลองเติมเซลล์เพื่อนบ้านทั้ง 4 เซลล์ หากเซลล์ปัจจุบันไม่ได้เป็นจุดตัดการเริ่มต้นจากเพื่อนบ้านที่เปิดอยู่จะเติมเต็มทั้งหมด อื่นฉันจะต้องดำเนินการเติมมากกว่าหนึ่งเพื่อเข้าถึงเซลล์เพื่อนบ้านทั้งหมด

น้อย golfed

m=>{
  w = m.search('\n') + 1; // offset to the next row
  result = [...m].map( // for each cell
     ( v, // current value
       p  // current position
     ) => {
     n = [...m]; // work on a copy of the input
     // recursive fill function from position p
     // returns 1 if managed to fill at least 1 cell
     fill = (p) => {
        if (n[p] == 1)
        {
           n[p] = 0;
           // flag will be > 1 if the fill from the current point found disjointed areas
           // flag will be 0 if no area could be filled (isolated cell)
           var flag = fill(p+1) + fill(p-1) + fill(p+w) + fill(p-w);
           // v is modified repeatedly, during recursion
           // but I need the value at top level, when fill returns to original caller
           v = flag != 1 ? 1 : 0;
           return 1; // at least 1 cell filled
        }
        else
           return 0; // no fill
     }
     fill(p)
     return v // orginal value or modified by fill function
  }) 
}

ทดสอบ

var F=
m=>m.replace(/./g,(v,p,m,n=[...m],f=p=>n[p]==1&&(n[p]=0,v=f(p-1)+f(p+1)+f(p-w)+f(p+w)-1?1:0,1))=>(f(p),v),w=~m.search`\n`)

var test=`in:
11101001
11011101
00000001
11101111
11110101
00011111
10110001
11111111
out:
01000000
00001001
00000001
00000101
00110000
00010000
00000000
11100000

in:
1111111111111111
1000000000000001
1111111111111101
0000000000000101
1111111111110101
1000000000010101
1011111111010101
1010000001010101
1010111101010101
1010101111010101
1010100000010101
1010111111110101
1010000000000101
1011111111111101
1000000000000001
1111111111111111
out:
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000

in:
1011010001111010
1111111011101101
1110010101001011
1111001110010010
1111010000101001
0111101001000101
0011100111110010
1001110011111110
0101000011100011
1110110101001110
0010100111000110
1000110111011010
0100101000100101
0001010101100011
1001010000111101
1000111011000010
out:
0000000000111010
1011110001001000
0000000000000011
0000000100010000
0000010000101000
0000001000000100
0000000011000000
1001100000011110
0000000001000010
0110100001000110
0000100101000010
1000100000000000
0100001000000100
0000000100100001
0000010000111000
0000010000000010
`.match(/\d[10\n]+\d/g);
for(i = 0; test[2*i]; ++i)
{
   input = test[2*i]
   check = test[2*i+1]
   result = F(input)
   ok = check == result
   console.log('Test '+ i + ' ' + (ok?'OK':'FAIL'),
   '\n'+input, '\n'+result)
}