Distribuire un numero in un elenco di valori il più possibile uguale la cui somma è uguale a quel numero

15

Probabilmente una semplice sfida di code-golf. Dati 2 numeri interi positivi me n, crea un elenco di nvalori che sono numeri interi positivi la cui somma è uguale al numero m. Tutti i valori nell'output hanno lo stesso valore o la differenza è esattamente 1.

Esempi

Per esempio

  • m=6e n=3diventerebbe2, 2, 2
  • m=7e n=3diventerebbe 2, 2, 3o 2, 3, 2o 3, 2, 2
  • m=7e n=2diventerebbe 3, 4o4, 3
  • m=7e n=1diventerebbe7
  • m=7e n=8genererebbe un errore perché la somma di 8 numeri interi positivi non può essere 7.
  • m=10e n=4diventerebbe 3, 3, 2, 2o qualsiasi altra permutazione

Regole

  • Sia l'input che l'output riguardano solo numeri interi positivi.
  • Tutti i valori nell'output hanno lo stesso valore o la differenza è esattamente 1.
  • L'ordine dei valori nell'elenco non è importante.
  • La somma dei valori nell'elenco è uguale a m.
  • Quando non è risolvibile, genera un errore o un valore falso (ad esempio nel caso di m = 7 e n = 8).
  • Come risultato delle altre regole m=8e n=3genererebbe una qualsiasi delle permutazioni di 3, 3, 2(non 2, 2, 4)

Il vincitore

Questo è code-golf, quindi la risposta valida più breve - misurata in byte - vince.

code-golf  number 
— Christiaan Westerbeek
fonte
Suppongo che zero non sia positivo?
— TheLethalCoder
— Christiaan Westerbeek,
1
@aras Non sono un matematico, ma da quello che ho letto di solito dipende dal contesto. Alcuni dicono che è senza segno, alcuni sia positivi che negativi, altri positivi ecc.
— TheLethalCoder
1
@TheLethalCoder nel frattempo, in java (e in virgola mobile in generale), float a = -0f, b = 0f; System.out.println(a == b); System.out.println(a + "," + b);... produce truee -0.0,0.0. Vedi, 0 positivo e 0 negativo sono chiaramente due numeri distinti ... l'implementazione lo dice!
— Socratic Phoenix,
1
— jpmc26

Risposte:

2

Gaia , 4 byte

…÷l¦

C'è quasi solo un built-in per questo ...

Spiegazione

…     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.
— Gatto di affari
fonte
Pensavo che ci fosse anche una soluzione a 4 byte con 05AB1E. Ora che non c'è più, mi rende più facile decidere. Complimenti e grazie!
— Christiaan Westerbeek,
5

Mathematica, 33 byte

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

ingresso

[63, 11]

produzione

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

genera False quando non è risolvibile

— J42161217
fonte
5

MATL , 7 byte

:gie!Xs

Quando non c'è soluzione l'output è un array contenente almeno uno zero, che è errato in MATL.

Provalo online!

Spiegazione

Considerare input 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]
— Luis Mendo
fonte
4

Carbone , 15 byte dopo l'applicazione di NDD 1

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

Provalo online!

Non genera nulla se non c'è soluzione. Link alla versione dettagliata .

1 NDD = Sviluppo guidato da Neil.

La mia risposta precedente:

Carbone , 32 27 24 20 byte

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

Provalo online!

Non genera nulla se non c'è soluzione. Link alla versione dettagliata .

Certo, non avrei potuto giocare a golf senza l'aiuto di Neil.

— Charlie
fonte
La rimozione Castdell'operatore funziona per qualche motivo, ma questo non è un algoritmo ideale ... Ho una soluzione a 16 byte.
— Neil,
@Neil Challenge accettata!
— Charlie,
Mi piace la variabile predefinita, ma ora sapendo che Castfunziona sugli elenchi sono giù a 11 byte ...
— Neil
@Neil E ancora non riesco a usare Map, come mai funziona ??
— Charlie,
Mapè come la versione dell'espressione di for, fino all'utilizzo della stessa variabile di ciclo. Quindi, nel tuo esempio, anziché spingere ogni volta un'espressione in un elenco, Mapli raccoglie automaticamente e li valuta nell'elenco dei risultati.
— Neil,
3

R , 33 byte

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

Un porto della risposta Octave di Luis Mendo . Abbastanza triste che questo sia quasi il 50% più breve della mia risposta precedente.

Provalo online!

risposta precedente, 63 byte:

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

Una funzione anonima che prende due argomenti (obbligatorio) me n, e due opzionali che sono per scopi golf. Restituisce un vettore in ordine crescente. Per errore, sarà il primo valore 0, che è falso in R, poiché ifutilizza solo il primo valore del vettore (con un avviso).

È sostanzialmente equivalente alla seguente funzione:

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

Provalo online!

— Giuseppe
fonte
pryr::f(diff(trunc(0:n*m/n)))funziona ed è più corto!
— JAD,
2

Gelatina , 7 6 byte

:ȧœsL€

Provalo online! Non genera nulla per falsità.

Come funziona

:ȧœ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].
— ETHproductions
fonte
2

TI-Basic, 23 byte

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

Restituisce ERR: DIVIDE BY 0 in caso di errore

— Oki
fonte
2

Ottava , 24 byte

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

Il codice definisce una funzione anonima. L'output è un array numerico (vettore riga). Quando non è presente, questo array contiene almeno uno zero, che è errato in Octave.

Provalo online!

Spiegazione

0:m/n:mproduce una matrice di n+1valori da 0a mcon step m/n. fixarrotonda ogni voce verso 0e diffcalcola le differenze consecutive.

Come esempio, qui sono tutti i risultati intermedi per 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
— Luis Mendo
fonte
Un array che contiene uno zero è errato. Sembra un tratto, ma non conosco nemmeno Octave. Provenendo da Javascript con le sue coercizioni, direi perché diavolo no. +1 da me.
— Christiaan Westerbeek,
@ChristiaanWesterbeek Grazie! Sembra strano se vieni da altre lingue, ma è così in MATLAB / Octave
— Luis Mendo,
2

Haskell , 93 89 88 87 86 71 byte

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

Provalo online!

Spiegazione

La funzione principale qui è e. eprenderà un elenco ed eseguirà essenzialmente un mattarello da sinistra a destra. Mentre c'è un elemento nell'elenco che è più grande del suo vicino a destra, ne sposteremo uno da esso a destra.

Ora tutto ciò che dobbiamo fare è alimentare questa funzione con un elenco sufficientemente sbilenco e consentirgli di fare la magia. L'elenco che sceglieremo è mseguito da n-1zero. Dal momento che è facile da fare.

L'ultima cosa che dobbiamo fare è assicurarsi che il caso di errore sia gestito. Per questo abbiamo appena lanciato un Non-exhaustive patterns in functionerrore m>n.

— Post Rock Garf Hunter
fonte
Penso che si può sbarazzarsi di error[]non avendo con un modello non esaustivo, invece: m!n|m>n=e$m:replicate(n-1)0.
— Laikoni,
Inoltre (0<$[1..n-1])è più breve di replicate(n-1)0.
— Laikoni,
2

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

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

genera un errore per input non validi.

Provalo online!

-4 byte grazie a TheLethalCoder

-11 byte grazie a OlivierGrégoire

— LiefdeWen
fonte
1
Questo è solo uno snippet di codice al momento; devi solo avvolgerlo in una funzione anonima o a=>b=>all'inizio.
— TheLethalCoder
@TheLethalCoder Hmm sei sicuro? Non devo aggiungere il using System.Collections.Genericse restituisco un IEnumerable<int>?
— LiefdeWen
Ho sbagliato comunque perché stai restituendo un array (ho letto male la prima parte del ternario). Ma solo se questo viene visualizzato nel tuo codice e visto che IEnumerable<int>sarebbe nella definizione della funzione non dovrai includere il using.
— TheLethalCoder
No, il tuo suggerimento è ancora valido poiché il codice senza .ToArray () viene ancora compilato.
— LiefdeWen
1
@ OlivierGrégoire Hai ragione, scusa e grazie.
— Liefde:
2

Haskell, 48 byte

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

Inizia con un elenco di nzeri. Ripeti i mtempi: prendi il primo elemento, aggiungine uno e mettilo alla fine dell'elenco.

Errore con un errore di corrispondenza del modello se n < m.

Provalo online!

— Nome del modello
fonte
1

Braingolf , 30 byte

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

Provalo online!

Accetta gli input in ordine inverso ( nè il primo input, mè il secondo)

Divide mper n, duplica i ntempi del risultato , quindi scorre e accelera uno alla m % nvolta

— Skidsdev
fonte
1

Lotto, 71 byte

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

cmd/cset/anon genera alcun separatore, quindi devo usare echo(( (evita la stampa ECHO is on.).

— Neil
fonte
1

PHP> = 7.1, 62 byte

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

PHP Sandbox online

— Jörg Hülsermann
fonte
Fare clic sul collegamento alla Sandbox, fare clic su Esegui codice e ho visualizzato un errore di analisi.
— Christiaan Westerbeek,
@ChristiaanWesterbeek Per impostazione predefinita, il sandbox è PHP 7.0.3.
— Neil,
1
Con altri linguaggi come Octave e MATL uno zero in un array è considerato falso, ma non credo che questo sia il caso di php. Suppongo che l'output debba essere falso all'interno delle regole della lingua in cui è scritto il programma.
— Christiaan Westerbeek,
1
@ChristiaanWesterbeek risolto
— Jörg Hülsermann
1

Javascript (ES6), 57 56 53 41 byte

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

La risposta ora include un modo più intelligente di creare i valori. Grazie @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]

Storia

Prima la mia

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

Quindi ha aggiunto l'operatore di diffusione e la sintassi di curry fornita da @Arnauld

m=>n=>m>=n&&[...Array(n)].map((v,i)=>~~(m/n)+(i<m%n))
— Christiaan Westerbeek
fonte
1
_=>m++/n|0salva un sacco di byte.
— Neil,
0

Pyth , 13 byte

KE?>KQ0lMcK*d

Provalo online! Uscita 0in caso di errore.

Barare, 6 byte

lMcE*d

Provalo online! L'array contiene un 0errore di accensione. Purtroppo questo non è falsy in Pyth .

Spiegazione

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
— Jim
fonte
0

CJam , 13 12 byte

{_2$>/,/z:,}

Provalo online!

Questo è un blocco anonimo che accetta l'input come n m nello stack. Sarebbe stata una buona risposta, ma il requisito di gestione degli errori l'ha completamente eliminata.

Errori con una divisione per zero quando non è possibile risolvere.

Spiegazione

{   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 il requisito di gestione degli errori viene aumentato, questo può essere ridotto a 7 byte, con una riduzione di oltre il 40%:

{,/z:,}
— Esolanging Fruit
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.