Provavelmente um simples desafio de código-golfe. Dados 2 inteiros positivos me n, faça uma lista de nvalores inteiros positivos cuja soma é igual ao número m. Todos os valores na saída são o mesmo valor ou a diferença é exatamente 1.

Exemplos

Por exemplo

• m=6e n=3se tornaria2, 2, 2
• m=7e n=3se tornaria 2, 2, 3ou 2, 3, 2ou 3, 2, 2
• m=7e n=2se tornaria 3, 4ou4, 3
• m=7e n=1se tornaria7
• m=7e n=8geraria um erro porque a soma de 8 números inteiros positivos não pode ser 7.
• m=10e n=4se tornaria 3, 3, 2, 2ou qualquer outra permutação

Regras

• Tanto a entrada como a saída são apenas números inteiros positivos.
• Todos os valores na saída são o mesmo valor ou a diferença é exatamente 1.
• A ordem dos valores na lista não é importante.
• A soma dos valores na lista é igual a m.
• Quando não for solucionável, gere um erro ou um valor falso (no caso de m = 7 en = 8, por exemplo).
• Como resultado de outras regras m=8e n=3geraria qualquer uma das permutações de 3, 3, 2(não 2, 2, 4)

O vencedor

Isso é código-golfe, então a resposta mais curta e válida - medida em bytes - vence.

Gaia , 4 bytes

…÷l¦

Há quase apenas um built-in para isso ...

Explicação

…     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

Retorna 0por erro.

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

Experimente online!

41 bytes (com o truque de @ xnor)

Lança NameErrorcom erro.

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

Experimente online!

Mathematica, 33 bytes

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

entrada

[63, 11]

resultado

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

gera False quando não é solucionável

MATL , 7 bytes

:gie!Xs

Quando não há solução, a saída é uma matriz que contém pelo menos um zero, o que é falso no MATL.

Experimente online!

Explicação

Considere entradas m = 10e 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]

Experimente online!

Carvão vegetal , 15 bytes após a aplicação do NDD ¹

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

Experimente online!

Não produz nada se não houver solução. Link para a versão detalhada .

¹ NDD = Desenvolvimento Dirigido por Neil.

Minha resposta anterior:

Carvão , 32 27 24 20 bytes

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

Experimente online!

Não produz nada se não houver solução. Link para a versão detalhada .

Claro, eu não poderia ter jogado o jogo sem a ajuda de Neil.

R , 33 bytes

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

Um porto da resposta oitava de Luis Mendo . Muito triste que isso seja quase 50% menor que minha resposta anterior.

Experimente online!

resposta anterior, 63 bytes:

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

Uma função anônima que recebe dois argumentos (obrigatórios) me n, e dois opcionais, para fins de golfe. Retorna um vetor em ordem crescente. Para falha, o primeiro valor será 0, que é falsey em R, pois ifusa apenas o primeiro valor do vetor (com um aviso).

É essencialmente equivalente à seguinte função:

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

Experimente online!

Geléia , 7 6 bytes

:ȧœsL€

Experimente online! Não produz nada por falsidade.

Como 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

Retorna ERR: DIVIDE BY 0 em erro

Oitava , 24 bytes

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

O código define uma função anônima. A saída é uma matriz numérica (vetor de linha). Quando não existe, essa matriz contém pelo menos um zero, o que é falso na oitava.

Experimente online!

Explicação

0:m/n:mproduz uma matriz de n+1valores de 0para mcom o passo m/n. fixarredonda cada entrada para 0ediff calcula diferenças consecutivas.

Como um exemplo, estão aqui todos os resultados intermédios 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

Experimente online!

Explicação

A principal função aqui é e. efará uma lista e essencialmente executará um rolo ao longo da esquerda para a direita. Enquanto houver um elemento na lista que seja maior que seu vizinho à direita, moveremos um deles para a direita.

Agora tudo o que precisamos fazer é alimentar essa função com uma lista suficientemente desigual e permitir que ela faça a mágica. A lista que escolheremos é apenas mseguida por n-1zeros. Desde que é fácil de fazer.

A última coisa que precisamos fazer é garantir que o caso de erro seja tratado. Para isso, apenas lançamos um Non-exhaustive patterns in functionerro enquanto 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)

gera um erro para entradas inválidas.

Experimente online!

-4 bytes graças ao TheLethalCoder

-11 bytes graças a OlivierGrégoire

Haskell, 48 bytes

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

Comece com uma lista de n zeros. Repetirm tempos: pegue o primeiro elemento, adicione um e coloque-o no final da lista.

Falha com um erro de correspondência de padrão se n < m .

Experimente online!

Braingolf , 30 bytes

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

Experimente online!

Recebe entradas na ordem inversa ( né a primeira entrada, mé a segunda)

Divide mpor n, duplica os ntempos do resultado , depois percorre e incrementa uma a uma m % nvezes

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/anão produz nenhum separador, então eu tenho que usar echo(( (evita a impressão ECHO is on.).

PHP> = 7.1, 62 bytes

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

Sandbox do PHP Online

Python 2 , 41 bytes

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

Experimente online!

NameError quando impossível.

Python 2 , 43 bytes

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

Experimente online!

ValueError quando impossível.

Javascript (ES6), 57 56 53 41 bytes

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

A resposta agora inclui uma maneira mais inteligente de criar os valores. Obrigado @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]

História

Primeira mina

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

Em seguida, adicionou o operador de propagação e a sintaxe de currying com dicas 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);}

Experimente online!

Observe, para currying, me nsão revertidos.

Pitão , 11 bytes

efqlTeQ./hQ

Experimente online!

Pitão , 13 bytes

KE?>KQ0lMcK*d

Experimente online! Saída 0com erro.

Trapaça, 6 bytes

lMcE*d

Experimente online! A matriz contém um 0erro. Infelizmente, isso não é falso em Pyth .

Explicação

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

Experimente online!

Este é um bloco anônimo que recebe a entrada como n mna pilha. Teria sido uma boa resposta, mas o requisito de manipulação de erros o eliminou completamente.

Erros com uma divisão por zero quando não é possível resolver.

Explicação

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

Se o requisito de tratamento de erros for levantado, ele poderá ser reduzido para 7 bytes, o que representa uma diminuição de mais de 40%:

{,/z:,}