La somme est toujours 15

36

Ecrivez un programme ou une fonction qui prend en entrée un tableau d’entiers non négatifs et sort un ensemble de vecteurs / tableaux avec les éléments du tableau en entrée dans l’ordre, séparez-les de manière à ce que chaque vecteur soit égal à 15. Si la somme du premier N éléments ne "frappent pas 15", alors le nombre qui a fait passer 15 doit être coupé, et le reste sera le premier élément du vecteur suivant. Cela se poursuit jusqu'à la fin du tableau d'entrée. Si la somme du vecteur final est inférieure à 15, il faut ajouter un nombre à la fin pour que la somme augmente.

Je pense que les règles sont plus faciles à comprendre en regardant les exemples:

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.

Le format d’entrée et le format de sortie sont optionnels. Quel que soit le meilleur dans votre langue.

Le code le plus court en octets gagne.

Classement

L'extrait de pile au bas de cet article génère le catalogue à partir des réponses a) sous forme de liste des solutions les plus courtes par langue et b) sous forme de classement global.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

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

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de langue un lien qui apparaîtra ensuite dans l'extrait de code:

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

Afficher l'extrait de code

code-golf math arithmetic array-manipulation Stewie Griffin
la source
"Le format de sortie est facultatif". Est-ce que cela signifie que ce [[3, 7, 5], [10, 5]]serait une sortie valide pour le premier cas de test?
Morgan Thrapp
@ MorganThrapp, oui. c'est valide.
Stewie Griffin
1
@FlagAsSpam, j'ai ajouté plus d'explications dans l'exemple dont vous parlez.
Stewie Griffin
3
Bon cas de test:Input: 100 Output: 15; 15; 15; 15; 15; 15; 10 5
randomra
3
Cela devrait définitivement remplacer le test
FizzBuzz

Réponses:

8

Pyth, 37 octets

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

A expliqué

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)

C'était mon premier pyth, alors n'hésitez pas à suggérer des améliorations.

Exemple:

Contribution

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

Sortie

1
3
4
5
2


7
8

Remarque: Merci beaucoup à Isaacg pour plusieurs octets de conseils de réduction de taille et pour la création de pyth! S'il vous plaît upvote ses commentaires ci-dessous :)

csga5000
la source
2
Else a récemment été changé pour être à la .?place de E, mais j'ai oublié de mettre à jour la documentation. Désolé pour ça.
isaacg
@isaacg Merci isaacg! Je devrais le faire fonctionner maintenant. Bien qu’il ne sauve qu’un octet puisque le reste a 2 caractères maintenant.
csga5000
1
En le réparant au moment où nous parlons
isaacg
3
Quelques autres suggestions: =Z+ZNet =+ZNsont les mêmes. C'est un peu comme Python +=. Likewiese, =Z-ZK-> =-ZK. De plus, vous n’avez pas besoin )de la fin, elle est remplie automatiquement. Enfin, FNQet VQsont les mêmes.
isaacg
1
Vous pouvez économiser 2 octets supplémentaires en remplaçant I>Z0par IZ- Zne peut pas être négatif, vous ne vérifiez donc que si la valeur Zest différente de zéro et que la valeur 0 est falsifiée, alors que tous les autres nombres sont véridiques.
isaacg
16

Java - 229 200 192 181 172 170 170 octets

Avait déjà commencé, pas pour la victoire mais pour le plaisir :)
Toute suggestion est la bienvenue.

Sauvegardé 8 octets grâce à @ThomasKwa
Sauvegardé 20 octets grâce à @corsiKa
Sauvegardé 2 octets grâce à @Ypnypn
Sauvegardé 2 octets grâce à @ 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 octets

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 octets

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 octets

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 octets

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 octets

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 octets

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
la source
1
Wow, je n'avais jamais vu continuer à être utilisé dans un programme Java jusqu'à maintenant.
Urne Magique Octopus
7

Python 3 - 1̶7̶7̶ 1̶3̶8̶ 1̶66̶ 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)

Edit 5 Vraiment joué grâce à @poke * lignes supprimées, etc.

Éditer 4 Alias, et remplacé a = par un - = pour sauvegarder un octet. Merci à @poke et @elzell. Déplacement également eval d'entrée dans la boucle for pour économiser 2 octets de l'attribution

Éditer 3 Économies trouvées dans différents OO en une seconde si

Edit 2 Bug corrigé

Modifier 1 L'entrée a été modifiée pour se présenter sous la forme '[1,2,3,4,5 ...]' et les deux premiers commentaires ont été implémentés, grâce à @Morgan Thrapp

Première affiche ici. L'entrée est une ligne de commande avec des entrées séparées par des espaces, la sortie est une entrée par ligne, avec une nouvelle ligne entre les groupes.

Adam Martin
la source
3
Vous pouvez le réduire à 122 en affectant 15 à une variable et en n'utilisant qu'un seul espace pour l'indentation.
Morgan Thrapp
De plus, vous échouez au deuxième test, je reçois 2 3 5, mais cela devrait être 5 2 3 5.
Morgan Thrapp
1
@AdamMartin Vous pouvez être intéressé par ma version Pyth de votre code
csga5000
1
Puisque vous utilisez printsouvent, vous devez l' enregistrer comme une variable: p=print. Vous permet d'économiser 14 autres caractères.
Poke
2
Le nombre actuel est de 132, mais vous pouvez le réduire à 113 si vous supprimez certains des sauts de ligne. Vous pouvez combiner tous les si en une seule ligne, par exemple if s>i:s-=i;p(e-s);p();e=spour la seconde. Cela vous évite les sauts de ligne et les caractères d'indentation.
Poke
7

Haskell, 126 107 102 100 octets

[]#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])

Exemple d'utilisation: (#[]).(++[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]]

Edit: @ Steinie Griffin m'a aidé à économiser 19 octets. Merci!

nimi
la source
4

CJam, 39 octets

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

Testez-le ici.

Cela semble très sous-optimal, mais jusqu’à présent, toutes mes tentatives pour trouver une solution plus courte ont été déjouées par la présence de zéros dans l’entrée.

Martin Ender
la source
4

Python2 alimenté par RegEx : 158 155 octets

Fabriqué en python avec amour et presque pas de maths.
Ou Regex Math si vous voulez, mathématiques unaires.
Les mathématiques «réelles» utilisées uniquement pour «corriger» la dernière exigence:

Si la somme du vecteur final est inférieure à 15, il faut ajouter un nombre à la fin pour que la somme augmente.

Codegolfé:

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

Cela fonctionne en convertissant chaque nombre N en une chaîne de longueur N ( x choisi comme caractère pour remplir la chaîne) et en les joignant dans un espace séparé string. La chaîne résultante est divisée via RegEx BLACK MAGIC en quelque chose comme: 

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

pour une entrée du type: f([1, 2, 3, 4, 5, 6, 7, 8, 10])
Ceci est ensuite divisé à nouveau, et la longueur de xes consécutives est utilisée pour créer à nouveau les nombres, le tout étant bien présenté dans une liste de compréhension.

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

Sortie: 

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

Note: il n'y avait pas assez de magie pour les 0 alors cette entrée est disqualifiée

les zéros doivent être inclus. Voir le deuxième exemple

CSᵠ
la source
Tous ces noms de fonctions sont plutôt coûteux. L'utilisation de regex est presque impossible en code golf. Cependant, la taille de votre octet est pas mal vu
csga5000
4

Sérieusement, 88 octets

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

Essayez-le en ligne

C'est mon premier répondre sérieusement! Maintenant, je connais très bien toutes les lacunes de la langue!

Décharge Hex:

2c6027212a2730604d27206a30bb603b3b3b277cee33352a2827213dbd2b3bbb252827203d7c2827303d7c49
29604dee6a277c407360936c60bc609427304073be4d604d643be433352a2d3b60586060407160499f40712e

Explication:

,`'!*'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.
quintopie
la source
Si des points de code Unicode sont utilisés, ces caractères comptent-ils chacun pour 2 octets? : P
Dan
J'utilise l'unicode dans la source illustrée pour qu'il puisse être lu comme il se doit. Sinon, cela ressemblerait à une poubelle aléatoire remplie d’imprimables. La source officielle est le vidage d'hex.
Quintopia
C'était une question humoristique
Dan
1
C’était aussi une question raisonnable qu’un autre lecteur pourrait s’interroger, aussi j’ai répondu sans humour.
Quintopia
@quintopia +1 Pour essayer une nouvelle langue de golf! Les nouvelles langues sont amusantes;) J'ai aussi essayé pyth pour la première fois sur cette question.
csga5000
3

Javascript, 138 128 octets

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

Avec des espaces:

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

Exemple:

Attribuer la fonction à une variable

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

Alors évaluez comme ceci:

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

1 4 10
1 4 5 5

Historique des révisions:

03/12/2015 00:02 - Merci à user81655 (+1 lui dans les commentaires) pour l'amélioration de 10 octets

12/2/2015 21:44 - Passage à utiliser un style fonctionnel afin de réduire la taille.

csga5000
la source
3
Vous pouvez améliorer cela avec celles - ci: f=n'est pas nécessaire selon les règles du site, supprimez les parenthèses (i), surround avec de evalsorte que vous n'avez pas besoin returnou les crochets et remplacer ifpar un ternaire de sorte que oest retourné et le changement '\n'à `\n`, fusion t+=...avec t>=md'enlever pour crochets de fixation. Voici votre solution en 127 octets avec toutes ces améliorations: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 Je vais implémenter certaines de ces modifications! Lorsque j'essaie le vôtre, je reçois un SytaxError: jeton inattendu ILLEGAL (...). Remarque, afin de tester la fonction, j’ai ajouté f =
csga5000
1
SO ajoute quelques symboles o+à la fin de la ligne. Supprimez o+=zet écrivez à nouveau et cela fonctionnera. : P
user81655
@ user81655 Je ne vois pas en quoi cela \nfait une différence
csga5000
1
Tu veux dire le `\n`? Cela ne fonctionnera pas sans elle car le code est à l'intérieur à "..."cause de la eval.
user81655
2

Python 3: 139 octets

Approche légèrement différente de l’autre réponse. Produit le résultat réel de la question parce que j'avais initialement supposé que c'était une exigence.

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

Exemple d'utilisation:

>>> 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
poussée
la source
2

Perl, 86 octets

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

En comptant le shebang comme trois, l'entrée est prise de stdin, séparé par espace.

Exemple d'utilisation

$ 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
la source
2

R, 155 octets

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

Avec des retraits et des sauts de ligne:

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

Usage:

> 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
planificateur
la source
2

Python 2, 117 octets

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

Prend l'entrée sous forme de liste:

>>[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
la source
1

Perl, 76 octets

Inclut +3 pour -p(normalement +1, mais +3 pour jouer loyalement avec l'autre solution Perl)

Exécuter avec l'entrée sur STDIN (la nouvelle ligne finale sur l'entrée est facultative, mais DOIT être absente pour l'entrée vide)

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

Regardez ma, aucun calcul que ce soit ...

Ton Hospel
la source
Mieux vaut tard que jamais! Très bonne solution cependant :)
Dada
0s sont plutôt délicats dans cette solution (représentée par des espaces supplémentaires) et je dois faire très attention à bien gérer les espaces pour que le nombre de 0s reste correct. En particulier, considérons les entrées où une somme partielle est exactement 15, comme 1 14 2 13. Essayez-les sans le `?` Et voyez ce qui se passe
Ton Hospel
Oui, j'ai essayé et vu que des zéros étaient ajoutés au début de certaines lignes, comme vous le dites (c'est pourquoi j'ai supprimé mon commentaire 30 secondes après l'avoir posté). Merci
Dada
0

Java - 158 155 octets

Version lambda de https://codegolf.stackexchange.com/a/65590/46866 par yassin-hajaj , Vous ne savez pas si une soumission valide, mais vous n'avez pas assez de rep pour ajouter un commentaire sur la réponse liée. Compté à l'aide de 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 octets

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

peut être utilisé comme 

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