Existe um "jogo" existente no qual os piratas dividem racionalmente as moedas de ouro de acordo com certas regras. Citando da Wikipedia :

Existem 5 piratas racionais, A, B, C, D e E. Eles encontram 100 moedas de ouro. Eles devem decidir como distribuí-los.

Os piratas têm uma ordem estrita de antiguidade: A é superior a B, superior a C, superior a D e superior a E.

As regras de distribuição do mundo pirata são assim: que o pirata mais velho proponha uma distribuição de moedas. Os piratas, incluindo o proponente, votam se aceitam essa distribuição. Em caso de empate, o proponente tem voto de qualidade. Se a distribuição for aceita, as moedas são desembolsadas e o jogo termina. Caso contrário, o proponente é jogado para fora do navio pirata e morre, e o próximo pirata mais velho faz uma nova proposta para iniciar o sistema novamente.

Os piratas baseiam suas decisões em três fatores. Primeiro de tudo, cada pirata quer sobreviver. Segundo, dada a sobrevivência, cada pirata deseja maximizar o número de moedas de ouro que recebe. Terceiro, cada pirata prefere jogar outro ao mar, se todos os outros resultados forem iguais. Os piratas não confiam um no outro e não farão nem honrarão nenhuma promessa entre piratas, além de um plano de distribuição proposto que fornece um número inteiro de moedas de ouro para cada pirata.

Desafio

Tome como entrada um número inteiro n, 1 <= n <= 99, onde né o número de piratas - e produza a distribuição de moedas, começando com o primeiro pirata.

Casos de teste (a primeira linha é entrada; a segunda saída):

1
100

2
100 0

3
99 0 1

5
98 0 1 0 1

Isso é código-golfe , então a solução mais curta em bytes vence.

Gelatina , 11 10 bytes

R%2ḊµSȷ2_;

Experimente online! ou verifique todos os casos de teste de uma só vez .

Como funciona

Para a entrada n , a tarefa se resume a criar a lista x, 0, 1, 0,… de comprimento n cuja soma é 100 .

R%2ḊµSȷ2_;  Main link. Input: n

R           Yield [1, 2, ..., n].
 %2         Replace each integer by its parity. Yields [1, 0, 1, 0, ...].
   Ḋ        Dequeue; remove the first 1. This yields the list a = [0, 1, ...].
    µ       Begin a new, monadic link. Argument: a
     S      Compute the sum of a.
      ȷ2_   Subtract the sum from 100. (ȷ2 is 1e2 in Python syntax)
         ;  Prepend the difference to a.

Python, 33 bytes

lambda n:([-n/2+101]+[0,1]*n)[:n]

Calcula o primeiro valor, acrescenta alguns 0, 1, 0, 1..., trunca no comprimento n.

Observe que -n/2+101não é possível abreviá-lo 101-n/2porque unário e binário -têm precedência diferente: o primeiro é analisado como (-n)/2e o segundo como 101-(n/2).

A recursão foi muito mais longa (45):

f=lambda n,i=100:1/n*[i]or f(n-1,i-n%2)+[n%2]

MATL , 12 bytes

:2\ts_101+l(

Isso usa a versão atual (9.2.2) do idioma / compilador, anterior a esse desafio.

Exemplo

>> matl :2\ts_101+l(
> 5
98  0  1  0  1

Explicação

:         % implicitly input number "n". Generate vector [1, 2, ..., n]
2\        % modulo 2. Gives [1, 0, 1, ...]
ts        % duplicate and compute sum
_101+     % negate and add 101
l(        % assign that to first entry of [1, 0, 1, ...] vector. Implicitly display

Pitão, 13 bytes

+-100sJ%R2tQJ

Conjunto de teste .

Python, 62 58 bytes

EDIT: Que bom que eu fiz um one-liner. Mas eu perco por Python. Portanto, isso é apenas para referência. Obrigado @Zgarb

def x(i):n=[~j%2for j in range(i)];n[0]=101-sum(n);print n

Ele pega a entrada, cria uma lista de paridade de todos os números de 1 a i. Em seguida, define o primeiro elemento em i como soma 101 (n) e imprime.

Experimente aqui

Javascript ES6, 45 bytes

a=>[...Array(a)].map((x,y)=>y?--y%2:202-a>>1)

Graças a @ Neil por 1 byte salvo!

𝔼𝕊𝕄𝕚𝕟, 14 caracteres / 26 bytes

⩥ï⒨?‡$%2:ỉ-ï»1

Try it here (Firefox only).

Não é ruim, mas também não é bom ...

Explicação

⩥ï⒨?‡$%2:ỉ-ï»1 // implicit: ï=input, ṥ=101
⩥ï⒨            // map over a range [0,ï) and return:
    ?‡$%2       // (if mapitem>0) then ($-1) mod 2
         :ỉ-ï»1 // (else) 202-ï>>1
                // implicit output

Sério, 23 17 bytes

EDIT : Obrigado @quintopia

,R`2@%`M;Σ2╤u-0(T

Utiliza a mesma abordagem da minha resposta Python, mas faço o módulo 2 usando mapeamento e, várias vezes, giro minha pilha.

Explicação :

Este código empurra a entrada (eu vou chamá-lo i). Em seguida, empurra range(1,i+1)e faz uma função. Em seguida, empurra 2, gira a pilha e, finalmente, pega o módulo.

Em seguida, mapeie essa função no intervalo iterável. Isso fornece a paridade de cada elemento na lista.

Por fim, duplica a pilha, soma a lista de paridades, pressiona 2, 10 ^ 2 e 100 + 1 e subtrai a soma (deixe-me chamar esse valor n). Em seguida, o código empurra 0, gira a pilha por 1 e define o elemento índice 0 da lista como n. A lista resultante é impressa implicitamente.

Japonês, 14 bytes

Mais um desafio em que me encontro desejando um built-in que acabei de considerar adicionar ...

1oU mv u#Ê-UÁ1

Experimente online!

1oU mv u#Ê-UÁ1  // Implicit: U = input integer
1oU             // Create the range [1, U).
    mv          // Map each item to 1 if even, 0 otherwise.
       u        // Unshift (add to the beginning of the array)
        #Ê-UÁ1  //  the char code of Ê (202), minus U >>> 1 (floor of U / 2).

ActionScript 3, 87 bytes

function x(n){var l=[],i=1;for (l[0]=int(101-n/2);i<n;){l[i]=++i%2;}return l.join(" ")}

Não é a melhor linguagem de golfe, mas gosto de postar as3 respostas.

05AB1E , 12 bytes (não comp)

<LÈDOTns-s)˜

Experimente online!

Perl 51 49 44 bytes

$,=$";@"=map{$i++%2}2..<>;say 100-(@">>1),@"

Precisa das seguintes opções perlrun -E

$ perl -E'$,=$";@"=map{$i++%2}2..<>;say 100-(@">>1),@"'<<<5
98
0
1
0
1

QBIC , 28 25 bytes

:?100-(a-1)'\`2[2,a|?b%2

Explicação

:               Get command line parameter, assign to 'a'
                Determine the part of the treasure for the crew:
      (a-1) \ 2 Integer Divide 'a'-1 by 2. The -1 compensates for even cases.
           ' `  Make \ a direct command for QBasic instead of substituting it for ELSE.
?100-           Print 100 coins, minus the crew-share --> Captain's booty.
[2,a|           FOR b=2; b <= a; b++; ie for every other crew member
?b%2            Give every odd crewman a coin.
                [FOR loop implicitly closed by QBIC]