Considere o seguinte triângulo.

1
23
456
7891
01112
131415
1617181
92021222
324252627
2829303132
33343536373
839404142434
4454647484950
51525354555657
585960616263646
5666768697071727
37475767778798081

Como você provavelmente notou, a primeira linha tem o comprimento 1, e cada linha a seguir é 1 dígito a mais que a anterior e contém os dígitos dos números inteiros positivos concatenados.

Vai ser dado um número inteiro N . Sua tarefa é encontrar a soma dos dígitos que se encontram em N ª linha do triângulo acima.

Regras

• Você pode escolher 0 ou 1 indexação. Especifique isso na sua resposta.

• Aplicam-se lacunas padrão .

• Você pode receber e fornecer saída por qualquer média padrão e em qualquer formato razoável.

• Este é o OEIS A066548 e essa sequência é o próprio triângulo (exceto que não removemos zeros à esquerda).

• Isso é código-golfe , então o código mais curto em bytes (em todos os idiomas) vence. Divirta-se jogando golfe!

Casos de teste

Input  |  Output

0  |  1
1  |  5
2  |  15
3  |  25
4  |  5
5  |  15
6  |  25
7  |  20
8  |  33
9  |  33
10 |  43
11 |  46
12 |  64

Observe que os itens acima são indexados em 0. Se você estiver procurando por casos de teste indexados em 1, aumente a entrada em 1.

_{Em uma nota não relacionada, mudei recentemente minha foto de perfil e isso me inspirou a escrever esse desafio.}

Casca , 7 bytes

Indexado 1

Σ!CNṁdN

Experimente online!

Explicação

    ṁ     Map then concatenate
     d    Integer digits
      N   Over the natural numbers
  CN      Cut into lists of lengths corresponding to the natural numbers
 !        Index it
Σ         Sum

Python 2 , 69 bytes

Provavelmente isso poderia ser um pouco mais curto.

Indexado 1

Edit: -7 bytes graças a @ Mr.Xcoder

lambda n:sum(map(int,"".join(map(str,range(1,n*n+1)))[~-n*n/2:][:n]))

Experimente online!

Haskell , 57 bytes

f n=sum[read[d]|d<-take n$drop(div(n*n-n)2)$show=<<[1..]]

Experimente online!

05AB1E , 8 bytes

nLS¹L£θO

Experimente online!

-1 graças a Emigna .

Indexação 1.

Perl 6 , 47 45 42 bytes

{[~](1..$_²).substr(:1[^$_],$_).comb.sum}

Experimente online!

Indexado 1

Mathematica, 96 bytes

(d=Flatten[IntegerDigits/@Range[#^2]];Last@Table[Tr@Take[d,{i(i+1)/2+1,(i+1)(i+2)/2}],{i,0,#}])&  

Experimente online! (para trabalhar em matemática, "Tr" deve ser substituído por "Total")

Gelatina , 11 bytes

²RDFṁRS$ṫCS

Experimente online!

Usa indexação baseada em 1.

Explicação

²RDFṁRS$ṫCS  Input: n
²            Square
 R           Range, [1, n^2]
  D          Decimal digits
   F         Flatten
    ṁ        Reshape to
       $     Monadic chain
     R         Range, [1, n]
      S        Sum
        ṫ    Tail
         C   Complement, 1-n
          S  Sum

Haskell, 69 64 bytes

n%x=sum[read[d]|d<-take n x]:(n+1)%drop n x
f=(1%(show=<<[1..])!!)

Experimente online.

Guardado 5 bytes graças a Laikoni !

Aqui está a versão menos golfe:

-- continuous stream of digits representing
-- the concatenation of positive integers in
-- order: 1234567891011...
digitstream = show=<<[1..]

-- sequence that yields the rows of the triangle
triangle n xs |(a,b)<-splitAt n xs=a:triangle(n+1)b

digitSum xs = sum[read[d]|d<-xs]

-- sequence that sums up the digits in each row
rowSumSequence = map digitSum (triangle 1 digitstream)

-- the final function that just shows the value 
-- at a given index
g=(rowSumSequence!!)

R, 119 109 108 93 88 bytes

começando a jogar golfe .... 1-indexado

function(n){for(i in 1:n+n*(n-1)/2){F=F+strtoi(substr(paste(1:n^2,collapse=""),i,i))};F}

obrigado @Zachary. sua presunção está correta :) raspou 1 byte tnx para @Andrius e 15 mais tnx para @ user2390246

@Giuseppe - tnx para o strtoi. novo para mim. 5 bytes abaixo :)

Emojicode , 182 bytes

🐖©a🚂➡🚂🍇🍦l➗✖a➕a 1 2🍮t🔤🔤🍮i 0🔁▶l🐔t🍇🍮➕i 1🍮t🍪t🔡i 10🍪🍉🍮s 0🔂g🔪t➖l a a🍇🍮➕s 🍺🚂🔡g 10🍉🍎s🍉

Define um método chamado © que leva a returns e retorna a 🚂. 1 indexado.

Experimente online!

Explicação:

Nota: muitas opções de emoji não fazem muito sentido no Emojicode 0.5. É 0.x, afinal. O 0.6 corrigirá isso. Portanto, se você quiser aprender isso (porque quem não gostaria), recomendo aguardar um momento.

O Emojicode é uma linguagem de programação orientada a objetos com genéricos, protocolos, opcionais e fechamentos, mas este programa não usa fechamentos, e todos os genéricos e protocolos podem ser considerados implícitos.

O programa opera em apenas alguns tipos: 🚂 é o tipo inteiro e 🔡 é o tipo de sequência. Além disso, appears aparecem em condições, que podem assumir um valor de 👍 (verdadeiro) ou 👎 (falso).

Atualmente, não há operadores no Emojicode, portanto, adição, comparsões e outras operações que normalmente são operadores são implementadas como funções, fazendo com que as expressões usem a notação de prefixo . Os operadores também estão planejados em 0,6.

🐖©a🚂➡🚂🍇

© pega um 🚂 chamado ae retorna um 🚂.

 🍦l➗✖a➕a 1 2

Declare um congelado ("constante") ligual ao a-ésimo número triangular (fórmula na notação de prefixo). Isso representa o comprimento da sequência de números que precisamos gerar.

 🍮t🔤🔤

Atribua uma sequência vazia à variável t .

 🍮i 0

Atribuir i = 0 .

 🔁▶l🐔t🍇

Enquanto o lfor maior que o comprimento det

  🍮➕i 1

i += 1

  🍮t🍪t🔡i 10🍪

Anexar a representação textual de i base 10 em t.

 🍉

Laço final

 🍮s 0

Atribuir s = 0

 🔂g🔪t➖l a a🍇

Pegue uma substring tcomeçando em l - a(a - 1 th número triangular) de comprimento a, itere sobre todos os caracteres

  🍮➕s 🍺🚂🔡g 10

Converta o caractere em sequência, analise o número inteiro na base 10, desembrulhe o opcional (nada será retornado se a sequência não for um número) e adicione à svariável.

 🍉

Laço final

 🍎s

Return s

🍉

Método final.

PHP, 66 + 1 bytes

for($p=($n=$argn)*-~$n/2;$n--;)$r+=join(range(1,$p))[--$p];echo$r;

Execute como pipe -nRou experimente on-line .

requer PHP 5.4 ou posterior para indexar a expressão.

Pitão, 24 bytes

u+GsH<>jkS+*QQ2/*QhQ2hQ0

Experimente aqui: http://pyth.herokuapp.com/

APL, 28 26 25 bytes

{+/⍎¨⍵↑⌽(+/⍳⍵)↑∊,/⍕¨⍳⍵×⍵}

Usa indexação baseada em 1

Experimente online!

Quão?

• ⍳⍵×⍵, 1 através da entrada ao quadrado
• ⍕¨, transforme cada elemento em uma sequência
• ∊,/, concatená-los juntos
• (+/⍳⍵)↑, pegue as linhas até a entrada
• ⍵↑⌽, pegue a linha desejada
• ⍎¨, transforme cada elemento em um número
• +/soma

Clojure v1.8, 154 bytes

Indexado 1

(fn[n](loop[i 1 s(clojure.string/join""(take(* n n)(iterate inc 1)))](if(= i n)(apply +(map #(Character/digit % 10)(take n s)))(recur(inc i)(subs s i)))))

Experimente online!

Explicação

(take(* n n)(iterate inc 1))  Take the first N*N numbers
(clojure.string/join""...)    Combine them into a string
(loop[i 1 ...](if(= i n)...)  Loop N times
(apply +(map #(Character/digit % 10)(take n s)))  Take N characters from the string, convert to integers and add them
(recur(inc i)(subs s i))      Increment iterator, remove i characters from string

Java 8, 116 98 bytes

n->{String t="";int r=0,i=0;for(;i++<n*n;t+=i);for(i=0;i<n;r+=t.charAt(i+++~-n*n/2)-48);return r;}

Indexado 1

-18 bytes graças a @Nevay

Explicação:

Experimente aqui.

n->{                             // Method with integer as both parameter and return-type
  String t="";                   //  Triangle-String
  int r=0,                       //  Result-integer
      i=0;                       //  Index-integer
  for(;i++<n*n;                  //  Loop (1) from 0 to `n^2` (exclusive)
    t+=i                         //   And append String `t` with all the numbers
  );                             //  End of loop (1)
  for(i=0;i<n;                   //  Loop (2) from 0 to `n` (exclusive)
    r+=t.charAt(i+++~-n*n/2)-48  //   And raise the sum `r` by the digits
  );                             //  End of loop (2)
  return r;                      //  Return the resulting sum of digits
}                                // End of method

R, 99 , 105 , 97 bytes

a=diag(N<-scan());a[upper.tri(a,T)]=strtoi(strsplit(paste(1:N^2,collapse=""),"")[[1]]);sum(a[,N])

Indexado 1

versão ungolfed

a <- diag(N<-scan())
a[upper.tri(a, diag=TRUE)] <- strtoi(strsplit(paste(1:N^2, 
                                                  collapse=""),
                                            "")[[1]])
sum(a[,N])

Experimente aqui!

graças a @ Giuseppe por salvar 8 bytes

Perl 6 , 44 bytes

{[+] (1..*).flatmap(*.comb).rotor(1..*)[$_]}

Teste-o

Expandido:

{
  [+]        # reduce the result of the following using &infix«+»

  ( 1 .. * ) # infinite range starting at 1

  .flatmap(  # map, then flatten
    *.comb   # split into digits (100 ⇒ 1,0,0)
  )

  .rotor(    # break the sequence into pieces
    1 .. *   # start with 1 value, then 2 values, then 3, etc.
  )\

  [$_]       # index into that infinite sequence
}

Gelatina , 16 bytes

Ṭ€Ẏ0;œṗ²D€Ẏ$$⁸ịS

Experimente online!

1 indexado.

SOGL V0.12 , 15 13 bytes

²Δr∑.δ∑⌡kmčr∑

Experimente aqui!
1 indexado.

Enquanto trabalhava nisso, corrigi um bug que ∑não funcionava em matrizes numéricas e que mincorretamente recebia entradas implícitas.

Explicação:

²              square the input
 Δ             get a range from 1 to that
  r∑           join as a string
    .δ         create a range 0 - input-1
      ∑        sum that
       ⌡       that many times do
        k        remove the 1st character of the joined string
         m     mold to the length of the input
          č    chop into characters
           r∑  convert to numbers and sum

C ++, 180 bytes

-17 bytes graças a Zacharý

Índice começa em 1

#include<string>
int s(int n){std::string t;int i=0,p=0;for(;i<=n;)p+=i++;for(i=0;t.size()<p;t+=std::to_string(++i));t=t.substr(0,p).substr(p-n);i=0;for(auto&a:t)i+=a-48;return i;}

Pitão ,  15 14  13 bytes

s<>sMjkS^Q2sU

Experimente aqui! ou Confira a suíte de testes.

Alternativas de 13 bytes :

ssM<>jkS^Q2sU
ssM<>jkS*QQsU
s<>sMjkS^Q2sU

Quão?

s<>sMjkS^Q2sU    Full program. Q means input.

       S^Q2      The range [1, Q^2].
     jk          Join as a String.
   sM            Convert each character to integer.
  >              All the elements of the above, but the first Q*(Q-1)/2.
 <               All the element of the above but the last Q.
s                Sum.
                 Output implicitly.

> <>, 141 + 2 bytes

::1+* 2,01\
@}})?/:0$\>$:@{{:
:%a:/?(1:< ,a-]{+1[4
  /~/     \+1~\
1:<]{+1[+4@:-1\?(
{1-}>{:}1(?\@1-@+
    \0}~{{\\n;
@:{{:<-1~$\!?)}}
     ~

1-Indexado

+ 2b para sinalizador -v

O Tio.run realmente não parece gostar dos meus programas <> recentemente ... Ainda pode ser verificado em https://fishlanguage.com . A entrada entra na 'pilha inicial'.

Edit: Acontece que tio.run não gosta, porque lida com '[' e ']' de maneira diferente para fishlanguage.com. O fishlanguage.com inverte a pilha ao criar ou remover uma nova pilha, mas o tio.run não.

Perl 5 , 62 + 1 (-p) = 63 bytes

$_=eval(substr((join'',1..$_*$_),($_**2-$_)/2,$_)=~s/./+$&/gr)

Experimente online!

O resultado é 1 indexado.

Quão?

Concatene mais que o suficiente dígitos juntos e pule os irrelevantes no início (a duração do salto é a soma dos números inteiros de 1 a n-1). Pegue os próximos ndígitos, coloque um +na frente de cada um e avalie essa equação.

JavaScript (ES6), 78 65 bytes

f=
n=>eval([...(g=n=>n?g(n-1)+n:``)(n*n).substr(n*~-n/2,n)].join`+`)

<input type=number min=1 oninput=o.textContent=f(this.value)><pre id=o>

1 indexado. Editar: salvou 13 bytes graças a @tsh.