소개

비는 마침내 가라 앉았습니다. @ user12345의 코드 버그로 인해 대부분의 인류가 익사했습니다 . 생존자들은 전 세계 열도에 흩어져 있습니다. 무선 통신이 활성화되었으며 인류는 한 번 더 번성 할 수 있습니다. 어쨌든, 좀비 해적들은 프라임 자오선에 모여 서쪽을 휩쓸고 있습니다. 무리는 모든 것을 삼킨다.

문제

우리의 종말 시나리오는 협력 섬 공동체의 집합을 나타내는 한 줄에 5 개의 정수로 설명 할 수 있습니다. 그것들은 서쪽 (가장 왼쪽 정수)에서 동쪽 (가장 오른쪽 정수)으로 정렬됩니다.

가장 동쪽에있는 섬에서 시작하여 섬 사람들은 다음으로 가장 가까운 섬으로 쌍으로 도망합니다. 흥미롭게도, 착수하는 각 쌍마다 그 중 하나만이 여행에서 살아남습니다. 섬 사람들 은 쌍으로 만 여행합니다. 홀수 인구는 뒤에 머물고 좀비 해적 무리의 장난에 대한 최신 라디오 업데이트를 제공 할 유일한 주민을 선택합니다. 인구는 동쪽의 모든 섬이 이주를 완료하거나 사망 할 때까지 여행을 거부합니다. 인구가 최 서단에 도달하면 여행이 중단됩니다.

세계 끝에있는 운영 관리자는 각 마을의 최종 인구 수를 출력 할 수있는 프로그램이 필요합니다.

입력 예

3 8 6 0 2

출력 예

8 1 0 1 0

가정

• 입력은 stdin을 통해 제공되거나 임의로 이름이 지정된 파일에서 읽거나 인수로 허용 될 수 있습니다.
• 각 섬에 대해 0 <= 인구 <= 1024
• 인구는 결코 섬을 건너 뛰지 않습니다

최단 답변이 승리합니다!

APL, 16 자

{(1e9,4⍴2)⊤2⊥⍎⍵}

입력은이 블록에 문자열로 제공됩니다.

{(1e9,4⍴2)⊤2⊥⍵} "3 8 6 0 2"
8 1 0 1 0

입력이이 블록에 대한 인수로 제공되는 경우 1 문자 이하

{(1e9,4⍴2)⊤2⊥⍵} 3 8 6 0 2
8 1 0 1 0

이 의견 에서 Ilmari Karonen의 아이디어를 기반으로합니다 .

• 2⊥⍵ 입력의 기본 2 변환을 수행합니다.
• (1e9,4⍴2)⊤따라서이 숫자를 밑수 2 (마지막 4 자리)와 밑수 1e9 (첫 번째 숫자 1)로 다시 변환하면 위에서 주어진 입력 범위에 충분합니다. ( 1e9,4⍴2목록을 작성합니다 1e9 2 2 2 2.)

이 과정에서 기저 서쪽은 기본 변환에 의해 자동으로 수행됩니다.

GolfScript, 23 22 자

~]{{.2/@+\2%}*]}4*' '*

반복적 인 접근. 배열은 여러 번 반복되며 매번 여러 쌍이 오른쪽에서 왼쪽으로 전송됩니다. 온라인 예제를 사용해보십시오 .

코드에 대한 간단한 설명 :

~]       # convert input to an integer
{        # loop 4 times (enough for a 5-elements input)
  {      # inject this block into the array
    .    # duplicate (l r r)
    2/   # determine surviving people (l r r%2)
    @+\  # add to the left (l+r/2 r)
    2%   # determine remaining people (l+r/2 r%2)
  }*
  ]      # make array again of the results
}4*
' '*     # format output

GolfScript (25 자)

~]-1%{\.1&\2/@+}*]-1%' '*

온라인 데모

매우 간단한 해결책 : 각 섬의 출력 값을 입력 값의 함수로 정의하는 더 흥미로운 접근법이 있지만 질문에 설명 된 재배포 알고리즘을 실제로 따르는 한 골프를 칠 수 있다고 생각하지 않습니다.

자바 스크립트 / ES6 (69)

비트 연산자로 재생 :

• x&=1 가장 낮은 비트를 유지합니다 (홀수이면 1, 짝수이면 0)
• x>>1 정수의 경우 2로 나눕니다.

f=a=>{a=a.split(' ');for(i=5;--i;a[i]&=1)a[i-1]-=-(a[i]>>1);return a}

ES6없는 버전 :

function f(a){a=a.split(' ');for(i=5;--i;a[i]&=1)a[i-1]-=-(a[i]>>1);return a}

예 :
f("3 8 6 0 2")반품 [8, 1, 0, 1, 0]
f("0 997 998 999 1000")반환[935, 0, 1, 1, 0]

파이썬-96 자

처음으로 골프! stdin에서 입력

n=map(int,raw_input().split())
x=4
while x:n[x-1]+=n[x]/2;n[x]%=2;x-=1
print' '.join(map(str,n))

J (26 자)

J의 솔루션은 다음과 같습니다. ((<.@-:@}.,0:)+{.,2|}.)^:_

   islands1 =: 3 8 6 0 2
   islands2 =: 3 8 6 3 2
   ((<.@-:@}.,0:)+{.,2|}.)^:_ islands1
8 1 0 1 0
   ((<.@-:@}.,0:)+{.,2|}.)^:_ islands2
9 0 0 0 0

이 일반적인 솔루션은 여러 섬에서 작동합니다.

루비, 97 90 74 72

온라인 버전

더 이상 배열을 뒤집지 않고 조금 더 골프를 쳤습니다 ...

f=->i{i=i.split.map(&:to_i);(1..4).each{|n|i[-n-1]+=i[-n]/2;i[-n]%=2};i}

C-121 자

입력은 stdin에서 가져옵니다.

a[5];main(i){b(i=0,0);while(i++<5)printf("%i ",a[i-1]);}b(i,j){scanf("%i",&i);return j<5?i+=
b(i,j+1)/2,a[j]=j?i&1:i,i:0;}

Python2-98 자

stdin에서 입력

s=[0]
for v in raw_input().split()[::-1]:s=[int(v)+s[0]/2,s[0]%2]+s[1:4]
print' '.join(map(str,s))

Python3-79 자

stdin에서 입력

s=[0]
for v in input().split()[::-1]:s=[int(v)+s[0]//2,s[0]%2]+s[1:4]
print(*s)

파이썬 2, 85 80 바이트

b=1
for x in raw_input().split():b=2*b+int(x)
print b/16-2,' '.join(bin(b)[-4:])

모든 섬에서 시작하는 X 명은 오른쪽의 한 섬에서 시작하는 X * 2 명과 같습니다. 이 코드는 시작 구성의 모든 사람을 맨 오른쪽 섬의 동등한 것으로 변환 한 다음 결과의 이진 표현을 사용하여 각 섬에 몇 명의 사람들이 있는지 결정합니다.

편집 : 형식 문자열 대신 b사용할 수 있도록 0 대신 1 로 초기화하여 코드를 bin줄였습니다.

파이썬 (101)

l=map(int,raw_input().split())
for i in range(4):l[3-i]+=l[4-i]/2;l[4-i]%=2
print' '.join(map(str,l))

우리는 목록을 뒤에서 앞으로 반복하고 명세에 따라 인구를 이동시킨 다음 목록을 인쇄합니다. 다음은 간단한 테스트입니다.

>>> l=map(int,raw_input().split())
3 8 6 0 2
>>> for i in range(4):l[3-i]+=l[4-i]/2;l[4-i]%=2
... 
>>> print' '.join(map(str,l))
8 1 0 1 0

매스 매 티카 105

이것은 여러 섬에서 작동합니다.

f[w_,n_:1]:=
If[n==Length@w,w,
f[w~ReplacePart~{-n-> Mod[z=w[[-n]],2],-(n+1)->(w[[-(n+1)]]+ z~Quotient~2)},n+1]]

예

5 개 섬

f[{3, 8, 6, 0, 2}]

{8, 1, 0, 1, 0}

25 개 섬

f[{145, 144, 144, 59, 35, 129, 109, 99, 200, 24, 219, 96, 12, 121, 75,20, 153, 124, 131, 178, 228, 120, 63, 207, 228}]

{270, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0 }

자바- 647 533 그러나 Java 8 Streams에 대한 일부 브라우니 포인트를 기대합니다.

class I{int p;I e;I(int p,I e){this.p=p;this.e=e;}void x(){if(e!=null){int r=p&1;e.p+=(p-r)/2;p=r;}}public String toString(){return ""+p;}}Deque<I>B(String d){H<I>e=new H<>();return Arrays.stream(d.split(" ")).map(s->Integer.valueOf(s)).map(p->e.hold(new I(p,e.held()))).collect(Collectors.toCollection(LinkedList::new));}void x(Deque<I>is){is.descendingIterator().forEachRemaining((I i)->{i.x();});}void t(String s){Deque<I> a=B(s);x(a);System.out.println(a);}class H<T>{T h=null;H(){}T hold(T t){return (h=t);}T held(){return h;}}

비 압축 형태 :

private static class Island {
  int population;
  final Island eastwardIsland;

  Island(int population, Island eastwardIsland) {
    this.population = population;
    this.eastwardIsland = eastwardIsland;
  }

  private void exodus() {
    if (eastwardIsland != null) {
      // How many remain.
      int remain = population & 1;
      // How many leave.
      int leave = population - remain;
      // Account for 50% death rate.
      int arrive = leave / 2;
      // Modify the eastward island population.
      eastwardIsland.population += arrive;
      // Change my population.
      population = remain;
    }
  }

  @Override
  public String toString() {
    return String.valueOf(population);
  }

}

private Deque<Island> buildIslands(String data) {
  // Holds the island to the east as we traverse.
  final Holder<Island> eastward = new Holder<>();
  // Build my list of islands - assumes order is retained.
  return Arrays.stream(data.split(" "))
          // Convert to int.
          .map(s -> Integer.valueOf(s))
          // Build the island in a chain.
          .map(p -> eastward.hold(new Island(p, eastward.held())))
          // Roll them into a linked list.
          .collect(Collectors.toCollection(LinkedList::new));
}

private void exodus(Deque<Island> islands) {
  // Walk backwards.
  islands.descendingIterator()
          // Perform all exodus.
          .forEachRemaining((Island i) -> {
            i.exodus();
          });
}

private void test(String data) {
  Deque<Island> archipelago = buildIslands(data);
  // Initiate the exodus.
  exodus(archipelago);
  // Print them.
  System.out.println(archipelago);
}

다음의 도움으로 :

// Mutable final.
private static class Holder<T> {
  private T held = null;

  public Holder() {
  }

  public Holder(T it) {
    held = it;
  }

  public T hold(T it) {
    return (held = it);
  }

  public T held() {
    return held;
  }

  @Override
  public String toString() {
    return held == null ? "null" : held.toString();
  }

}

@DavidCarraher의 테스트가 약간 걱정되었습니다.

145 144 144 59 35 129 109 99 200 24 219 96 12 121 7520 153 124 131 178 228 120 63 207 228

생성

270, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0

자바 -196 195

나는 200 이하로 그것을 얻을 수 없다면 그것을 게시하지 않을 것이라고 나 자신에게 말했다 ... 나는 솔직히 다른 것을 제거 할 수 있다고 생각하지 않는다 .Java에게는 꽤 슬림하다.

class H{public static void main(String[]a){int l=a.length,p[]=new int[l],i=l;for(;i-->0;){p[i]=Integer.valueOf(a[i]);if(l-i>1){p[i]+=p[i+1]/2;p[i+1]%=2;}}for(;++i<l;System.out.print(p[i]+" "));}}

줄 바꿈 :

class H{
    public static void main(String[]a){
        int l=a.length,p[]=new int[l],i=l;
        for(;i-->0;){
            p[i]=Integer.valueOf(a[i]);
            if(l-i>1){
                p[i]+=p[i+1]/2;
                p[i+1]%=2;
            }
        }
        for(;++i<l;System.out.print(p[i]+" "));
    }
}

샘플 입력 출력 :

$ java H 3 8 6 0 2
8 1 0 1 0

$ java H 0 1 2 3 4 5 6 7 8 9 10
1 1 1 1 1 1 1 0 1 0 0

$java H 235 897 158 693
809 1 0 1

자바-179 자

압축 :

class F{public static void main(String[] a){int l=0,x,s,i=a.length-1;String z="";for(;0<=i;i--){x=Integer.valueOf(a[i])+l;s=i>0?x%2:x;l=(x-x%2)/2;z=s+" "+z;}System.out.print(z);}}

표준:

public class FloatingHorde {

    public static void main(String[] a) {
        int leave = 0;
        String outputStr = "";
        for (int i = a.length - 1; 0 <= i ; i--) {
            int x = Integer.valueOf(a[i]) + leave;
            int stays = i > 0 ? x % 2 : x;
            leave = (x - x % 2) / 2;
            outputStr = stays + " " + outputStr;
        }
        System.out.print(outputStr);
    }
}

샘플 출력 :

$ java F 3 8 6 0 2
8 1 0 1 0

$ java F 7 6 5 4 3
11 1 1 1 1

이맥스 Lisp 144 자

작지만 작동합니다.

(lambda (d)
   (setq x d)(while(cdr x)
           (setcar(cdr x)(+(/(-(car x)(%(car x)2))2)(cadr x)))
           (setcar x (-(car x)(*(/(car x)2)2)))
       (pop x))
   (reverse d))

awk-44 자

{for(i=NF;i>1;){n=int($i/2);$i%=2;$--i+=n}}1

자바-116 자

예를 들어 int[] i = {2, 33, 16, 5};(각 숫자가 다를 수 있으므로 카운트에 추가하지 않는 것 같습니다)23 0 0 1

for(int j = i.length-1; j > 0; j--) {       
    while(i[j] > 1) {
        i[j] -= 2;
        i[j-1]++;
    }       
}
for(int j = 0; j < i.length; j++) {     
    System.out.print(i[j] + " ");
}