Esiste un "gioco" esistente in cui i pirati dividono razionalmente le monete d'oro secondo determinate regole. Citando da Wikipedia :

Ci sono 5 pirati razionali, A, B, C, D ed E. Trovano 100 monete d'oro. Devono decidere come distribuirli.

I pirati hanno un rigido ordine di anzianità: A è superiore a B, che è superiore a C, che è superiore a D, che è superiore a E.

Le regole di distribuzione del mondo dei pirati sono quindi: che il pirata più anziano dovrebbe proporre una distribuzione di monete. I pirati, incluso il proponente, votano quindi se accettare questa distribuzione. In caso di parità di voti, il proponente ha il voto decisivo. Se la distribuzione viene accettata, le monete vengono erogate e il gioco termina. In caso contrario, il proponente viene gettato in mare dalla nave pirata e muore, e il prossimo pirata più anziano fa una nuova proposta per riavviare il sistema.

I pirati basano le loro decisioni su tre fattori. Prima di tutto, ogni pirata vuole sopravvivere. Secondo, data la sopravvivenza, ogni pirata vuole massimizzare il numero di monete d'oro che ognuno riceve. Terzo, ogni pirata preferirebbe gettarne un altro in mare, se tutti gli altri risultati sarebbero uguali. I pirati non si fidano l'uno dell'altro e non faranno né onoreranno alcuna promessa tra i pirati a parte un piano di distribuzione proposto che fornisca un numero intero di monete d'oro a ciascun pirata.

Sfida

Prendi come input un numero intero n, 1 <= n <= 99, dove nè il numero di pirati - e genera la distribuzione di monete, a partire dal primo pirata.

Casi di test (viene inserita la prima riga; la seconda uscita):

1
100

2
100 0

3
99 0 1

5
98 0 1 0 1

Questo è code-golf , quindi vince la soluzione più breve in byte.

Gelatina , 11 10 byte

R%2ḊµSȷ2_;

Provalo online! oppure verifica tutti i casi di test contemporaneamente .

Come funziona

Per l'input n , l'attività si riduce alla creazione dell'elenco x, 0, 1, 0, ... di lunghezza n la cui somma è 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 byte

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

Calcola il primo valore, aggiunge alcuni 0, 1, 0, 1..., tronca alla lunghezza n.

Si noti che -n/2+101non può essere abbreviato 101-n/2perché unario e binario -hanno una precedenza diversa: il primo viene analizzato come (-n)/2e il secondo come 101-(n/2).

La ricorsione è stata molto più lunga (45):

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

MATL , 12 byte

:2\ts_101+l(

Questo utilizza la versione corrente (9.2.2) del linguaggio / compilatore, che è precedente a questa sfida.

Esempio

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

Spiegazione

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

Pyth, 13 byte

+-100sJ%R2tQJ

Suite di test .

Python, 62 58 byte

EDIT: Sono contento di averlo fatto un liner. Ma perdo per Python. Pertanto, questo è solo per riferimento. Grazie @Zgarb

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

Prende l'input, crea un elenco di parità di tutti i numeri da 1 a i. Quindi imposta il primo elemento in i su 101-sum (n) e stampa.

Provalo qui

Javascript ES6, 45 byte

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

Grazie a @Neil per 1 byte salvato!

𝔼𝕊𝕄𝕚𝕟, 14 caratteri / 26 byte

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

Try it here (Firefox only).

Non male, ma neanche buono ...

Spiegazione

⩥ï⒨?‡$%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

Scherzi a parte, 23 17 byte

EDIT : Grazie @quintopia

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

Utilizza lo stesso approccio della mia risposta Python, ma faccio il modulo 2 usando la mappatura e, più volte, ruoto il mio stack.

Spiegazione :

Questo codice invia input (lo chiamerò i). Il prossimo spinge range(1,i+1)e crea una funzione. Quindi preme 2, ruota lo stack e infine prende il modulo.

Quindi, mappare questa funzione sull'intervallo iterabile. Ciò fornisce la parità di ciascun elemento nell'elenco.

Infine, duplica lo stack, somma l'elenco di parità, invia 2, 10 ^ 2 e 100 + 1 e sottrae la somma (fammi chiamare questo valore n). Successivamente il codice invia 0, ruota lo stack di 1 e imposta l'indice 0 dell'elenco su n. L'elenco risultante viene stampato implicitamente.

Japt, 14 byte

Ancora un'altra sfida in cui mi trovo a desiderare un built-in che avevo appena considerato l'aggiunta ...

1oU mv u#Ê-UÁ1

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

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

Non è il miglior linguaggio per giocare a golf, ma mi piace pubblicare risposte as3.

05AB1E , 12 byte (non comp)

<LÈDOTns-s)˜

Provalo online!

Perl 51 49 44 byte

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

Sono necessarie le seguenti opzioni perlrun -E

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

QBIC , 28 25 byte

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

Spiegazione

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