Probablement un simple défi de golf de code. Étant donné 2 entiers positifs met n, faites une liste de nvaleurs qui sont des entiers positifs dont la somme est égale au nombre m. Soit toutes les valeurs dans la sortie sont la même valeur ou la différence est exactement 1.

Exemples

Par exemple

• m=6et n=3deviendrait2, 2, 2
• m=7et n=3deviendrait 2, 2, 3ou 2, 3, 2ou 3, 2, 2
• m=7et n=2deviendrait 3, 4ou4, 3
• m=7et n=1deviendrait7
• m=7et n=8générerait une erreur car la somme de 8 entiers positifs ne peut pas être 7.
• m=10et n=4deviendrait 3, 3, 2, 2ou toute autre permutation

Règles

• L'entrée et la sortie concernent uniquement des entiers positifs.
• Soit toutes les valeurs dans la sortie sont la même valeur ou la différence est exactement 1.
• L'ordre des valeurs dans la liste n'est pas important.
• La somme des valeurs de la liste est égale à m.
• Lorsqu'il n'est pas résoluble, générer une erreur ou une fausse valeur (dans le cas de m = 7 et n = 8 par exemple).
• En raison des autres règles m=8et n=3générerait l'une des permutations de 3, 3, 2(non 2, 2, 4)

Le gagnant

Il s'agit de code-golf, donc la réponse valide la plus courte - mesurée en octets - l'emporte.

Gaia , 4 octets

…÷l¦

Il y a presque juste une fonction intégrée pour cela ...

Explication

…     Get the range [0 .. m-1].
 ÷    Split into n roughly even length chunks. Throws an error if the number of chunks if 
       more than the list's length.
  l¦  Get the length of each chunk.

Python 2 , 48 43 octets

Retourne 0sur erreur.

lambda m,n:m/n and[m/n]*(n-m%n)+m%n*[m/n+1]

Essayez-le en ligne!

41 octets (avec astuce @ xnor)

Lance une NameErrorerreur.

lambda m,n:[m/n or _]*(n-m%n)+m%n*[m/n+1]

Essayez-le en ligne!

Mathematica, 33 octets

#>#2&&Last@IntegerPartitions@##1&

contribution

[63, 11]

production

{6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5}

renvoie Faux lorsqu'il n'est pas résoluble

MATL , 7 octets

:gie!Xs

Lorsqu'il n'y a pas de solution, la sortie est un tableau contenant au moins un zéro, ce qui est faux dans MATL.

Essayez-le en ligne!

Explication

Considérez les entrées m = 10et n = 4.

:      % Implicitly input m. Push [1 2 ... m]
       % STACK: [1 2 3 4 5 6 7 8 9 10]
g      % Logical: convert nonzeros to 1
       % STACK: [1 1 1 1 1 1 1 1 1 1]
i      % Input n
       % STACK: [1 1 1 1 1 1 1 1 1 1], 4
e      % Reshape into matrix with n rows, padding with zeros
       % STACK: [1 1 1;
                 1 1 1;
                 1 1 0;
                 1 1 0]
!      % Transpose
       % STACK: [1 1 1 1;
                 1 1 1 1;
                 1 1 0 0]
Xs     % Sum of each column. Implicitly display
       % STACK: [3 3 2 2]

Haskell , 30 octets

m%n|m>=n=map(`div`n)[m..m+n-1]

Essayez-le en ligne!

Fusain , 15 octets après application de NDD ¹

¿÷ＮＮＩＥＩη÷⁺ＩθιＩη

Essayez-le en ligne!

N'affiche rien s'il n'y a pas de solution. Lien vers la version détaillée .

¹ NDD = Neil-Driven Development.

Ma réponse précédente:

Charbon de bois , 32 27 24 20 octets

ＮμＮν¿÷μνＩＥν⁺÷μν‹ι﹪μν

Essayez-le en ligne!

N'affiche rien s'il n'y a pas de solution. Lien vers la version détaillée .

Bien sûr, je n'aurais pas pu jouer au golf sans l'aide de Neil.

R , 33 octets

function(m,n)diff(trunc(0:n*m/n))

Un port de la réponse Octave de Luis Mendo . Assez triste que ce soit presque 50% plus court que ma réponse précédente.

Essayez-le en ligne!

réponse précédente, 63 octets:

function(m,n,o=rep(m%/%n,n),d=m-sum(o))o+c(rep(0,n-d),rep(1,d))

Une fonction anonyme qui prend deux arguments (obligatoires) met n, et deux optionnels qui sont à des fins de golf. Renvoie un vecteur dans l'ordre croissant. En cas d'échec, la première valeur sera 0, qui est falsey dans R, car ifn'utilise que la première valeur du vecteur (avec un avertissement).

Il est essentiellement équivalent à la fonction suivante:

function(m,n){o=rep(m%/%n,n)
d=m-sum(o)
o+c(rep(0,n-d),rep(1,d))}

Essayez-le en ligne!

Gelée , 7 6 octets

:ȧœsL€

Essayez-le en ligne! Ne produit rien pour la falsification.

Comment ça fonctionne

:ȧœsL€    Main link. Arguments: m (integer), n (integer)
:         Integer division. Yields 0 if m < n; a positive integer otherwise.
 ȧ        Logical AND. Yields 0 if m < n; m otherwise.
  œs      Split into n roughly equal groups. Since the left argument is an integer,
          this implicitly converts it to [1..m] (or [] for 0) before splitting.
    L€    Length of €ach. If the inputs were 7 and 3, the previous result would be
          [[1,2,3],[4,5],[6,7]], so this would give [3,2,2].

TI-Basic, 23 octets

:Prompt M,N
:N(M≥N
:int(Ans⁻¹randIntNoRep(M,M+N-1

Renvoie ERR: DIVIDE BY 0 en cas d'erreur

Octave , 24 octets

@(m,n)diff(fix(0:m/n:m))

Le code définit une fonction anonyme. La sortie est un tableau numérique (vecteur ligne). Lorsqu'il n'y a pas, ce tableau contient au moins un zéro, ce qui est faux dans Octave.

Essayez-le en ligne!

Explication

0:m/n:m produit un tableau de n+1 valeurs de 0à mavec step m/n. fixarrondit chaque entrée vers 0et diffcalcule les différences consécutives.

À titre d'exemple, voici tous les résultats intermédiaires pour m = 7, n = 3:

>> 0:m/n:m
ans =
         0    2.3333    4.6667    7.0000

>> fix(0:m/n:m)
ans =
     0     2     4     7

>> diff(fix(0:m/n:m))
ans =
     2     2     3

Haskell , 93 89 88 87 86 71 octets

m!n|n<=m=e$m:(0<$[2..n])
e(a:b:x)|b<a=e$a-1:e(b+1:x)
e(a:x)=a:e x
e x=x

Essayez-le en ligne!

Explication

La fonction principale ici est e . eprendra une liste et exécutera essentiellement un rouleau à pâtisserie le long de la gauche vers la droite. Bien qu'il y ait un élément dans la liste qui soit supérieur à son voisin de droite, nous en déplacerons un vers la droite.

Maintenant, tout ce que nous avons à faire est d'alimenter cette fonction d'une liste suffisamment déséquilibrée et de lui permettre de faire la magie. La liste que nous choisirons est juste msuivie den-1 zéros. Puisque c'est facile à faire.

La dernière chose que nous devons faire est de nous assurer que le cas d'erreur est traité. Pour cela, nous jetons simplement une Non-exhaustive patterns in functionerreur aussi longtemps que m>n.

C # (.NET Core) , 86 82 71 octets

using System.Linq;a=>b=>new int[b].Select((x,i)=>(i<a%b?1:0/(a/b))+a/b)

renvoie une erreur pour les entrées non valides.

Essayez-le en ligne!

-4 octets grâce à TheLethalCoder

-11 octets grâce à OlivierGrégoire

Haskell, 48 octets

m#n|m>=n=iterate(\(a:b)->b++[a+1])(0<$[1..n])!!m

Commencez par une liste de nzéros. Répéterm : prenez le premier élément, ajoutez-en un et placez-le à la fin de la liste.

Échoue avec une erreur de correspondance de modèle si n < m.

Essayez-le en ligne!

Braingolf , 30 octets

.M>.M/v.mR>[.]$_v%!?[R1+>v]|R=

Essayez-le en ligne!

Prend les entrées dans l'ordre inverse ( nest la première entrée,m est la deuxième)

Divise mpar n, duplique les ntemps de résultat , puis les boucle et les incrémente une à une m % nfois

Lot, 71 octets

@if %1 geq %2 for /l %%i in (1,1,%2)do @cmd/cset/an=(%1+%%i-1)/%2&echo(

cmd/cset/ane produit aucun séparateur, je dois donc utiliser echo(( (évite l'impression ECHO is on.).

PHP> = 7.1, 62 octets

for([,$s,$n]=$argv;$n;)$s-=$r[]=$s/$n--^0;$r[0]?print_r($r):0;

PHP Sandbox Online

Python 2 , 41 octets

lambda m,n:(m%n*[m/n+1]+[m/n or _]*n)[:n]

Essayez-le en ligne!

NameError quand c'est impossible.

Python 2 , 43 octets

lambda m,n:[c/n for c in range(m,m+n,m>=n)]

Essayez-le en ligne!

ValueError quand c'est impossible.

Javascript (ES6), 57 56 53 41 octets

m=>n=>m>=n&&[...Array(n)].map(_=>m++/n|0)

La réponse inclut désormais une manière plus intelligente de créer les valeurs. Merci @Neil

Usage

f=m=>n=>m>=n&&[...Array(n)].map(_=>m++/n|0)

f(6)(3) // [2, 2, 2]
f(7)(3) // [3, 2, 2]
f(7)(2) // [4, 3]
f(7)(1) // [7]
f(7)(8) // false
f(8)(3) // [3, 3, 2]

Histoire

Première mine

(m,n)=>m>=n&&Array(n).fill(~~(m/n)).map((v,i)=>v+(i<m%n))

(m,n)=>m>=n&&Array(n).fill().map((v,i)=>~~(m/n)+(i<m%n))

Puis ajouté l'opérateur d'étalement et la syntaxe de curry inclinée par @Arnauld

m=>n=>m>=n&&[...Array(n)].map((v,i)=>~~(m/n)+(i<m%n))

Java (OpenJDK 8) , 80 73 63 61 59 octets

n->m->{for(int i=n;i-->0/(m/n);)System.out.println(m++/n);}

Essayez-le en ligne!

Remarque, à des fins de curry, met nsont inversés.

Pyth , 11 octets

efqlTeQ./hQ

Essayez-le en ligne!

Pyth , 13 octets

KE?>KQ0lMcK*d

Essayez-le en ligne! Sortie 0en cas d'erreur.

Tricherie, 6 octets

lMcE*d

Essayez-le en ligne! Le tableau contient une 0erreur. Malheureusement, ce n'est pas faux en Pyth .

Explication

KE?>KQ0lMcK*dQ    # Implicit input Q for m
KE                # Store n in K
           *d     # Generate a string of length Q containing only spaces
         cK       # Chop this string in K pieces of equal sizes, initial piece longer if necessary
       lM         # For each string, compute the length. Here we already have our result. However if the array contain a zero, we must output a falsy value
  ?>KQ            # If K > Q...
      0           # Then display zero, otherwise display the array

CJam , 13 12 octets

{_2$>/,/z:,}

Essayez-le en ligne!

Il s'agit d'un bloc anonyme qui prend l'entrée comme n msur la pile. Cela aurait été une bonne réponse, mais l'exigence de gestion des erreurs l'a complètement détruite.

Erreurs avec une division par zéro lorsqu'il n'est pas possible de les résoudre.

Explication

{   e# Stack:                | 3 10
 _  e# Duplicate:            | 3 10 10
 2$ e# Copy from back:       | 3 10 10 3
 >  e# Greater than:         | 3 10 1 (true)
 /  e# Divide:               | 3 10
    e# This will cause an error on invalid input.
 ,  e# Range:                | 3 [0 1 2 3 4 5 6 7 8 9]
 /  e# Split on nth element: | [[0 1 2] [3 4 5] [6 7 8] [9]]
 z  e# Transpose array:      | [[0 3 4 9] [1 4 7] [2 5 8]]
 :, e# Length of each:       | [4 3 3]
}

Si l'exigence de gestion des erreurs est levée, celle-ci peut être raccourcie à 7 octets, ce qui représente une diminution de plus de 40%:

{,/z:,}