La somma è sempre 15

36

Scrivi un programma o una funzione che accetta come input una matrice di numeri interi non negativi e genera in ordine una serie di vettori / array con gli elementi della matrice di input in ordine, divisi in modo tale che ogni vettore sommi fino a 15. Se la somma del primo N elementi non "colpisce 15", quindi il numero che lo ha fatto passare 15 deve essere tagliato e il resto sarà il primo elemento del vettore successivo. Questo continua fino a raggiungere la fine dell'array di input. Se la somma del vettore finale è inferiore a 15, è necessario aggiungere un numero alla fine per aumentare la somma.

Penso che le regole siano più facilmente comprensibili guardando gli esempi:

Input: 3 7 5 10
Output:
3 7 5           <- Sum is 15
10 5            <- 5 is added to make the sum 15

Input: 2 4 5 9 2 3 5 0 2 4 5 0 3
Output:
2 4 5 4          <- Sum 15. 9 is split in two. 
5 2 3 5          <- The first 5 is the remainder of 9
0 2 4 5 0 3 1    <- The last number is added to make the sum 15

Input: 1 1 1            
Output:
1 1 1 12         <- The number 12 is added to make the sum 15

Input: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
Output:
1 2 3 4 5
6 7 2           <- 2 is the first part of 8
6 9             <- 6 is the remainder of 8
10 5            <- 5 is first part of 11
6 9             <- 6 is remainder of 11. 9 is first part of 12
3 12            <- 3 is remainder of 12. 12 is first part of 13
1 14            <- 1 is remainder of 13. 14 is 14
15
15              <- 15 is first part of 16
1 14            <- 1 is remainder of 16. 14 is first part of 17
3 12            <- 3 is remainder of 17. 12 is added to make the sum 15

Input: 20 20
Output:
15
5 10           <- 5 is remainder from the first 20
10 5           <- 10 is remainder from second 20. 5 is added to make the sum = 15.

Sia il formato di input che quello di output sono facoltativi. Qualunque sia il migliore nella tua lingua.

Vince il codice più breve in byte.

Classifica

Lo snippet di stack nella parte inferiore di questo post genera il catalogo dalle risposte a) come elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

## Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostra snippet di codice

code-golf  math  arithmetic  array-manipulation 
— Stewie Griffin
fonte
'Il formato di output è opzionale'. Significa che [[3, 7, 5], [10, 5]]sarebbe un output valido per il primo caso di test?
— Morgan Thrapp,
@MorganThrapp, sì. è valido.
— Stewie Griffin,
1
@FlagAsSpam, ho aggiunto ulteriori spiegazioni nell'esempio che stai chiedendo.
— Stewie Griffin,
3
Buon caso di prova:Input: 100 Output: 15; 15; 15; 15; 15; 15; 10 5
— randomra
3
Questo dovrebbe sicuramente sostituire il test
— FizzBuzz

Risposte:

8

Pyth, 37 byte

K15VQ=+ZNIgZK=-ZK-NZbIZZ)).?N;I>KZ-KZ

spiegato

K15              Store 15 in K (the max) (K is Autoinitializing, no = needed here)
VQ              For N in the evaluated input
  =+ZN           Set Z(Which in pyth defaults to 0) to Z+N
  IgZK           If Z(row total) is greater than or equal to K (row max)
    =-ZK         Set Z to Z-K (How much the max was exceeded)
    -NZ          Implicitly print N-Z
    b            Implicitly print b (in pyth defaults to a newline)
    IZ         If Z > 0 (There was excess to carry to the next row)
      Z          Implicitly print Z (the excess)
  .?N            Else(the current row count is < the max(15)) output the current number
;                Use infinite )'s in place of )) (to save 1 character)
I>KZ             If K > Z (The max is greater than the current row count)
  -KZ           Implicitly print K-Z (The amount needed for the row to equal 15)

Questo è stato il mio primo pyth, quindi sentiti libero di suggerire miglioramenti.

Esempio:

Ingresso

[1, 3, 4, 5, 9, 8]

Produzione

1
3
4
5
2


7
8

Nota: grazie a Isaacg per diversi byte di consigli sulla riduzione delle dimensioni e per aver creato pyth in primo luogo! Per favore, vota i suoi commenti qui sotto :)

— csga5000
fonte
2
Altrimenti è stato recentemente modificato per essere .?invece di E, ma ho dimenticato di aggiornare i documenti. Mi dispiace per quello.
— Isaacg,
@isaacg Grazie isaacg! Dovrei farlo funzionare ora. Anche se salva solo 1 byte poiché l'altro è di 2 caratteri ora.
— csga5000,
1
Risolvendolo mentre parliamo.
— isaacg,
3
Un paio di altri suggerimenti: =Z+ZNe =+ZNsono gli stessi. È un po 'come quello di Python +=. Likewiese, =Z-ZK-> =-ZK. Inoltre, non è necessario )alla fine: viene compilato automaticamente. Finalmente, FNQe VQsono gli stessi.
— isaacg,
1
Puoi salvare un altro 2 byte sostituendolo I>Z0con IZ- Znon può essere negativo, quindi stai solo verificando se Znon è zero e zero è falso, mentre tutti gli altri numeri sono veritieri.
— isaacg,
16

Java - 229 200 192 181 172 170 168 byte

Era già iniziato, non per la vittoria ma per il divertimento :)
Qualsiasi suggerimento è il benvenuto.

Salvato 8 byte grazie a @ThomasKwa
Salvato 20 byte grazie a @corsiKa
Salvato 2 byte grazie a @Ypnypn
Salvato 2 byte grazie a @ user902383

String p(int[]a){int c=0,j;String s="";f:for(int i:a){for(j=i;j-->0;)if(++c>14){s+=(i-j)+"\n";c=0;if(j<15){if(j>0)s+=j+" ";c+=j;continue f;}}s+=i+" ";}return s+(15-c);}

170 byte

String p(int[]a){int c=0,j;String s="";f:for(int i:a){for(j=i;j-->0;){if(++c>14){s+=(i-j)+"\n";c=0;if(j<15){if(j>0)s+=j+" ";c+=j;continue f;}}}s+=i+" ";}return s+(15-c);}

172 byte

String p(int[]a){int c=0,j;String s="";f:for(int i:a){for(j=i;j>0;){j--;if(++c>14){s+=(i-j)+"\n";c=0;if(j<15){if(j>0)s+=j+" ";c+=j;continue f;}}}s+=i+" ";}return s+(15-c);}

181 byte

void p(int[]a){int c=0,j;String s="";f:for(int i:a){for(j=i;j>0;){j--;if(++c>14){s+=(i-j)+"\n";c=0;if(j<15){if(j>0)s+=j+" ";c+=j;continue f;}}}s+=i+" ";}System.out.print(s+(15-c));}

192 byte

void p(int[]a){int c=0,j;String s="";f:for(int i:a){for(j=i;j>0;){j--;c++;if(c==15){s+=(i-j)+"\n";c=0;if(j>=15)continue;if(j>0)s+=j+" ";c+=j;continue f;}}s+=i+" ";}System.out.print(s+(15-c));}

200 byte

void p(int[]a){int c=0,j;String s="";f:for(int i:a){j=i;while(j>0){j--;c++;if(c==15){s+=(i-j)+"\n";c=0;if(j>=15)continue;else{if(j!=0)s+=j+" ";c+=j;continue f;}}}s+=i+" ";}System.out.print(s+(15-c));}

229 byte

void p(int[]a){int c=0,j;f:for(int i:a){j=i;while(j>0){j--;c++;if(c==15){System.out.print(i-j+"\n");c=0;if(j>=15){continue;}else{if(j!=0)System.out.print(j+" ");c+=j;continue f;}}}System.out.print(i+" ");}System.out.print(15-c);}

String p(int[] a) {
    int c = 0, j;
    String s = "";
    f: for (int i: a) {
        for (j = i; j-- > 0;)
            if (++c > 14) {
                s += (i - j) + "\n";
                c = 0;
                if (j < 15) {
                    if (j > 0) s += j + " ";
                    c += j;
                    continue f;
                }
            }
        s += i + " ";
    }
    return s + (15 - c);
}
— Yassin Hajaj
fonte
1
Wow, non avevo visto continuare fino ad ora effettivamente utilizzato in un programma Java.
— Magic Octopus Urn
7

Python 3 - 1̶7̶7̶ 1̶3̶8̶ 1̶6̶6̶ 1̶3̶3̶ 113

s=0
i=15
p=print
for e in eval(input()):
 if s>=i:p()
 s=s%i+e
 if s>i:s-=i;p(e-s);p();e=s
 p(e)
if s!=i:p(i-s%i)

Modifica 5 Veramente golfato grazie alle interruzioni di riga rimosse @poke * ecc

Modifica 4 Stampa con alias e sostituito a = con a - = per salvare un byte. Grazie a @poke e @elzell. Spostato anche input eval in for loop per salvare 2 byte dall'assegnazione

Modifica 3 Trovato risparmio in diversi OO al secondo se

Modifica 2 Bug risolto

Modifica 1 Ha modificato l'input per essere nella forma '[1,2,3,4,5 ...]' e ha implementato i primi due commenti, grazie a @Morgan Thrapp

Poster per la prima volta qui. L'input è una riga di comando con voci separate da spazi, l'output è una voce per riga, con una nuova riga tra i raggruppamenti.

— Adam Martin
fonte
3
Puoi portarlo a 122 assegnando 15 a una variabile e usando solo uno spazio per il rientro.
— Morgan Thrapp,
Inoltre, fallisci il secondo caso di test, ottengo 2 3 5, ma dovrebbe essere 5 2 3 5.
— Morgan Thrapp
1
@AdamMartin Potresti essere interessato alla mia versione Pyth del tuo codice
— Pyth csga5000,
1
Dal momento che si sta utilizzando printcosì spesso, si dovrebbe salvarlo come una variabile: p=print. Ti salva altri 14 personaggi.
— colpire
2
Il conteggio corrente è 132, ma è possibile farlo scendere a 113 se si rimuovono alcune interruzioni di riga. Puoi combinare ogni if ​​in un'unica riga, ad es. if s>i:s-=i;p(e-s);p();e=sPer la seconda. Ciò consente di risparmiare interruzioni di riga e caratteri di rientro.
— colpire il
7

Haskell, 126 107 102 100 byte

[]#c=[]
(h:t)#c|s<0=t#u|s<1=u:t#[]|1<2=(c++[h-s]):(s:t)#[]where s=sum c+h-15;u=c++[h]
(#[]).(++[14])

Esempio di utilizzo: (#[]).(++[14]) $ [1..17]->[[1,2,3,4,5],[6,7,2],[6,9],[10,5],[6,9],[3,12],[1,14],[15],[15],[1,14],[3,12]]

Modifica: @Stewie Griffin mi ha aiutato a salvare 19 byte. Grazie!

— Nome del modello
fonte
4

CJam, 39 byte

q~0af*Sf*N*30/{S-N/:,F1$:+-+0+e`W<e~p}/

Provalo qui.

Questo sembra molto non ottimale, ma finora tutti i miei tentativi di una soluzione più breve sono stati vanificati dalla presenza di zeri nell'input.

— Martin Ender
fonte
4

Python2 alimentato da RegEx : 158 155 byte

Realizzato in pitone con amore e quasi senza matematica.
O Regex Math, se vuoi, matematica unaria.
La matematica "reale" veniva utilizzata solo per "correggere" l'ultimo requisito:

Se la somma del vettore finale è inferiore a 15, è necessario aggiungere un numero alla fine per aumentare la somma.

Codegolfed:

import re
def f(i):o=[map(len,p.split())for p in re.findall('((?:x *){15}|.+)',' '.join(['x'*c for c in i]))];l=sum(o[-1]);o[-1]+=([],[15-l])[l<15];print o

Il modo in cui funziona è convertendo ogni numero N in una stringa di lunghezza N ( x scelto come carattere per riempire la stringa) e unendoli tutti in uno spazio separato string. La stringa risultante viene suddivisa tramite RegEx BLACK MAGIC in qualcosa del tipo: 

['x xx xxx xxxx xxxxx ', 'xxxxxx xxxxxxx xx', 'xxxxxx xxxxxxxxx', 'x']

per un input come: f([1, 2, 3, 4, 5, 6, 7, 8, 10])
che viene quindi diviso di nuovo e la lunghezza di consecutivix es viene utilizzata per creare nuovamente i numeri, tutto impacchettato piacevolmente nella comprensione di un elenco.

Ungolfed:

import re
o = [map(len, p.split()) for p in re.findall('((?:x *){15}|.+)', ' '.join(['x'*c for c in i]))]
l = sum(o[-1])
o[-1] += ([], [15-l])[l<15]
print o

Produzione: 

>>> f([30, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16])
[[15], [15], [1, 2, 3, 4, 5], [6, 7, 2], [6, 9], [15], [1, 14]]

Nota: non c'era abbastanza magia per gli 0, quindi questa voce è squalificata

gli zeri devono essere inclusi. Vedi il secondo esempio

— CSᵠ
fonte
Tutti quei nomi di funzioni sono piuttosto costosi. Rende quasi impossibile usare qualcosa come regex nel code golf. Tuttavia, la dimensione dei byte non è male considerando
— csga5000
4

Scherzi a parte, 88 byte

,`'!*'0`M' j0╗`;;;'|ε35*('!=╜+;╗%(' =|('0=|I)`Mεj'|@s`ôl`╝`ö'0@s╛M`Md;Σ35*-;`X``@q`Iƒ@q.

Provalo online

È la mia prima risposta seria! Ora ho un'intima familiarità con tutte le carenze della lingua!

Dump esadecimale:

2c6027212a2730604d27206a30bb603b3b3b277cee33352a2827213dbd2b3bbb252827203d7c2827303d7c49
29604dee6a277c407360936c60bc609427304073be4d604d643be433352a2d3b60586060407160499f40712e

Spiegazione:

,`'!*'0`M' j         Replace all the numbers by "0"+"!"*n, separated by " "
0╗                   Initialize an accumulator in register 0
` ... `M             Map the string with the following function:
   ;;;'|ε                Put three extra copies of the character, a pipe, an empty string
   35*                   and a 15 on the stack.
   ('!=                  Move one copy of the character to the top and push 1 if it's a !
   ╜+                    Load the accumulator, add the 1 or 0 from the preceding test
   ;╗                    Make a copy, and save it back to register 0
   %                     Modulo the sum by 15
   (' =|                 Or the result with whether the dug-up character is " "
   ('0=|                 Or the result with whether the dug-up character is "0"
   I                     If we're at " " or "0" or the current sum is not divisible by 15,
                         push empty string, else push "|"
   )                     Bury the new character under the original character.
εj                   Join the list that resulted from the map into a single string.
'|@s                 Resplit the string on occurrences of "|" (after every 15 "!"s)
`ôl`╝                Store a function in register 1 which trims whitespace
                     and returns the length of the remaining string
` ... `M             Map the list with the following function:
   ö                     Trim leading spaces.
   '0@s                  Split the string on occurrence of "0"
   ╛M                    Map the resulting list with the function stored in register 1
d;                   Push the last sublist from the resulting list and make a copy.
Σ                    Find the sum of the list.
35*-                 Subtract it from 15
;`X``@q`Iƒ           Duplicate it, drop it if it's zero, put it in the list otherwise.
@q.                  Put the list back in the big list and print it.
— quintopia
fonte
Se vengono utilizzati punti di codice Unicode, questi caratteri contano come 2 byte ciascuno? : P
— Dan,
Sto usando l'unicode nella fonte rappresentata in modo che possa essere letto come dovrebbe apparire. Altrimenti sembrerebbe spazzatura a caso piena di non stampabili. La fonte ufficiale è la discarica esadecimale.
— Quintopia,
Doveva essere una domanda divertente
— Dan,
1
Era anche una domanda ragionevole di cui un altro lettore potrebbe chiedersi, quindi ho risposto senza umorismo.
— Quintopia,
@quintopia +1 Per provare una nuova lingua per il golf! Le nuove lingue sono divertenti;) Ho provato Pyth per la prima volta anche su questa domanda.
— csga5000,
3

Javascript, 138 128 byte

i=>eval("for(o=z=n='',m=15,t=q=0;q<i.length;q++)(t+=c=+i[q])>=m?(t-=m,z+=c-t,o+=z+`\n`,z=t>0?t+' ':n):z+=c+' ';t<m?o+z+(m-t):o")

Con spazi bianchi:

i => eval("
  for(o=z=n='', m=15, t=q=0; q < i.length; q++)
    (t+=c=+i[q])>=m
      ?(
        t-=m,
        z+=c-t,
        o+=z+`\n`,
        z=t>0?t+' ':n)
      :
        z+=c+' '
    ;
  t<m ? o+z+(m-t) : o
")

Esempio:

Assegna la funzione a una variabile

sumFifteen=i=>eval("for(o=z=n='',m=15,t=q=0;q<i.length;q++)(t+=c=+i[q])>=m?(t-=m,z+=c-t,o+=z+`\n`,z=t>0?t+' ':n):z+=c+' ';t<m?o+z+(m-t):o")

Quindi valuta in questo modo:

console.log(sumFifteen([1,4,11,4,5]))

1 4 10
1 4 5 5

Cronologia delle revisioni:

03/12/2015 00:02 - Grazie a user81655 (+1 lui nei commenti) per il miglioramento di 10 byte

12/12/2015 alle 21:44 - Passato allo stile funzionale per ridurre le dimensioni.

— csga5000
fonte
3
Potresti migliorare questo con questi: f=non è necessario secondo le regole del sito, rimuovi le parentesi da (i), circondale con evalcosì non hai bisogno returno le parentesi e sostituisci ifcon un ternario in modo che osia restituito e cambia '\n'in `\n`, unisci t+=...con t>=mper rimuovere per parentesi ad anello. Ecco la tua soluzione in 127 byte con tutti questi miglioramenti:i=>eval("for(o=z=n='',m=15,t=q=0;q<i.length;q++)(t+=c=+i[q])>=m?(t-=m,z+=c-t,o+=z+`\n`,z=t>0?t+' ':n):z+=c+' ';t<m?o+z+(m-t):o")
— user81655
@ user81655 Implementerò alcune di queste modifiche! Quando provo il tuo ottengo un SytaxError: token inatteso ILLEGAL (...). Nota, per testare la funzione ho aggiunto f =
— csga5000 il
1
SO aggiunge alcuni simboli dopo o+alla fine della riga. Eliminalo o+=ze scrivilo di nuovo e funzionerà. : P
— user81655,
@ user81655 Non vedo come \nfa la differenza
— csga5000,
1
Intendi il `\n`? Non funzionerà senza di esso perché il codice è dentro a "..."causa di eval.
— user81655
2

Python 3: 139 byte

Approccio leggermente diverso rispetto all'altra risposta. Produce l'output effettivo dalla domanda perché inizialmente pensavo fosse un requisito.

def f(l):
 m=15;r,s=sum(l)%m,0
 if r:l+=[m-r]
 while l:
  x=l.pop(0)
  if s+x>m:y=m-s;l[0:0]=[x-y];x=y
  s+=x;print(x,end=' \n'[s==m]);s%=m

Esempio di utilizzo:

>>> f([2, 4, 5, 9, 2, 3, 5, 0, 2, 4, 5, 0, 3])
2 4 5 4
5 2 3 5
0 2 4 5 0 3 1
— colpire
fonte
2

Perl, 86 byte

#!perl -p
s|\d+( ?)|($i+=$&)<15?$&:($a=$&-($i%=15)).$/.($&>$a&&$&-$a.$1)|ge;$\=$".(15-$i)if$i

Contando lo shebang come tre, l'input è preso dallo stdin, lo spazio è separato.

Esempio di utilizzo

$ echo -n 2 4 5 9 2 3 5 0 2 4 5 0 3 | perl sum15.pl
2 4 5 4
5 2 3 5
0 2 4 5 0 3 1
— Primo
fonte
2

R, 155 byte

n=scan();while(S<-sum(n)){C=cumsum(n);if(S>14){w=which(C>14)[1];N=n[1:w];n=n[-(1:w)];r=C[w]-15;N[w]=N[w]-r;if(r)n=c(r,n);cat(N,"\n")}else{cat(n,15-S);n=0}}

Con rientri e interruzioni di riga:

n=scan()
while(S<-sum(n)){
     C=cumsum(n)
     if(S>14){
         w=which(C>14)[1]
         N=n[1:w]
         n=n[-(1:w)]
         r=C[w]-15
         N[w]=N[w]-r
         if(r) n=c(r,n)
         cat(N,"\n")
         }else{
            cat(n,15-S)
             n=0
             }
      }

Uso:

> n=scan();while(S<-sum(n)){C=cumsum(n);if(S>14){w=which(C>14)[1];N=n[1:w];n=n[-(1:w)];r=C[w]-15;N[w]=N[w]-r;if(r)n=c(r,n);cat(N,"\n")}else{cat(n,15-S);n=0}}
1: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
18: 
Read 17 items
1 2 3 4 5 
6 7 2 
6 9 
10 5 
6 9 
3 12 
1 14 
15 
15 
1 14 
3 12
> n=scan();while(S<-sum(n)){C=cumsum(n);if(S>14){w=which(C>14)[1];N=n[1:w];n=n[-(1:w)];r=C[w]-15;N[w]=N[w]-r;if(r)n=c(r,n);cat(N,"\n")}else{cat(n,15-S);n=0}}
1: 20 20
3: 
Read 2 items
15 
5 10 
10 5
> n=scan();while(S<-sum(n)){C=cumsum(n);if(S>14){w=which(C>14)[1];N=n[1:w];n=n[-(1:w)];r=C[w]-15;N[w]=N[w]-r;if(r)n=c(r,n);cat(N,"\n")}else{cat(n,15-S);n=0}}
1: 10 5
3: 
Read 2 items
10 5 
> n=scan();while(S<-sum(n)){C=cumsum(n);if(S>14){w=which(C>14)[1];N=n[1:w];n=n[-(1:w)];r=C[w]-15;N[w]=N[w]-r;if(r)n=c(r,n);cat(N,"\n")}else{cat(n,15-S);n=0}}
1: 2 4 5 9 2 3 5 0 2 4 5 0 3
14: 
Read 13 items
2 4 5 4 
5 2 3 5 
0 2 4 5 0 3 1
— plannapus
fonte
2

Python 2, 117 byte

i=input()
while i:
 s=15;r=[]
 while s>0:n=i.pop(0)if i else s;s-=n;r+=[n]if s>=0 else[n+s]
 if s<0:i=[-s]+i
 print r

Accetta input come elenco:

>>[2,4,5,9,2,3,5,0,2,4,5,0,3]
[2, 4, 5, 4]
[5, 2, 3, 5]
[0, 2, 4, 5, 0, 3, 1]
— TFeld
fonte
1

Perl, 76 byte

Include +3 per -p (normalmente +1, ma +3 per giocare bene con l'altra soluzione perl)

Esegui con l'input su STDIN (la nuova riga finale sull'input è facoltativa, ma DEVE essere assente per l'input vuoto)

sum15.pl <<< "1 2 3"

sum15.pl:

#!/usr/bin/perl -p
s/$/ 15/;s/\d+/1x$&/eg;s/( *1){15}\K ?/
/g;s/
1*
*$//;s/1+|\B/length$&/eg

Ma guarda, nessun calcolo ...

— Ton Hospel
fonte
Meglio tardi che mai! Soluzione molto bella però :)
— Dada,
0gli s sono piuttosto complicati in questa soluzione (rappresentata da spazi extra) e devo stare molto attento a gestire correttamente gli spazi per mantenere il numero di 0s corretto. In particolare considera gli input in cui una somma parziale è esattamente 15, come 1 14 2 13. Provali senza il "?" E guarda cosa succede
— Ton Hospel,
Sì, l'ho provato e ho visto che 0 sono stati aggiunti all'inizio di alcune righe come dici tu (ecco perché ho eliminato il mio commento 30 secondi dopo averlo pubblicato). Grazie
— Dada,
0

Java - 158 155 byte

Versione lambda di https://codegolf.stackexchange.com/a/65590/46866 di yassin-hajaj , Non sono sicuro se un invio valido, ma non hai abbastanza rappresentante per aggiungere un commento sulla risposta collegata. Contato utilizzando http://meta.codegolf.stackexchange.com/questions/4944/byte-counter-snippet 

a->{int c=0,j;String s="";f:for(int i:a){for(j=i;j-->0;)if(++c>14){s+=(i-j)+"\n";c=0;if(j<15){if(j>0)s+=j+" ";c+=j;continue f;}}s+=i+" ";}return s+(15-c);}

158 byte

a->{int c=0,j;String s="";f:for(int i:a){for (j=i;j-->0;)if(++c>14){s+=(i-j)+ "\n";c=0;if(j<15){if(j>0)s+=j+" ";c+=j;continue f;}}s+=i+ " ";}return s+(15-c);}

Ungolfed

a ->
    {
        int c=0, j;
        String s = "";
        f:
        for (int i : a) {
            for (j = i; j-- > 0; )
                if (++c > 14) {
                    s += (i - j) + "\n";
                    c = 0;
                    if (j < 15) {
                        if (j > 0) s += j + " ";
                        c += j;
                        continue f;
                    }
                }
            s += i + " ";
        }
        return s + (15 - c);
    }

può essere usato come 

Function<int[], String> func =a->{int c=0,j;String s="";f:for(int i:a){for (j=i;j-->0;)if(++c>14){s+=(i-j)+ "\n";c=0;if(j<15){if(j>0)s+=j+" ";c+=j;continue f;}}s+=i+ " ";}return s+(15-c);};
System.out.println(func.apply(new int[]{2, 4, 5, 9, 2, 3, 5, 0, 2, 4, 5 ,0 ,3}));
— The_Lone_Devil
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.