Introducción

La lluvia finalmente se calmó. La mayoría de la humanidad se ahogó debido a un error en el código de @ user12345 . Los sobrevivientes se encuentran dispersos en un archipiélago mundial. La comunicación por radio ha terminado y la humanidad está lista para prosperar una vez más. Sin ninguna razón, los piratas zombis se han reunido en el Primer Meridiano y están barriendo hacia el oeste. La horda lo devora todo.

Problema

Nuestro escenario del fin del mundo se puede describir con 5 enteros en una sola línea que representan un conjunto de comunidades insulares cooperantes. Se ordenan desde el oeste (entero más a la izquierda) hacia el este (entero más a la derecha).

Comenzando con la isla más al este, los isleños huyen en parejas a la siguiente isla más cercana. Curiosamente, por cada pareja que se embarca, solo uno de ellos sobrevive al viaje. Los isleños solo viajan en parejas. Poblaciones extrañas eligen a un único habitante para quedarse y proporcionar las últimas actualizaciones de radio sobre las travesuras de la horda de zombis piratas. Las poblaciones se niegan a viajar hasta que todas las islas al este de ellas hayan completado sus migraciones o hayan muerto. Cuando la población llega a la isla final más occidental, cesa el viaje.

El gerente de operaciones del fin del mundo necesita un programa que pueda generar los recuentos finales de población de cada aldea.

Entrada de ejemplo

3 8 6 0 2

Salida de ejemplo

8 1 0 1 0

Supuestos

• La entrada se puede proporcionar a través de stdin, leer desde un archivo nombrado arbitrariamente o aceptar como argumento
• Para cada isla, 0 <= población <= 1024
• Las poblaciones nunca saltan una isla

¡La respuesta más corta gana!

APL, 16 caracteres

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

La entrada se proporciona como cadena a este bloque:

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

o un char menos si la entrada se proporciona como argumento para este bloque:

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

Se basa en la idea de Ilmari Karonen en este comentario .

• 2⊥⍵ realiza una conversión de base 2 de la entrada.
• (1e9,4⍴2)⊤así convierte este número nuevamente en la base 2 (para los cuatro últimos dígitos) y la base 1e9 para el primero, que es suficiente para los rangos de entrada dados anteriormente. ( 1e9,4⍴2construye la lista 1e9 2 2 2 2)

Tenga en cuenta que la huida del oeste se realiza automáticamente mediante la conversión de base durante este proceso.

GolfScript, 23 22 caracteres

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

Un enfoque iterativo. La matriz se repite varias veces y cada vez se transfiere un número de pares de derecha a izquierda. Prueba el ejemplo en línea .

Breve explicación del código:

~]       # 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 caracteres)

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

Demostración en línea

Solución bastante sencilla: hay un enfoque más interesante que define el valor de salida para cada isla en función de los valores de entrada, pero no creo que pueda jugarse tan lejos como seguir el algoritmo de redistribución descrito en la pregunta.

Javascript / ES6 (69)

Jugando con operadores bit a bit:

• x&=1 mantiene el bit más bajo (1 si es impar, 0 si es par)
• x>>1 es la división por 2 para enteros

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

Versión sin ES6:

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

Ejemplos:
f("3 8 6 0 2")devoluciones [8, 1, 0, 1, 0]
f("0 997 998 999 1000")devoluciones[935, 0, 1, 1, 0]

Python - 96 caracteres

Primera vez jugando al golf! Entrada de 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 caracteres)

Aquí está mi solución en 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

Esta solución general debería funcionar con cualquier número de islas.

Rubí, 97 90 74 72

Versión en línea

Lo jugué un poco más, ya no invirtió la matriz ...

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

C - 121 caracteres

La entrada se toma de 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 caracteres

Entrada de 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 caracteres

Entrada de 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 bytes

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

X personas que comienzan en cualquier isla son equivalentes a X * 2 personas que comienzan una isla a la derecha. Este código convierte a todos en la configuración inicial a su equivalente en los isleños de extrema derecha, luego usa la representación binaria del resultado para determinar cuántas personas terminan en cada isla.

EDITAR: acortó el código inicializando ba 1 en lugar de 0, permitiendo el uso de en binlugar de una cadena de formato.

Pitón (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))

Recorremos la lista de atrás hacia adelante y movemos las poblaciones según la especificación, luego imprimimos la lista. Aquí hay una prueba rápida:

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

Mathematica 105

Esto debería funcionar con cualquier número de islas.

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

Ejemplos

5 islas

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

{8, 1, 0, 1, 0}

25 islas

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 }

Java - 647 533 pero esperando algunos puntos de brownie para 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;}}

La forma sin comprimir:

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

Con una asistencia de:

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

}

Ligeramente preocupado de que la prueba de @ 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

genera

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

Java - 196 195

Me dije a mí mismo que no lo publicaría si no podía obtenerlo por debajo de 200 ... Sinceramente, no creo que pueda deshacerme de nada más, es bastante delgado para 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]+" "));}}

Saltos de línea:

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

Muestra de entrada y salida:

$ 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 caracteres

Comprimido:

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

Normal:

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

Salida de muestra:

$ 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 caracteres

No es pequeño, pero funciona.

(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 caracteres

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

Java - 116 caracteres

Por ejemplo int[] i = {2, 33, 16, 5};(supongo que esos no se suman al recuento, ya que cada número puede variar) generaría23 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] + " ");
}