introduction

La pluie s'est finalement calmée. La plupart de l'humanité s'est noyée en raison d'un bogue dans le code de @ user12345 . Les survivants sont dispersés dans un archipel mondial. La communication radio est en hausse, et l'humanité est prête à prospérer une fois de plus. Pour aucune raison que ce soit, des pirates zombies se sont rassemblés au premier méridien et se dirigent vers l'ouest. La horde dévore tout.

Problème

Notre scénario apocalyptique peut être décrit par 5 entiers sur une seule ligne qui représentent un ensemble de communautés insulaires coopérantes. Ils sont classés de l'ouest (entier le plus à gauche) à l'est (entier le plus à droite).

En commençant par l'île la plus à l'est, les insulaires s'enfuient par paires jusqu'à la prochaine île la plus proche. Curieusement, pour chaque paire qui s'embarque, un seul d'entre eux survit au voyage. Les insulaires voyagent uniquement par paires. Les populations étranges élisent un habitant unique pour rester derrière et fournir les dernières mises à jour radio sur les pitreries de la horde de pirates zombies. Les populations refusent de voyager jusqu'à ce que toutes les îles à l'est d'entre elles aient achevé leurs migrations ou soient mortes. Lorsque la population atteint la dernière île la plus à l'ouest, les voyages cessent.

Le directeur des opérations à la fin du monde a besoin d'un programme capable de produire les chiffres de population finaux de chaque village.

Exemple d'entrée

3 8 6 0 2

Exemple de sortie

8 1 0 1 0

Hypothèses

• L'entrée peut être fournie via stdin, lue à partir d'un fichier nommé arbitrairement ou acceptée comme argument
• Pour chaque île, 0 <= population <= 1024
• Les populations ne sautent jamais une île

La réponse la plus courte gagne!

APL, 16 caractères

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

L'entrée est fournie sous forme de chaîne à ce bloc:

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

ou un caractère de moins si l'entrée est fournie en argument à ce bloc:

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

Il est basé sur l'idée d'Ilmari Karonen dans ce commentaire .

• 2⊥⍵ effectue une conversion en base 2 de l'entrée.
• (1e9,4⍴2)⊤convertit ainsi ce nombre en base 2 (pour les quatre derniers chiffres) et en base 1e9 pour le premier, ce qui est suffisant pour les plages d'entrée données ci-dessus. ( 1e9,4⍴2construit la liste 1e9 2 2 2 2.)

Notez que la fuite vers l'ouest se fait automatiquement par la conversion de base au cours de ce processus.

GolfScript, 23 22 caractères

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

Une approche itérative. Le tableau est itéré plusieurs fois et à chaque fois un nombre de paires est transféré de droite à gauche. Essayez l'exemple en ligne .

Brève explication du code:

~]       # 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 caractères)

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

Démo en ligne

Solution assez simple: il existe une approche plus intéressante qui définit la valeur de sortie pour chaque îlot en fonction des valeurs d'entrée, mais je ne pense pas qu'il soit possible de jouer autant que de suivre l'algorithme de redistribution décrit dans la question.

Javascript / ES6 (69)

Jouer avec des opérateurs au niveau du bit:

• x&=1 conserve le bit le plus bas (1 si impair, 0 si pair)
• x>>1 est la division par 2 pour les entiers

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

Version sans ES6:

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

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

Python - 96 caractères

Golf pour la première fois! Entrée 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 caractères)

Voici ma solution 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

Cette solution générale devrait fonctionner avec n'importe quel nombre d'îles.

Rubis, 97 90 74 72

Version en ligne

Je l'ai joué un peu plus loin, sans inverser le tableau ...

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

C - 121 caractères

L'entrée provient 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 caractères

Entrée 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 caractères

Entrée 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 octets

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

X personnes commençant sur une île équivalent à X * 2 personnes commençant une île à droite. Ce code convertit tout le monde dans la configuration de départ en son équivalent dans les insulaires d'extrême droite, puis utilise la représentation binaire du résultat pour déterminer combien de personnes se retrouvent sur chaque île.

EDIT: raccourci le code en initialisant bà 1 au lieu de 0, permettant l'utilisation de binau lieu d'une chaîne de format.

Python (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))

Nous parcourons la liste de l'arrière vers l'avant et déplaçons les populations selon les spécifications, puis imprimons la liste. Voici un test rapide:

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

Cela devrait fonctionner avec n'importe quel nombre d'îles.

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

Exemples

5 îles

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

{8, 1, 0, 1, 0}

25 îles

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 mais en espérant quelques points brownie pour 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 forme non compressée:

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

Avec l'aide 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();
  }

}

Légèrement préoccupé par le test 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

génère

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

Je me suis dit que je ne le publierais pas si je ne pouvais pas le faire sous 200 ... Honnêtement, je ne pense pas pouvoir me débarrasser de quoi que ce soit d'autre, c'est assez mince pour 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]+" "));}}

Sauts de ligne:

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

Exemple de sortie d'entrée:

$ 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 caractères

Comprimé:

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

Ordinaire:

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

Exemple de sortie:

$ 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 caractères

Pas minuscule, mais ça marche

(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 caractères

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

Java - 116 caractères

Par exemple int[] i = {2, 33, 16, 5};(je suppose que ceux-ci ne s'ajoutent pas au nombre, car chaque nombre peut varier) produirait23 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] + " ");
}