Probablemente un simple desafío de código de golf. Dados 2 enteros positivos my n, haga una lista de nvalores que sean enteros positivos cuya suma sea igual al número m. O todos los valores en la salida son el mismo valor o la diferencia es exactamente 1.

Ejemplos

Por ejemplo

• m=6y n=3se convertiría2, 2, 2
• m=7y n=3se convertiría 2, 2, 3o 2, 3, 2o 3, 2, 2
• m=7y n=2se convertiría 3, 4o4, 3
• m=7y n=1se convertiría7
• m=7y n=8generaría un error porque la suma de 8 enteros positivos no puede ser 7.
• m=10y n=4se convertiría en 3, 3, 2, 2cualquier otra permutación

Reglas

• Tanto la entrada como la salida son solo enteros positivos.
• O todos los valores en la salida son el mismo valor o la diferencia es exactamente 1.
• El orden de los valores en la lista no es importante.
• La suma de los valores en la lista es igual a m.
• Cuando no se puede resolver, genere un error o un valor falso (en el caso de m = 7 yn = 8, por ejemplo).
• Como resultado de las otras reglas m=8y n=3generaría cualquiera de las permutaciones de 3, 3, 2(no 2, 2, 4)

El ganador

Este es el código de golf, por lo que gana la respuesta válida más corta, medida en bytes.

Gaia , 4 bytes

…÷l¦

Casi solo hay un incorporado para esto ...

Explicación

…     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 bytes

Devoluciones 0por error.

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

Pruébalo en línea!

41 bytes (con el truco de @ xnor)

Lanza NameErroren error.

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

Pruébalo en línea!

Mathematica, 33 bytes

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

entrada

[63, 11]

salida

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

da como resultado Falso cuando no es solucionable

MATL , 7 bytes

:gie!Xs

Cuando no hay solución, la salida es una matriz que contiene al menos un cero, que es falso en MATL .

Pruébalo en línea!

Explicación

Considere las entradas m = 10y 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 bytes

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

Pruébalo en línea!

Carbón , 15 bytes después de aplicar NDD ¹

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

Pruébalo en línea!

No genera nada si no hay solución. Enlace a la versión detallada .

¹ NDD = Desarrollo Neil-Driven.

Mi respuesta anterior:

Carbón , 32 27 24 20 bytes

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

Pruébalo en línea!

No genera nada si no hay solución. Enlace a la versión detallada .

Por supuesto, no podría haber jugado golf sin la ayuda de Neil.

R , 33 bytes

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

Un puerto de la respuesta de octava de Luis Mendo . Es bastante triste que esto sea casi un 50% más corto que mi respuesta anterior.

Pruébalo en línea!

respuesta anterior, 63 bytes:

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

Una función anónima que toma dos argumentos (obligatorios) m y n, y dos opcionales que son para los propósitos de golf. Devuelve un vector en orden creciente. Para el fallo, el primer valor será 0, que es falsey en R, ya que ifsolo usa el primer valor del vector (con una advertencia).

Es esencialmente equivalente a la siguiente función:

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

Pruébalo en línea!

Gelatina , 7 6 bytes

:ȧœsL€

Pruébalo en línea!No produce nada por falsedad.

Cómo funciona

:ȧœ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 bytes

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

Devuelve ERR: DIVIDE BY 0 en caso de error

Octava , 24 bytes

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

El código define una función anónima. La salida es una matriz numérica (vector de fila). Cuando no hay esta matriz contiene al menos un cero, que es falso en Octave.

Pruébalo en línea!

Explicación

0:m/n:mproduce una matriz de n+1valores de 0a mcon paso m/n. fixredondea cada entrada hacia0 y diffcalcula diferencias consecutivas.

A modo de ejemplo, aquí están todos los resultados intermedios para 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 bytes

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

Pruébalo en línea!

Explicación

La función principal aquí es e. etomará una lista y esencialmente ejecutará un rodillo a lo largo de izquierda a derecha. Si bien hay un elemento en la lista que es mayor que su vecino a la derecha, moveremos uno de él a la derecha.

Ahora todo lo que tenemos que hacer es alimentar esta función con una lista lo suficientemente desproporcionada y permitirle hacer la magia. La lista que elegiremos va mseguida de n-1ceros. Ya que eso es fácil de hacer.

Lo último que debemos hacer es asegurarnos de que se maneje el caso de error. Para esto solo lanzamos un Non-exhaustive patterns in functionerror siempre que m>n.

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

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

arroja un error para entradas no válidas.

Pruébalo en línea!

-4 bytes gracias a TheLethalCoder

-11 bytes gracias a OlivierGrégoire

Haskell, 48 bytes

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

Comience con una lista de n ceros. Repita los mtiempos: tome el primer elemento, agregue uno y colóquelo al final de la lista.

Falla con un error de coincidencia de patrón si n < m.

Pruébalo en línea!

Braingolf , 30 bytes

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

Pruébalo en línea!

Toma entradas en orden inverso ( nes la primera entrada,m es la segunda)

Divide mpor n, duplica los ntiempos de resultado , luego recorre e incrementa uno por uno m % nveces

Lote, 71 bytes

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

cmd/cset/a no genera ningún separador, así que tengo que usar echo( ( (evita la impresión ECHO is on.).

PHP> = 7.1, 62 bytes

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

PHP Sandbox en línea

Python 2 , 41 bytes

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

Pruébalo en línea!

NameError cuando es imposible

Python 2 , 43 bytes

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

Pruébalo en línea!

ValueError cuando es imposible

Javascript (ES6), 57 56 53 41 bytes

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

La respuesta ahora incluye una forma más inteligente de crear los valores. Gracias @Neil

Uso

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]

Historia

Primero mio

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

Luego agregó el operador de propagación y la sintaxis de currículum con punta de @Arnauld

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

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

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

Pruébalo en línea!

Nota, para fines de curry, my nse invierten.

Pyth , 11 bytes

efqlTeQ./hQ

Pruébalo en línea!

Pyth , 13 bytes

KE?>KQ0lMcK*d

Pruébalo en línea! Salida0 por error.

Hacer trampa, 6 bytes

lMcE*d

Pruébalo en línea! La matriz contiene un 0error. Lamentablemente, esto no es falso en Pyth .

Explicación

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 bytes

{_2$>/,/z:,}

Pruébalo en línea!

Este es un bloque anónimo que toma la entrada como n m en la pila. Hubiera sido una buena respuesta, pero el requisito de manejo de errores lo eliminó por completo.

Errores con una división por cero cuando no es posible resolverlo.

Explicación

{   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 se levanta el requisito de manejo de errores, esto se puede acortar a 7 bytes, lo que es una disminución de más del 40%:

{,/z:,}