Вступ

Дощ нарешті вщух. Більшість людства потонула через помилку в коді @ 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

або на один знак менше, якщо введення подано як аргумент до цього блоку:

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

Він заснований на ідеї Ілмарі Каронен у цьому коментарі .

• 2⊥⍵ робить перетворення бази 2 на вході.
• (1e9,4⍴2)⊤таким чином перетворює це число назад в базу 2 (для чотирьох останніх цифр) і базу 1e9 для першої, що достатньо для введених вище діапазонів. ( 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%' '*

Демонстрація в Інтернеті

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

Javascript / 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)

Python 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 людям, що починають один острів праворуч. Цей код перетворює всіх у стартовій конфігурації у їх еквівалент у крайніх правих островах, а потім використовує двійкове представлення результату, щоб визначити, скільки людей потрапляє на кожен острів.

EDIT: Скоротіть код, ініціалізувавшись bна 1 замість 0, дозволяючи використовувати 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, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0 }

Java - 647 533, але сподіваюся на деякі точки брауні для потоків Java 8.

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

Java - 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

Emacs 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

Java - 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] + " ");
}