Bir labirentte kesme noktaları


13

Bir labirent herhangi bir uygun formatta 0s (duvarlar) ve 1s (yürünebilir alan) matrisi olarak verilir. Her hücre 4 (veya daha az) dik komşusuna bağlı olarak kabul edilir. Bir bağlantılı bileşen tüm geçişli birbirine bağlı yapılabilen hücre kümesidir. Göreviniz kesme noktalarını tanımlamaktır - duvarlara dönüştürüldüğünde bağlı bileşenlerin sayısını değiştirecek olan yürünebilir hücreler. Yalnızca bu konumlarda 1-s ile bir boole matrisi çıktılayın. Amaç bunu en az byte kodda yapmaktır.

Giriş matrisi en az 3 satır ve 3 sütundan oluşur. Hücrelerinden en az biri duvar olacak ve en az biri yürünebilir olacak. İşleviniz veya programınız TIO'da (veya dil TIO tarafından desteklenmiyorsa, kendi bilgisayarınızda) aşağıdaki örneklerden herhangi birini bir dakikadan kısa sürede işleyebilmelidir .

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

böylece, tüm alt bölümlerdeki tüm köprüleri bulun
HyperNeutrino

1
Zorluğun daha küçük bir matris için adım adım bir örnek alacağını düşünüyorum.
Bay Xcoder

1
@HyperNeutrino bir köprü farklı bir şey - kaldırılması bağlı bileşenlerin sayısını artıran bir kenar (tepe noktası değil)
ngn

1
@HyperNeutrino da, bir alt
çizgi

1
@Notatree Haklısın. Bir hata yaptım. Şimdi düzeltmek için çok geç ama umarım eğlenceyi bozmaz.
ngn

Yanıtlar:


3

Stax , 40 bayt

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

Test senaryolarını çalıştırma ve hata ayıklama

Bu program girişi satır içeren boşlukla ayrılmış bir dize olarak alır. Çıktı aynı biçimde. İşte ambalajsız ascii temsili.

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

Bir ada saymak için temel operasyon böyle çalışır.

  1. İlkini '1'a ile değiştirin '2'.
  2. Yerine regex '12|21'ile '22'.
  3. Boşluklara bölün.
  4. Devrik matris.
  5. Bir dize tekrarlanıncaya kadar tekrarlayın 2..
  6. Dizede artık a kalmayıncaya kadar 1. adımını yineleyin '1'. Tekrar sayısı ada sayısıdır.

.

{               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

Bonus 44 bayt programı - bu sürüm ızgara biçimini kullanarak girer ve çıkar.


ikinci örneği bilgisayarınızda bir dakikadan kısa sürede işler mi?
ngn

@ngn: Chrome'daki bu orta sınıf dizüstü bilgisayarda 41'lerde her üç örneği de yapıyor. Ayrıca, ana bağlantıyı düzelttim. Yanlışlıkla eski bir çalışma sürümüne ayarlı bıraktım.
özyinelemeli

3

MATL , 26 bayt

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

Giriş, ;satır ayırıcı olarak kullanılan sayısal bir matristir .

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

açıklama

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

2

Perl 5 , -p0 105 101 96 93 90 89 bayt

Girdi byerine kullanır 1.

STDIN üzerindeki matrisin bir satırsonu ile sonlandığından emin olun

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

Çevrimiçi deneyin!

3 ikame seviyesi kullanır!

Bu 87 baytlık sürümün hem giriş hem de çıkış biçiminde yorumlanması daha kolaydır, ancak çıkışta 3 farklı karakter kullandığından rekabet etmez:

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

Çevrimiçi deneyin!

sSatır sonlandırıcı olarak farklı bir (alfasayısal olmayan) karakter (satırsonu yerine) kullanarak başka bir bayt (regex değiştirici) her iki sürümde kaydetmek kolaydır , ancak bu giriş tekrar okunamaz hale gelir.

Nasıl çalışır

Değişikliği düşünün

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

Bu, yatay ve dikey olarak farklı ve yan yana olan iki harfi bularak yerini alacaktır c. Yolları tamamen bharflerden oluşan bir labirentte, harfler aynı olduğu için hiçbir şey olmayacaktır, ancak harflerden biri diğeriyle değiştirilir değiştirilmez (örn. z) Bu harf ve bir komşu ile değiştirilir cve tekrarlanan uygulama bir bağlı bileşenin ctohumdan taşkın dolgusu z.

Ancak bu durumda tam bir taşkın dolgu istemiyorum. Komşu kollardan sadece birini doldurmak istiyorum z, bu yüzden ilk adımdan sonra zgitmeyi istiyorum . Bu zaten c$2cdeğiştirme ile çalışıyor , ancak daha sonra aynı noktadan başlayarak başka bir kol boyunca bir taşkın dolgusunu yeniden başlatmak istiyorum ve hangisinin artık corijinal olduğunu bilmiyorum z. Onun yerine kullanıyorum

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

b | aolduğunu c, b | colduğunu cve z | aolduğunu {. Böylece, yollardan oluşan bir labirentte ve ilk adımdaki bbir tohum yerine geçecek ve yerini alacak ve bir harf değil, eşleşmeyecek ve daha fazla doluma neden olmayacaktır. Ancak gidiş bir başka sel dolgu tutacak ve tohumun bir komşu kolu doldurulur. Örneğinzbcz{\wc

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

Sonra olmayan bazı harf (örn bütün c yerini alabilir -) ve değiştirme {yoluyla zsel-dolgu yeniden başlatmak için tekrar:

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

ve tohumun tüm komşuları dönüştürülene kadar bu işlemi tekrarlayın. Sonra bir kez daha değiştirin {tarafından zve taşkın dolgu:

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

zSonunda geride kalır bir dönüşüm yapmak için hiçbir komşu olduğundan. Bu, aşağıdaki kod parçasında neler olduğunu netleştirir:

/\n/ >                                    

İlk yeni satırı bulun. Başlangıç ​​ofseti şimdi@-

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

Yukarıda @{-}sütun sayısı olarak tartışılan normal ifade (düz @-perl ayrıştırıcısını karıştırdığı ve düzgün bir şekilde yer değiştirmediği için)

&&

Her /\n/zaman başarılı olur ve sübvansiyonu doldurabildiğimiz sürece oyuncu değişikliği doğrudur. Böylece, &&bir kolun taşkın dolgusu yapılırsa sonraki kısım yürütülür. Değilse, sol taraf boş bir dize olarak değerlendirilir

y/{c/z / > 0

Taşkın dolgusunu yeniden başlatın ve önceki taşkın dolgusu bir şey yaptıysa 1 değerini döndürün. Else boş dizeyi döndürür. Bu kodun tamamı içeri sarılmış

s:|.: code :seg

Bu bir başlangıç ipe yürütüldüğünde Yani eğer $_bir ile ztohum pozisyonunda kod içeriden parçası çoğunlukla hiçbir şey dönen birçok kez idam edilecek ama 1her zaman bir komşu kol sel dolu alır. Etkili bir şekilde $_yok edilir ve 1bağlı bileşenler olduğu kadar çok s ile değiştirilir z. Döngünün bileşen boyutu + silah sayısı toplamına kadar yürütülmesi gerektiğine dikkat edin, ancak sorun yok, çünkü "yeni satırlar * 2 + 1 dahil karakter sayısı".

Labaratörün bağlantısı yoksa 1(boş dize, yalıtılmış bir tepe noktası) veya 1'den fazla kol (2 1saniyeden fazla) varsa. Bu regex kullanılarak kontrol edilebilir /\B/(bu eski perl sürümleri 0yerine verir 1. Hangisinin yanlış olduğu tartışılabilir). Ne yazık ki bu eşleşmezse bunun yerine boş bir dize verir 0. Ancak s:|.: code :segher zaman yaparak bu yüzden bir tek sayısını döndürmek için tasarlanmış &olan /\B/bu verecektir 0ya 1.

Geriye kalan tek şey tüm girdi dizisini ve her yürünebilir pozisyon tohumunda zbağlı kollarla yürümek ve saymaktır. Kolayca şu şekilde yapılır:

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

Tek sorun, yürünemeyen pozisyonlarda eski değerin korunmasıdır. Buraya ihtiyacımız 0olduğu için, orijinal giriş dizisinin 0yürünemez konumlarda olması ve orijinal ikamedeki 0eşleşmelerde \wolması ve taşkın dolgularını tetiklemesi gerektiği anlamına gelir . Onun için \pLkullanıyorum (sadece harfleri eşleştir).


2

Java 8, 503 489 459 455 bayt

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

@Ceilingcat sayesinde -18 bayt .

Açıklama:

Çevrimiçi deneyin.

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

1

Python 2 , 290 bayt

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

Çevrimiçi deneyin!

Rod
sayesinde -11 bayt Lynn sayesinde -11 bayt


1
F(m,i,j)Her eleman için kullanımı daha kısa , 11 bayt tasarruf
Rod

for q in((i,j+1),(i,j-1),(i+1,j),(i-1,j)):-> for q in(i,j+1),(i,j-1),(i+1,j),(i-1,j):- rm dış parens
ngn

Yana Förtülü olarak getiri Nonekullanabileceğiniz F(m,i,j)or cyerine [F(m,i,j)]and c.
Lynn

Ayrıca, and m[i][j]olabilir >0<m[i][j]ve [q[:]for q in m]olabilir eval(`m`).
Lynn

@Lynn demek eval ('m')? aynı liste örneğini döndürmez mi?
ngn


1

Javascript 122 bayt

Çok satırlı bir dize olarak giriş / çıkış.

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

Yürünebilir her hücre için bir blok koyun ve 4 komşu hücreyi doldurmaya çalışın. Mevcut hücre bir kesme noktası değilse, herhangi bir açık komşudan başlamak hepsini doldurur. Aksi takdirde, tüm komşu hücrelere ulaşmak için birden fazla doldurma işlemine ihtiyacım olacak.

Daha az golf

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

Ölçek

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

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.