truc cool séquence sans titre

19

Définissons f n (k) comme la somme des k premiers termes des nombres naturels [1, ∞) où chaque nombre est répété n fois.

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

Les anti-diagonales de cette forme de réseau carré sont similaires à la séquence OEIS A134546 .

Défi

Écrivez un programme / une fonction qui prend deux entiers non négatifs n et k et produit f n (k) .

Caractéristiques

  • Les règles d'E / S standard s'appliquent .
  • Les failles standard sont interdites .
  • Votre solution peut être indexée 0 ou indexée 1 pour n et / ou k, mais veuillez préciser laquelle.
  • Ce défi ne consiste pas à trouver l'approche la plus courte dans toutes les langues, mais plutôt à trouver l' approche la plus courte dans chaque langue .
  • Votre code sera noté en octets , généralement dans le codage UTF-8, sauf indication contraire.
  • Les fonctions intégrées qui calculent cette séquence sont autorisées, mais l'inclusion d'une solution qui ne repose pas sur une séquence intégrée est encouragée.
  • Des explications, même pour les langues "pratiques", sont encouragées .

Cas de test

Dans ces cas de test, n est indexé 1 et k est indexé 0.

n   k      fn(k)

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

Dans quelques meilleurs formats:

1 2
2 11
11 14
14 21
21 24
24 31
31 0

1, 2
2, 11
11, 14
14, 21
21, 24
24, 31
31, 0

Implémentation de référence

Ceci est écrit en Haskell .

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

Essayez-le en ligne!

Ce défi a été mis en bac à sable.

code-golf  math  number  sequence 
— totalement humain
source
Pensez-vous que ma modification améliore la mise en forme, ou est-ce uniquement sur mon navigateur?
— user202729
@ user202729 Hé ... ça a l'air sur mon navigateur mais je doute que mon formatage soit bon sur la plupart des navigateurs ... Je vais juste le garder comme ça, il ne perd aucun sens. C'est juste bizarre. : P
— totalement humain
Avons-nous besoin de gérer le cas f_n(0) = 0de l' kindex 0?
— Cinaski
9
" truc cool séquence sans titre " Lol, je ne suis pas le seul à avoir du mal à trouver des noms pour les séquences que j'ai
— inventées
3
@Fabian Non, vous additionnez uniquement les premiers ktermes de la liste des nombres naturels répétés, pas les premiers n*ktermes.
— Martin Ender

Réponses:

12

Rubis , 32 28 23 octets

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

Essayez-le en ligne!

Explication

Visualisons la somme comme l'aire d'un triangle, par exemple avec n = 3 et k = 10:

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

Ensuite, nous additionnons par colonne au lieu de ligne: la première colonne est k, puis k-n, k-2net ainsi de suite.

— GB
source
8

Python 2 , 34 28 octets

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

Essayez-le en ligne!

Merci à Martin Ender, Neil et M. Xcoder pour leur aide.

— GB
source
1
De toute façon, vous n'en avez pas besoin k/n- k-(k/n)*nc'est juste k%n. Voir ma réponse Lot.
— Neil
— M. Xcoder
Merci. Je ne pensais pas que cela pourrait devenir aussi simple.
— GB
8

Husk , 4 octets

Σ↑ṘN

Essayez-le en ligne!

Explication

Cela finit par être une traduction directe de l'implémentation de référence dans le défi:

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

Gelée , 5 octets

Rxḣ³S

Un octet de plus que la solution @ Mr.Xcoder Jelly mais c'est ma toute première soumission dans Jelly et je suis toujours confus quant à la façon dont le tacitness de Jelly choisit les opérandes, donc je suis toujours satisfait. Notez que l'ordre des entrées est kalors n.

Explication

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

Essayez-le en ligne!

— dylnan
source
4

JavaScript (ES6),  24  21 octets

Prend une entrée dans la syntaxe de curry (n)(k). Renvoie falseau lieu de0 .

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

Cas de test

Afficher l'extrait de code

Comment?

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

Ceci est similaire à la réponse Ruby de @ GB .

Le défi décrit comment construire «l'escalier» de gauche à droite, alors que cette fonction récursive le construit de bas en haut. Avec n = 2 et k = 11 :

staircase

— Arnauld
source
3

Lot, 34 octets

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

Une formule sous forme fermée que j'ai trouvée. Le premier argument nest indexé 1, le deuxième argument kest indexé 0.

— Neil
source
3

Haskell , 28 octets

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

Essayez-le en ligne!

Une approche que j'ai trouvée juste en vissant avec quelques paramètres de plage. Ce n'est certainement pas le plus court, mais c'est assez cool de voir à quel point il existe de nombreuses approches différentes.

— totalement humain
source
3

R , 37 33 31 octets

-6 octets grâce à Giuseppe

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

Essayez-le en ligne!

Rien d'extraordinaire. Le [0:k]gère le cas lorsque k = 0.

— NofP
source
1
Vous pouvez vous débarrasser des accolades ici. Si vous utilisez les arguments dans l'ordre pour rep.default, vous pouvez vous en débarrasser [0:k]en utilisant rep(1:k,,k,n)mais votre réponse est essentiellement celle de rturnbull mais avec la base R plutôt queR + pryr
— Giuseppe
1
Vous pouvez toujours vous débarrasser des accolades! {}
— Giuseppe
la substitution [0: k] m'a eu et j'ai oublié les accolades :)
— NofP
2

C ++, 53 octets

Utilisez simplement la formule. nest indexé 1 et indexé k0.

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

Essayez-le en ligne!

— Colera Su
source
Économisez quelques octets en abusant de l' ~opérateur. [](int n,int k){return-k/n*~(k/n)/2*n-k%n*~(k/n);};
— Plafond du
2

J , 13 octets

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

Comment ça fonctionne:

L'argument de gauche est n, celui de droite est k.

i. génère une liste 0..k-1

1+ ajoute un à chaque numéro de la liste, yealding 1,2, ..., k

# forme un crochet avec ce qui précède, donc n copies de chaque élément de la liste sont copiées.

]{. prendre les n premiers

1#. trouver leur somme par conversion de base.

Essayez-le en ligne!

— Galen Ivanov
source
J'aime le crochet.
— cole
2

Rétine , 29 26 octets

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

Essayez-le en ligne! Link inclut des cas de test et un en-tête pour les reformater en son entrée préférée (0 indexé en kpremier, 1 indexé en nsecond). J'ai été inspiré par la réponse Ruby de @ GB. Explication:

\d+
$*

Convertissez en unaire.

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

Faites correspondre chaque chaîne de l' nintérieur ket remplacez la correspondance par tout ce qui suit la correspondance. Ceci est k-n, k-2n, k-3nmais nest également après le match, de sorte que vous obtenez k, k-n,k-2n etc. Cela correspond aussi n, ce qui est tout simplement supprimé (il est plus nécessaire).

1

Additionnez les résultats et reconvertissez en décimal.

— Neil
source
2

Perl 6 , 39 octets

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

Essaye-le

n et k sont tous deux basés sur 1

Étendu:

-> \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
source
1

05AB1E , 9 octets

FL`}){I£O

Essayez-le en ligne!

Explication

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
source
1

Clojure, 54 octets

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

Le deuxième argument kest indexé sur 0, tout (f 14 20)comme 28.

— NikoNyrh
source
1

APL + WIN, 13 octets

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

Invite à saisir l'écran pour n, puis pour k. Origine de l'indice = 1.

— Graham
source
1

Japt , 7 6 octets

Inspiré à l'origine par la solution de GB et évolué vers un port!

Prend kcomme première entrée et ncomme seconde.

õ1Vn)x

Essayez-le

Explication

Saisie implicite d'entiers U=k& V=n. Générez un tableau d'entiers ( õ) de 1à Uavec une étape de Vnegated ( n) et réduisez-le par addition ( x).

— Hirsute
source
1

R , 27 octets

Fonction anonyme qui prend ketn dans cet ordre. Crée une liste de longueur k(troisième argument rep) qui est composée de 1travers k(premier argument rep), en répétant chaque élément de nfois (quatrième argument rep). Prend ensuite la somme de cette liste.

nest indexé 1 et indexé k0. Renvoie une erreur pour n<1. 

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

Essayez-le en ligne!

— rturnbull
source
1

Befunge, 27 octets

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

Essayez-le en ligne

Prend k puis n comme entrée. Utilise la réponse de GB comme base mathématique.

— Jo King
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.