Definiamo f _n (k) come la somma dei primi k termini dei numeri naturali [1, ∞) dove ogni numero viene ripetuto n volte.

k       | 0    1    2    3    4    5    6    7    8    9
--------+-------------------------------------------------
f_1(k)  | 0    1    3    6    10   15   21   28   36   45
deltas  |   +1   +2   +3   +4   +5   +6   +7   +8   +9
--------+-------------------------------------------------
f_2(k)  | 0    1    2    4    6    9    12   16   20   25
deltas  |   +1   +1   +2   +2   +3   +3   +4   +4   +5
--------+-------------------------------------------------
f_3(k)  | 0    1    2    3    5    7    9    12   15   18
deltas  |   +1   +1   +1   +2   +2   +2   +3   +3   +3

Le anti-diagonali di questo come una matrice quadrata sono simili a sequenza OEIS A134546 .

Sfida

Scrivi un programma / funzione che accetta due numeri interi non negativi n e k e genera f _n (k) .

specificazioni

Si applicano le regole I / O standard .
Sono vietate le scappatoie standard .
La soluzione può essere indicizzata 0 o 1 per n e / o k, ma specificare quale.
Questa sfida non riguarda la ricerca dell'approccio più breve in tutte le lingue, ma piuttosto la ricerca dell'approccio più breve in ciascuna lingua .
Il tuo codice sarà assegnato punteggio in byte , di solito nella codifica UTF-8, se non diversamente specificato.
Sono consentite funzioni integrate che calcolano questa sequenza ma è incoraggiata l'inclusione di una soluzione che non si basa su un built-in.
Le spiegazioni, anche per le lingue "pratiche", sono incoraggiate .

Casi test

In questi casi di test, n è 1 indicizzato e k è 0 indicizzato.

n   k      f_n(k)

1   2      3
2   11     36
11  14     17
14  21     28
21  24     27
24  31     38
31  0      0

In alcuni formati migliori:

Implementazione di riferimento

Questo è scritto in Haskell .

f n k = sum $ take k $ replicate n =<< [1..]

Provalo online!

Questa sfida è stata sandbox.

— totallyhuman
fonte

Pensi che la mia modifica migliori la formattazione o è solo sul mio browser?

— user202729

@ user202729 Heh ... sembra fuori dal mio browser ma dubito che la mia formattazione sia andata bene sulla maggior parte dei browser ... La terrò così, non perderà alcun significato. Sembra strano. : P

— totalmente umano il

Dobbiamo gestire il caso f_n(0) = 0per k0-indicizzato?

— Cinaski,

9

" fighissima sequenza senza titolo " Lol, non sono l'unico che fa fatica a trovare i nomi delle sequenze che ho

— inventato,

3

@Fabian No, sommi solo i primi ktermini dall'elenco di numeri naturali ripetuti, non i primi n*ktermini.

— Martin Ender,

12

Rubino , 32 28 23 byte

->n,k{k.step(0,-n).sum}

Provalo online!

Spiegazione

Visualizziamo la somma come l'area di un triangolo, ad esempio con n = 3 e k = 10:

*
*
*
**
**
**
***
***
***
****

Quindi sommiamo per colonna anziché per riga: la prima colonna è k, quindi k-n, k-2ne così via.

— GB
fonte

8

Python 2 , 34 28 byte

lambda n,k:(k+k%n)*(k/n+1)/2

Provalo online!

Grazie Martin Ender, Neil e Mr Xcoder per l'aiuto.

— GB
fonte

1

In realtà non ti serve k/ncomunque - k-(k/n)*nè giusto k%n. Vedi la mia risposta in batch.

— Neil,

28 byte

— Mr. Xcoder,

Grazie. Non pensavo che potesse essere così semplice.

— GB,

8

Buccia , 4 byte

Σ↑ṘN

Provalo online!

Spiegazione

Questo finisce per essere una traduzione diretta dell'implementazione di riferimento nella sfida:

   N  Start from the infinite sequence of all natural numbers.
  Ṙ   Replicate each element n times.
 ↑    Take the first k values.
Σ     Sum them.

— Martin Ender
fonte

5

APL (Dyalog) , 12 10 8 byte

+/∘⌈÷⍨∘⍳

Provalo online!

na sinistra, k(0 indicizzato) a destra.

— Uriel
fonte

5

Mathematica, 40 byte

Tr@Sort[Join@@Range@#2~Table~#][[;;#2]]&

Provalo online!

Tr[Range@(s=⌊#2/#⌋)]#+#2~Mod~#(s+1)&

Provalo online!

Mathematica, 18 byte

di Martin Ender

Tr@Range[#2,0,-#]&

Provalo online!

n~Sum~{n,#2,0,-#}&

Provalo online!

— J42161217
fonte

2

Tr@Range[#2,0,-#]&o n~Sum~{n,#2,0,-#}&usando il trucco della risposta Ruby di GB.

— Martin Ender,

5

MATL , 12 11 byte

:iY"Ys0h1G)

Provalo online!

kè indicizzato 0. Accetta l'input in ordine inverso.

Salvato 1 byte grazie a @Giuseppe

— Cinaski
fonte

5

Gelatina , 5 byte

Rxḣ³S

Un byte in più rispetto alla soluzione Jelly di @ Mr.Xcoder, ma questa è la mia prima presentazione in assoluto su Jelly e sono ancora confuso su come il tacitness di Jelly scelga gli operandi, quindi sono ancora soddisfatto. Nota l'ordine degli ingressi sono kpoi n.

Spiegazione

Rxḣ³S
R           Range: [1,2,...,k]
 x          Times: repeat each element n times: [1,1,1,2,2,2,...,n,n,n]
  ḣ³        Head: take the first k elements. ³ returns the first argument.
    S       Sum

Provalo online!

— dylnan
fonte

4

Gelatina , 4 byte

1-indicizzato

Ḷ:‘S

Provalo online! o vedere una suite di test .

— Mr. Xcoder
fonte

Puoi fare 0 indicizzazione quindi penso che Ḷ:S

— funzioni

@dylnan In realtà non penso che questo significhi 0 indicizzato qui. Sono tornato indietro e vedremo

— Mr. Xcoder il

La divisione @dylnan per zero è un errore.

— Erik the Outgolfer,

4

JavaScript (ES6), 24 21 byte

Accetta input nella sintassi del curry (n)(k). Restituisce falseinvece di0 .

n=>g=k=>k>0&&k+g(k-n)

Casi test

Mostra snippet di codice

let f =

n=>g=k=>k>0&&k+g(k-n)

console.log(f(1 )(2 )) // 3
console.log(f(2 )(11)) // 36
console.log(f(11)(14)) // 17
console.log(f(14)(21)) // 28
console.log(f(21)(24)) // 27
console.log(f(24)(31)) // 38

Expand snippet

Come?

n =>             // main unamed function taking n
  g = k =>       // g = recursive function taking k
    k > 0 &&     // if k is strictly positive:
      k +        //   add k to the final result
      g(k - n)   //   subtract n from k and do a recursive call

Questo è simile alla risposta di Ruby di @ GB .

La sfida descrive come costruire la 'scala' da sinistra a destra, mentre questa funzione ricorsiva la costruisce dal basso verso l'alto. Con n = 2 e k = 11 :

— Arnauld
fonte

3

Lotto, 34 byte

@cmd/cset/a(%2+%2%%%1)*(%2/%1+1)/2

Una formula in forma chiusa che ho trovato. Il primo argomento nè 1 indicizzato, il secondo argomento kè 0 indicizzato.

— Neil
fonte

3

Python 2 , 29 byte

lambda n,k:sum(range(k,0,-n))

Provalo online!

Grazie a totalmente umano per -3 byte!

Python 2 , 30 byte

f=lambda n,k:k>0and k+f(n,k-n)

Provalo online!

— Mr. Xcoder
fonte

3

Haskell , 28 byte

n#k|m<-k`mod`n=sum[m,m+n..k]

Provalo online!

Un approccio che ho trovato semplicemente girovagando con alcuni parametri di portata. Sicuramente non il più breve, ma è piuttosto bello come ci siano così tanti approcci diversi.

— totallyhuman
fonte

3

C, 38 34 byte

Definizione ricorsiva.

-4 byte grazie a Steadybox .

f(n,k){return k--?1+f(n,k)+k/n:0;}

Provalo online!

32 byte di Mr. Xcoder , GB

f(n,k){return(k+k%n)*(k/n+1)/2;}

Provalo online!

— Colera Su
fonte

34 byte in Python , 36 byte in C

— Mr. Xcoder,

1

Utilizzando l'approccio di GB, 32 byte

— Mr. Xcoder,

tio.run/… -> 28 byte

— GB

1

34 byte (la versione ricorsiva): f(n,k){return k--?1+f(n,k)+k/n:0;} provalo online!

— Steadybox

3

R , 37 33 31 byte

-6 byte grazie a Giuseppe

function(n,k)sum(rep(1:k,,k,n))

Provalo online!

Nulla di bello. ~~Le [0:k]maniglie il caso in cui k = 0.~~

— NOFP
fonte

1

Puoi sbarazzarti delle parentesi graffe qui. Se usi gli argomenti in-order per rep.default, puoi sbarazzartene [0:k]usando rep(1:k,,k,n)ma poi la tua risposta è sostanzialmente di rturnbull ma con la base R piuttosto cheR + pryr

— Giuseppe

1

Puoi ancora sbarazzarti delle parentesi graffe! {}

— Giuseppe,

la sostituzione [0: k] mi ha fatto e mi sono dimenticato delle parentesi graffe :)

— NofP

2

C ++, 53 byte

Usa la formula. nè 1-indicizzato ek 0 indicizzato.

[](int n,int k){return k/n*(k/n+1)/2*n+k%n*(k/n+1);};

Provalo online!

— Colera Su
fonte

Salva un paio di byte abusando ~dell'operatore. [](int n,int k){return-k/n*~(k/n)/2*n-k%n*~(k/n);};

— plafoniera

2

J , 13 byte

1#.]{.(#1+i.)

Come funziona:

L'argomento sinistro è n, il diritto è k.

i. genera un elenco 0..k-1

1+ aggiunge uno a ciascun numero dell'elenco, yealding 1,2, ..., k

# costituisce un hook con quanto sopra, quindi vengono copiate n copie di ciascun elemento dell'elenco.

]{. prendine la prima n

1#. trova la somma tramite la conversione di base.

Provalo online!

— Galen Ivanov
fonte

Mi piace il gancio.

— Cole

2

Retina , 29 26 byte

\d+
$*
(?=.*?(1+)$)\1
$'
1

Provalo online! Il collegamento include casi di test e intestazione per riformattarli al loro input preferito ( kprimo indicizzato 0 , nsecondo indicizzato 1 ). Sono stato ispirato dalla risposta di Ruby di @ GB. Spiegazione:

\d+
$*

Converti in unario.

(?=.*?(1+)$)\1
$'

Abbina ogni stringa di ndentro ke sostituisci la partita con tutto dopo la partita. Questo è k-n, k-2n, k-3n, ma nè anche dopo la partita, in modo da ottenere k, k-n, k-2necc Questo anche le partiten , che è semplicemente cancellato (non è più necessario).

Somma i risultati e converti nuovamente in decimale.

— Neil
fonte

2

Pyth , 5 byte

s%_ES

Provalo qui!

Port of GB's Ruby answer. Una porta del mio Jelly sarebbe di 6 byte:+s/Rvz

— Mr. Xcoder
fonte

2

Perl 6 , 39 byte

->\n,\k{(0,{|($_+1 xx n)}...*)[^k].sum}

Provalo

n e k sono entrambi basati su 1

Allargato:

-> \n, \k { # pointy block lambda with two parameters ｢n｣ and ｢k｣

  ( # generate the sequence

    0,         # seed the sequence (this is why ｢k｣ is 1-based)

    {          # bare block lambda with implicit parameter ｢$_｣
      |(       # slip this into outer sequence
        $_ + 1 # the next number
        xx n   # repeated ｢n｣ times (this is why ｢n｣ is 1-based)
      )
    }

    ...        # keep doing that until

    *          # never stop

  )[ ^k ]      # get the first ｢k｣ values from the sequence
  .sum         # sum them
}

— Brad Gilbert b2gills
fonte

2

Kotlin , 40 byte

{n:Int,k:Int->Array(k,{i->i/n+1}).sum()}

Provalo online!

— alves
fonte

2

Java (OpenJDK 8) , 23 byte

n->k->(k+k%n)*(k/n+1)/2

Provalo online!

La risposta di Port of GB Python 2 .

— Olivier Grégoire
fonte

1

05AB1E , 9 byte

FL`}){I£O

Provalo online!

Spiegazione

F           # n times do
 L`         # pop top of stack (initially k), push 1 ... topOfStack
   }        # end loop
    )       # wrap stack in a list
     {      # sort the list
      I£    # take the first k elements
        O   # sum

— Emigna
fonte

1

Python 2 , 44 byte

f=lambda n,k:sum(sorted(range(1,k+1)*n)[:k])

Provalo online!

— TFeld
fonte

1

Python 2 , 38 byte

lambda n,k:sum(i/n+1for i in range(k))

Provalo online!

— asta
fonte

1

Clojure, 54 byte

#(nth(reductions +(for[i(rest(range))j(range %)]i))%2)

Il secondo argomento kè indicizzato 0, quindi (f 14 20)è 28.

— NikoNyrh
fonte

1

APL + WIN, 13 byte

+/⎕↑(⍳n)/⍳n←⎕

Richiede l'inserimento dello schermo per n e quindi per k. Origine indice = 1.

— Graham
fonte

1

Brain-Flak , 78 byte

(({}<>)<{<>(({})<>){({}[()]<(({}))>)}{}({}[()])}{}<>{}>)({<({}[()])><>{}<>}{})

Provalo online!

Sono certo che si possa fare di meglio, ma è un inizio.

— Mago del grano
fonte

1

Japt , 7 6 byte

Originariamente ispirato alla soluzione di GB e trasformato in una porta!

Prende kcome primo input e ncome secondo.

õ1Vn)x

Provalo

Spiegazione

Immissione implicita di numeri interi U=ke V=n. Generare un array di numeri interi ( õ) da 1a Ucon un passaggio di Vnegated ( n) e ridurlo di addition ( x).

— ispido
fonte

1

R , 27 byte

Funzione anonima che accetta ke nin quell'ordine. Crea un elenco di lunghezza k(terzo argomento a rep) composto da 1through k(primo argomento a rep), ripetendo ogni elementon volte (quarto argomento a rep). Quindi prende la somma di tale elenco.

nè 1 indicizzato e k0 indicizzato. Restituisce un errore per n<1.

pryr::f(sum(rep(1:k,,k,n)))

Provalo online!

— rturnbull
fonte

1

Befunge, 27 byte

&::00p&:10p%+00g10g/1+*2/.@

Provalo online

Prende k quindi n come input. Utilizza la risposta di GB come base matematica.

— Jo King
fonte

figa sequenza senza titolo

Sfida

specificazioni

Casi test

Implementazione di riferimento

Rubino , 32 28 23 byte

Spiegazione

Python 2 , 34 28 byte

Buccia , 4 byte

Spiegazione

APL (Dyalog) , 12 10 8 byte

Mathematica, 40 byte

Mathematica, 18 byte

MATL , 12 11 byte

Gelatina , 5 byte

Gelatina , 4 byte

JavaScript (ES6), 24 21 byte

Casi test

Come?

Lotto, 34 byte

Python 2 , 29 byte

Python 2 , 30 byte

Haskell , 28 byte

C, 38 34 byte

R , 37 33 31 byte

C ++, 53 byte

J , 13 byte

Retina , 29 26 byte

Pyth , 5 byte

Perl 6 , 39 byte

Allargato:

Kotlin , 40 byte

Java (OpenJDK 8) , 23 byte

05AB1E , 9 byte

Python 2 , 44 byte

Python 2 , 38 byte

Clojure, 54 byte

APL + WIN, 13 byte

Brain-Flak , 78 byte

Japt , 7 6 byte

Spiegazione

R , 27 byte

Befunge, 27 byte