sequência legal sem título

19

Vamos definir f n (k) como a soma dos primeiros k termos dos números naturais [1, ∞) onde cada número é repetido n vezes.

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

As anti-diagonais disso, como uma matriz quadrada, são semelhantes à sequência A134546 da OEIS .

Desafio

Escreva um programa / função que utilize dois números inteiros não negativos nek e produza f n (k) .

Especificações

  • Aplicam- se as regras de E / S padrão .
  • As brechas padrão são proibidas .
  • Sua solução pode ser indexada em 0 ou 1 em n e / ou k, mas especifique qual.
  • Esse desafio não é encontrar a abordagem mais curta em todos os idiomas, mas sim encontrar a abordagem mais curta em cada idioma .
  • Seu código será pontuado em bytes , geralmente na codificação UTF-8, a menos que especificado de outra forma.
  • Funções internas que computam essa sequência são permitidas, mas é recomendável incluir uma solução que não dependa de uma interna.
  • Explicações, mesmo para idiomas "práticos", são incentivadas .

Casos de teste

Nesses casos de teste, n é indexado em 1 e k é indexado em 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

Em alguns formatos melhores:

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

Implementação de referência

Isso está escrito em Haskell .

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

Experimente online!

Esse desafio foi marcado na caixa de areia.

code-golf  math  number  sequence 
— totalmente humano
fonte
Você acha que minha edição melhora a formatação ou é apenas no meu navegador?
— user202729
@ user202729 Heh ... parece que está no meu navegador, mas duvido que minha formatação tenha ficado bem na maioria dos navegadores ... vou continuar assim, não perde nenhum significado. Apenas parece estranho. : P
— totallyhuman 28/11
Será que precisamos de lidar com o caso f_n(0) = 0para k0-indexados?
— Cinaski # 28/17
9
" Arrefecer seqüência untitled coisinha " Lol, eu não sou o único a ter um tempo difícil chegar com nomes para as sequências que fiz até eu ver ..;)
— Kevin Cruijssen
3
@ Fabian Não, você apenas soma os primeiros ktermos da lista de números naturais repetidos, não os primeiros n*k.
— Martin Ender

Respostas:

12

Ruby , 32 28 23 bytes

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

Experimente online!

Explicação

Vamos visualizar a soma como a área de um triângulo, por exemplo, com n = 3 e k = 10:

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

Em seguida, somamos por coluna em vez de linha: a primeira coluna é k, então k-n, k-2ne assim por diante.

— GB
fonte
8

Casca , 4 bytes

Σ↑ṘN

Experimente online!

Explicação

Isso acaba sendo uma tradução direta da implementação de referência no desafio:

   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

Gelatina , 5 bytes

Rxḣ³S

Mais um byte do que a solução Jelly do @ Mr.Xcoder, mas esta é a minha primeira submissão em Jelly e ainda estou confuso sobre como a testemunha de Jelly escolhe operandos, por isso ainda estou satisfeito. Observe que a ordem das entradas é kentão n.

Explicação

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

Experimente online!

— dylnan
fonte
4

JavaScript (ES6),  24  21 bytes

Recebe entrada na sintaxe de currying (n)(k). Retorna em falsevez de0 .

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

Casos de teste

Mostrar snippet de código

Quão?

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

Isso é semelhante a resposta Ruby do @ GB .

O desafio descreve como construir a 'escada' da esquerda para a direita, enquanto essa função recursiva a constrói de baixo para cima. Com n = 2 e k = 11 :

staircase

— Arnauld
fonte
3

Lote, 34 bytes

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

Uma fórmula de formulário fechado que eu encontrei. O primeiro argumento né indexado em 1, o segundo argumento ké indexado em 0.

— Neil
fonte
3

Haskell , 28 bytes

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

Experimente online!

Uma abordagem que encontrei apenas mexendo com alguns parâmetros de faixa. Definitivamente, não é o mais curto, mas é muito legal como existem tantas abordagens diferentes.

— totalmente humano
fonte
3

R , 37 33 31 bytes

-6 bytes graças a Giuseppe

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

Experimente online!

Nada chique. Ele [0:k]lida com o caso quando k = 0.

— NofP
fonte
1
Você pode se livrar do aparelho aqui. Se você usar os argumentos em ordem para rep.default, poderá se livrar [0:k]usando, rep(1:k,,k,n)mas sua resposta será basicamente do rturnbull, mas com base R, e nãoR + pryr
— Giuseppe
1
Você ainda pode se livrar do aparelho! {}
— Giuseppe
a substituição [0: k] me pegou e eu esqueci o aparelho :) #
— NofP
2

C ++, 53 bytes

Basta usar a fórmula. né indexado em 1 e ké indexado em 0.

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

Experimente online!

— Colera Su
fonte
Salve alguns bytes abusando do ~operador. [](int n,int k){return-k/n*~(k/n)/2*n-k%n*~(k/n);};
— ceilingcat
2

J , 13 bytes

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

Como funciona:

O argumento da esquerda é n, o da direita é k.

i. gera uma lista 0..k-1

1+ adiciona um a cada número da lista, resultando em 1,2, ..., k

# forma um gancho com o acima, portanto, n cópias de cada elemento da lista são copiadas.

]{. pegue o primeiro n deles

1#. encontre a soma por conversão base.

Experimente online!

— Galen Ivanov
fonte
Eu gosto do gancho.
— cole
2

Retina , 29 26 bytes

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

Experimente online! O link inclui casos de teste e cabeçalho para reformatá-los para sua entrada preferida ( kprimeiro indexado 0 , nsegundo indexado 1 ). Fui inspirado pela resposta Ruby do @ GB. Explicação:

\d+
$*

Converta para unário.

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

Combine cada sequência de ndentro ke substitua a partida por tudo após a partida. Isto é k-n, k-2n, k-3n, mas né também após o jogo, de modo a obter k, k-n, k-2netc. Isso também corresponde n, que é simplesmente eliminado (ele não é mais necessário).

1

Soma os resultados e converta novamente em decimal.

— Neil
fonte
2

Perl 6 , 39 bytes

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

Teste-o

n e k são ambos um baseado

Expandido:

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

05AB1E , 9 bytes

FL`}){I£O

Experimente online!

Explicação

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

Clojure, 54 bytes

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

O segundo argumento ké indexado em 0, assim (f 14 20)como 28.

— NikoNyrh
fonte
1

APL + WIN, 13 bytes

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

Solicita a entrada na tela para ne depois para k. Origem do índice = 1.

— Graham
fonte
1

Japonês , 7 6 bytes

Originalmente inspirado na solução da GB e evoluído para uma porta!

Toma kcomo a primeira entrada e ncomo a segunda.

õ1Vn)x

Tente

Explicação

Entrada implícita de números inteiros U=k& V=n. Gere uma matriz de números inteiros ( õ) de 1para Ucom uma etapa Vnegada ( n) e reduza-a por adição ( x).

— Shaggy
fonte
1

R , 27 bytes

Função anônima que leva ke nnessa ordem. Cria uma lista de comprimento k(terceiro argumento para rep) que é composto 1por k(primeiro argumento para rep), repetindo cada elemento nvezes (quarto argumento para rep). Depois pega a soma dessa lista.

né indexado em 1 e ké indexado em 0. Retorna um erro para n<1. 

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

Experimente online!

— rturnbull
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.