세균성 확장

25

박테리아 콜로니 표지 1통해 9빈 셀에 의해 표시하여, 균일 한 깊이의 셀 세그먼트 라이브0

0 0 2 0 0 0 1 2 0 0 3 3 0 0

매 초마다 각 식민지는 인접한 빈 세포로 퍼집니다. 두 식민지가 동시에 빈 세포에 도달하면 더 큰 레이블이 붙은 식민지가 그것을 취합니다.

t=0:  0 0 2 0 0 0 1 2 0 0 3 3 0 0
t=1:  0 2 2 2 0 1 1 2 2 3 3 3 3 0
t=2:  2 2 2 2 2 1 1 2 2 3 3 3 3 3

식민지는 경계를 넘어 퍼질 수 없습니다. 식민지는 다른 식민지로 대체되지 않으므로 빈 셀이 모두 채워지면 더 이상 변경되지 않습니다.

초기 상태가 주어지면 최종 상태를 출력하거나 인쇄합니다. 합리적인 목록 또는 문자열 형식을 사용하십시오. 중간 상태를 출력해서는 안됩니다. 투입물에는 적어도 하나의 박테리아 콜로니가 포함됩니다.

관련 : 목록에서 0을 가리십시오 . (식민지는 오른쪽으로 만 퍼졌다.)

테스트 사례 : 입력 아래 출력.

0 0 2 0 0 0 1 2 0 0 3 3 0 0
2 2 2 2 2 1 1 2 2 3 3 3 3 3

7 0 3 0 0 0 0 0 8 0 9 1
7 7 3 3 3 8 8 8 8 9 9 1

5 0 3 0 0 0
5 5 3 3 3 3

7 7 1
7 7 1

1 0 1
1 1 1

코드 스 니펫 표시

code-golf  cellular-automata 
— xnor
소스

답변:

14

자바 스크립트 (ES6), 66 62 바이트

a=>a.map(_=>a=a.map((c,i)=>c||Math.max(a[i-1]|0,a[i+1]|0)))&&a

설명

a=>                 // a = input as array of numbers
  a.map(_=>         // loop for the length of a, this ensures the end is always reached
    a=a.map((c,i)=> // update a after to the result of t, for each cell c of index i
      c||           // keep the cell if it is not 0
        Math.max(   // else set the cell to the max value of:
          a[i-1]|0, //     the previous cell (or 0 if i - 1 less than 0),
          a[i+1]|0  //     or the next cell (or 0 if i + 1 greater than the length of a)
        )
    )
  )
  &&a               // return a

테스트

코드 스 니펫 표시

— 사용자 81655
소스
10

Pyth, 18 바이트

um|@d1eSd.:++0G03Q

테스트 스위트

정수 목록으로 입력을받습니다.

본질적으로 이것은 수렴 루프까지 적용을 사용합니다 u. 각 셀과 두 셀의 모든 목록을 한쪽에 형성 한 다음 각 제로화 셀을 이웃의 최대 값으로 업데이트하여 업데이트를 적용합니다.

um|@d1eSd.:++0G03Q
                      Implicit: Q = eval(input())
u                Q    Apply the following until convergence, starting with G = Q.
           ++0G0      Pad G with zeros on either side.
         .:     3     Form all 3 element substrings.
                      Now, for each element of G, we have a list of the form
                      [previous, current, next]
 m                    Map over this list
  |@d1                The current element, if it's nonzero
      eSd             Else the max of the list.
— 아이작
소스
8

Mathematica, 77 바이트

alephalpha의 //.솔루션 과 비교할 때 경쟁이 치열 하지는 않지만 셀룰러-오토 마타 도전에 CellularAutomaton답이 있어야한다고 생각했습니다 .

CellularAutomaton[{If[#2<1,Max@##,#2]&@@#&,{},1},{#,0},{{{l=Length@#}},l-1}]&

이 함수는 많은 매개 변수를 사용합니다.

CellularAutomaton[{f,n,r},{i,b},{{{t}},d}]

그들이하는 일은 다음과 같습니다.

  • r규칙의 범위입니다. 즉, 업데이트에 대해 몇 개의 이웃이 고려되는지 결정합니다. 우리는 양쪽에 이웃을 하나씩 원하기 때문에를 사용 1합니다.
  • n일반적으로 색상의 수 또는 색상 목록 (다른 셀 유형)이지만 규칙 번호 대신 사용자 지정 함수로 규칙을 지정하는 경우이 값은이어야합니다 {}.
  • f업데이트 규칙을 결정하는 함수입니다. 3 개의 셀 목록 (if r = 1)을 가져 와서 가운데 셀의 새 색상을 반환합니다.
  • i초기 조건입니다. 그게 입력입니다.
  • b배경입니다. 이것이 주어지지 않으면 CellularAutomaton, 우리가 원하지 않는주기적인 경계를 사용합니다. 대신 사용 0하면 데드 바운더리 조건이 부과됩니다.
  • t시뮬레이션 횟수입니다. 우리는 입력이 넓은 것보다 더 많은 단계를 필요로하지 않습니다. 그 후에 박테리아가 수렴 될 것 t = Length@#입니다. 일반적으로 CellularAutomaton모든 중간 단계를 반환합니다. 우리는 t두 개의 목록 으로 감싸서 피할 수 있습니다 .
  • d출력에 표시 할 셀을 결정합니다. 기본적으로 규칙의 영향을받을 수있는 모든 셀 ( t*r입력의 양쪽 끝에있는 추가 셀)을 가져옵니다. l-1이것은 0부터 시작하는 인덱스가 사용되는 Mathematica의 몇 가지 상황 중 하나이기 때문에 제공합니다 .
— 마틴 엔더
소스
6

하스켈, 86 83 81 79 73 71 바이트

(0#r)l=max r l
(o#_)_=o
p!_=zipWith3(#)p(0:p)$tail p++[0] 
id>>=foldl(!)

사용 예 : id>>=foldl(!) $ [7,0,3,0,0,0,0,0,8,0,9,1]-> [7,7,3,3,3,8,8,8,8,9,9,1].

설명 할 것이 많지 않습니다 : 셀이 0이면 최대 인접 요소를 사용하십시오. 입력 시간을 반복하십시오. 이를 위해 xvia를 통해 반복 foldl하지만의 두 번째 인수는 무시하십시오 p.

편집 : @Mauris는 6 바이트를 저장하고 @xnor는 다른 두 개를 찾았습니다. 감사!

— 니미
소스
당신은 대체 할 수 h p와 p!_다음 교체 (const.h)와 (!)6 저장 바이트.
— Lynn
@Mauris : 영리합니다. 고마워요!
— nimi
@nimi 나는 마지막 줄이 익명이라고 생각한다 id>>=foldl(!).
— xnor
@ xnor : 그렇습니다! 잘 발견되었습니다!
— nimi
4

CJam, 27 24 바이트

{_,{0\0++3ew{~@e>e|}%}*}

여기에서 테스트하십시오.

이렇게하면 이름없는 블록이 푸시되어 스택의 목록을 새 목록으로 변환합니다.

설명

_,       e# Duplicate the input and get its length N.
{        e# Run this block N times (convergence won't take that long)...
  0\0++  e#   Wrap the list in two zeroes.
  3ew    e#   Get all sublists of length 3.
  {      e#   Map this block onto each sublist...
    ~    e#     Dump all three elements on the stack.
    @    e#     Pull up the left neighbour.
    e>   e#     Maximum of both neighbours.
    e|   e#     Logical OR between centre cell and maximum of neighbours.
  }%
}*
— 마틴 엔더
소스
컨버전스를 피하는 것은 좋은 트릭
— 루이스 Mendo
1
... 내가 뻔뻔스럽게 빌린 :-)
— Luis Mendo
4

J, 24 23 바이트

(+=&0*(0,~}.)>.0,}:)^:_

용법:

   ((+=&0*(0,~}.)>.0,}:)^:_) 0 1 5 0 0 0 6
1 1 5 5 6 6 6

방법은 Mauris의 솔루션 과 유사합니다 .

(                  )^:_ repeat until change
               0,}:     concat 0 and tailless input
      (0,~}.)           concat headless input and 0
             >.         elementwise maximum of the former two lists
  =&0*                  multiply by input_is_0 (zeroing out the list at nonzero input positions)
 +                       add to input

여기에서 온라인으로 사용해보십시오.

Zgarb 덕분에 1 바이트가 절약되었습니다.

— 랜덤
소스
3

매스 매 티카, 77 74 66 62 바이트

Martin Büttner 덕분에 12 바이트가 절약되었습니다.

#//.i_:>BlockMap[If[#2<1,Max@##,#2]&@@#&,Join[{0},i,{0}],3,1]&
— 알레프 알파
소스
3

J, 33 바이트

3 :'y+(y=0)*>./(_1,:1)|.!.0 y'^:_

내가 원했던 것보다 조금 더

3 :'                         '^:_   Repeat a "lambda" until a fixed point:
                            y         The input to this lambda.
               (_1,:1)|.!.0           Shift left and right, fill with 0.
            >./                       Maximum of both shifts.
      (y=0)*                          Don't grow into filled cells.
    y+                                Add growth to input.
— 린
소스
그것은 내가 가진 것과는 매우 다릅니다, 나는 당신이 답으로 그것을 게시해야한다고 생각합니다 :)
— Lynn
3

파이썬 3.5, 83 바이트

이 함수는 파이썬의 정수 목록을받습니다. 골프에 남은 것이 많지는 않지만 적어도 다른 언어와 경쟁하기를 원합니다!

def b(s):
 for _ in s:s=[s[n]or max((0,*s)[n:n+3])for n in range(len(s))]
 return s

Python 3.5부터 PEP 448을 사용 s하여 압축 을 풉니 다 0,*s. 이전 릴리스에는 다음과 같이 1 바이트가 더 필요합니다.

def b(s):
 for _ in s:s=[s[n]or max(([0]+s)[n:n+3])for n in range(len(s))]
 return s

에 신용 user81655의 솔루션 및 설명 나를 돕는 목록이 변경 중지 여부를 제가 테스트 할 필요가 없습니다 것을 깨닫게; 나는 모든 0을 덮 었는지 확인하기 위해 충분한 시간을 반복해야합니다. (필요한 최대 반복 횟수는 목록 길이보다 1이 적습니다. 코드를 덜 사용하기 때문에 반복 횟수가 1 회 더 많습니다.)

— 팀 페 데릭
소스
@ChrisH : 그것은 파이썬 3.5에 대한 작업을하지 않고, 나도 그 이전 버전에서 작동 것이라고 생각하지 않습니다 : (가) 움직이지 않는 return로 내부for _ in s 루프?
— Tim Pederick
주석이 삭제됨-처음 해결되는 테스트 사례 만 시도했습니다.
— Chris H
3

Matlab, 90 바이트

컨볼 루션은 어떻습니까?

x=input('');for n=x;x=x+max(conv(x,[0 0 1],'same'),conv(x,[1 0 0],'same')).*~x;end;disp(x)

예

>> x=input('');for n=x;x=x+max(conv(x,[0 0 1],'same'),conv(x,[1 0 0],'same')).*~x;end;disp(x)
[7 0 3 0 0 0 0 0 8 0 9 1]
     7     7     3     3     3     8     8     8     8     9     9     1
— 루이스 멘도
소스
3

하스켈, 66 65 바이트

f x=[maximum[[-j*j,a]|(j,a)<-zip[-i..]x,a>0]!!1|(i,_)<-zip[0..]x]

라는 함수를 정의합니다 f.

설명

셀룰러 오토 마톤을 반복하는 대신 최종 값을 직접 계산합니다. 정의는 단일 목록 이해입니다. 자연수로 압축하므로 값의 i범위는 0~ 입니다. 각 인덱스 에 대해 2 요소 목록을 생성합니다.length x - 1xi

[-(-i)^2, x0], [-(-i+1)^2, x1], [-(-i+2)^2, x2], ..., [-(-i+n)^2, xn]

이 목록에서 두 번째 좌표가 0이 아닌 최대 요소를 계산하고을 사용하여 두 번째 요소를 가져옵니다 !!1. 이것은 index에 가장 가까운 0이 아닌 값을 제공하고 i더 큰 값을 취함으로써 관계를 끊습니다.

— 자브
소스
현상금을 획득 한 것을 축하합니다!
— xnor
2

루아, 133 바이트

루프가 두 개이고 중첩 된 삼항 ... 골프를 더하고 싶다면 다른 방법을 찾아야하지만 하나는 보이지 않습니다.

function f(a)for i=1,#a do b={}for j=1,#a do c,d=a[j+1]or 0,a[j-1]b[j]=0<a[j]and a[j]or(d or 0)>c and d or c end a=b end return a end

설명

function f(a)
  for i=1,#a                       -- this loop allow us to be sure the cycle is complete
  do
    b={}                           -- set a new pointer for b
    for j=1,#a                     -- loop used to iterate over all elements in a
    do
      c,d=a[j+1]or 0,a[j-1]        -- gains some bytes by attributing these expressions 
                                   -- to a variable
      b[j]=0<a[j]and a[j]or        -- explained below
            (d or 0)>c and d or c
    end
    a=b                            -- we are one cycle further, new value for a
  end                              -- which is our reference array
  return a
end

부분

b[j]=0<a[j]and a[j]or(d or 0)>c and d or c

로 확장됩니다 

b[j]=0<a[j]and a[j]or(a[j-1] or 0)>(a[j+1] or 0) and a[j-1] or(a[j+1]or 0)

다음 if과 같이 중첩 으로 번역 될 수 있습니다.

if 0<a[j]
then
    value=a[j]          -- if the cell isn't at 0, it keeps its value
elseif (a[j-1] or 0)<(a[j+1] or 0)
--[[ x or y as the following truth table :
x | y ||x or y
------||-------
0 | 0 || false
0 | 1 ||   y
1 | 0 ||   x
1 | 1 ||   x
    -- It means that when j=1 (1-based) and we try to index a[j-1]
    -- instead of failing, we will fall in the case false or true
    -- and use the value 0
    -- the same trick is used for when we try to use an index > a:len
]]--
then
    value=a[j-1]        -- the left cell propagate to the cell j
else
    value=a[j+1] or 0   -- if j=a:len, we put 0 instead of a[j+1]
                        -- this case can only be reached when we are on the right most cell
                        -- and a[j-1]==0
end
— 카테 쿄
소스
1

Pyth, 17 바이트

meeSe#.e,_akdbQUQ

stdin에서 파이썬 스타일 목록을 가져 와서 stdout으로 출력합니다.

설명

이것은 기본적으로 내 Haskell 답변의 번역입니다. 나는 Pyth를 실제로 사용하지 않았으므로 힌트를 환영합니다.

                   Implicit: Q is input list
m              UQ  Map over input index d:
      .e      Q     Map over input index k and element b:
        ,_akdb       The pair [-abs(k-d), b]
    e#              Remove those where b==0
 eeS                Take the second element of the maximal pair
— 자브
소스
1

APL (Dyalog) , 18 바이트

익명의 암묵적 접두사 기능.

(⊢+~∘××3⌈/0,,∘0)⍣≡

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

(… )⍣≡ 결과가 인수와 동일 할 때까지 다음 암묵적 기능을 적용하십시오.

 ⊢ 논쟁 거리

 + ...을 더한

  ~ 하지  부호 요소
  ∘
  ×

 × 타임스

 3⌈/ 세 그룹의 각 그룹에 대한 최대

 0, 다음에 0

  , 인수는 다음  제로
  ∘
  0

— 아담
소스
1

자바 8, 155142 바이트

a->{for(int b[],i,l=a.length,p,n,f=l;f>0;)for(b=a.clone(),i=0,f=l;i<l;f-=a[i-1]>0?1:0)if(a[i++]<1)a[i-1]=(p=i>1?b[i-2]:0)>(n=i<l?b[i]:0)?p:n;}

int[]바이트를 절약하기 위해 새 입력 을 반환하는 대신 입력을 수정합니다 .

설명:

여기에서 시도하십시오.

a->{                   // Method with integer-array parameter and no return-type
  for(int b[],         //  Copy array
          i,           //  Index integer
          l=a.length,  //  Length of the array
          p,n,         //  Temp integers (for previous and next)
          f=1;         //  Flag integer, starting at 1
      f>0;)            //  Loop (1) as long as the flag is not 0 (array contains zeroes)
    for(b=a.clone(),   //   Create a copy of the current state of the array
        i=0,           //   Reset the index to 0
        f=l;           //   Reset the flag to the length of the array `l`
        i<l;           //   Inner loop (2) over the array
        f-=a[i-1]>0?   //     After every iteration, if the current item is not a zero:
            1          //      Decrease flag `f` by 1
           :           //     Else:
            0)         //      Leave flag `f` the same
      if(a[i++]<1)     //    If the current item is a 0:
        a[i-1]=        //     Change the current item to:
         (p            //      If `p` (which is:
           =i>1?       //        If the current index is not 0:
             b[i-2]    //         `p` is the previous item
            :          //        Else:
             0)        //         `p` is 0)
         >(n           //      Is larger than `n` (which is:
            =i<l?      //        If the current index is not `l-1`:
              b[i]     //         `n` is the next item
             :         //        Else:
              0)?      //         `n` is 0):
          p            //       Set the current item to `p`
         :             //      Else:
          n;           //       Set the current item to `n`
                       //   End of inner loop (2) (implicit / single-line body)
                       //  End of loop (1) (implicit / single-line body)
}                      // End of method
— 케빈 크루이 센
소스
0

루비, 81 바이트

->(a){a.map{|o|a=a.map.with_index{|x,i|x!=0 ? x : a[[0,i-1].max..i+1].max}}[-1]}

내면 map이 더 골프를 칠 수 있다고 생각합니다 .

— 가혹한 굽타
소스
방금 내 대답은 @ user81655의 대답 과 동일합니다 .
— Harsh Gupta
난 당신이, 즉 주위, 삼항의 공백을 제거 할 수 있다고 생각 ?하고 :.
— Alex A.
0

PHP - 301 개 291 289 288 264 문자

이것을 시도하기 전에 다른 답변에서 정점에 도달하지 않았습니다. 언어를 비난하지 말고 나를 비난하십시오. 덜 즐겁고 덜 도전적입니다. 모든 코드 골프 조언은 대단히 감사합니다.

$a=explode(' ',$s);$f=1;while($s){$o=1;foreach($a as&$b){
if($b==0){$u=current($a);prev($a);$d=prev($a);if(!$o&&current($a)==0){end($a);$d=prev($a);}if(!$f){$f=1;continue;}if($u>$d)$b=$u;if($u<$d){$b=$d;$f=0;}}
$o=0;}if(!in_array(0,$a))break;}$r=join(' ',$a);echo$r;

설명

// Input
$s = '0 0 2 0 0 0 1 2 0 0 3 3 0 0';

// Create array
$a = explode(' ', $s);
// Set skip flag
$f = 1;
while ($s)
{
    // Set first flag
    $o = 1;
    // Foreach
    foreach ($a as &$b)
    {
        // Logic only for non zero numbers
        if ($b == 0)
        {
            // Get above and below value
            $u = current($a);
            prev($a);
            $d = prev($a);

            // Fix for last element
            if (! $o && current($a) == 0)
            {
                end($a);
                $d = prev($a);
            }

            // Skip flag to prevent upwards overrun
            if (! $f)
            {
                $f = 1;
                continue;
            }

            // Change zero value logic
            if ($u > $d)
                $b = $u;
            if ($u < $d)
            {
                $b = $d;
                $f = 0;
            }
        }

        // Turn off zero flag
        $o = 0;
    }

    // if array contains 0, start over, else end loop
    if (! in_array(0, $a))
        break;
}
// Return result
$r = join(' ', $a);
echo $r;(' ', $a);
echo $r;
— 거위
소스
1
진심이야? 골프는 단순히 코드에서 공백을 제거하는 것이 아닙니다. 알고리즘 외에도, 여기에 몇 가지 도움말 : 사용 1하기보다는 true, split보다는 explode, for대신 while, join대신 implode, 쓸모 중괄호 제거는 ...
— 블랙홀
분할이 감가 상각되기 때문에 나는 계속 폭발했습니다. 또한 for 루프를 사용하여 while 루프를 작성하는 방법을 모르므로 여기 누군가가 지식을 공유하거나 링크를 공유 할 수 없다면 지금은 유지했습니다. 모두 감사합니다.
— Goose
0

파이썬, 71 바이트

g=lambda l:l*all(l)or g([l[1]or max(l)for l in zip([0]+l,l,l[1:]+[0])])

는 zip로 엔드 포인트를 넘어 치료, 요소 및 이웃의 모든 길이 3 하위 목록을 생성합니다 0. 중앙 요소 l[1]의 하위 목록은 l제로 경우로 대체 max와 그 이웃 l[1]or max(l). 이 없는 경우 l*all(l)목록을 반환합니다 .l0

— xnor
소스
0

루비, 74 바이트

->a{(r=0...a.size).map{|n|a[r.min_by{|i|[(a[i]<1)?1:0,(i-n).abs,-a[i]]}]}}

0이 아닌 가장 가까운 숫자를 찾아서 작동합니다.

— 메가 톰
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.