Desafio:

Dado um número inteiro de índice n, produza o n'th item nesta sequência ou produza a sequência até e incluindo o índice n:

25,25,7,28,29,20,21,22,23,14,35,26,7,28,29,20,16,29,12,15,28,21,14,17,30,13,16,29,12,15,28,21,10,6,12,18,15,11,7,13,19,17,13,9,15,21,18,14,10,16,22,19,15,11,17,23,20,16,12,18,24,21,17,13,19,25,23,19,15,21,27,24,20,16,22,28,25,21,17,23,29,16,13,9,15,21,18,14,10,16,22,20,16,12,18,24,21,17,13,19

Como essa sequência funciona?

NOTA: Nesta explicação, o índice né 1 indexado.
Coloque os números 1através xde duas linhas de comprimento n*6 - 1, onde xdepende da iteração atual e o comprimento dos números usados, e depois somar os dígitos dos n'th / mais à direita anéis olímpicos dessas duas linhas.

O primeiro número na sequência é calculado da seguinte forma:

The length of the lines are 5 (because 1*6 - 1 = 5):
12345
67891(0)

Then leave the digits in an Olympic Rings pattern:
1 3 5
 7 9

And sum them:
1+3+5+7+9 = 25

Então n=1resulta em 25.

O segundo número na sequência é calculado da seguinte maneira:

The length of the lines are 11 (because 2*6 - 1 = 11):
12345678910
11121314151(6)

Then leave the digits in the second/right-most Olympic Rings pattern:
      7 9 0 
       4 5

And sum them:
7+9+0+4+5 = 25

Então n=2resulta em 25.

O terceiro número na sequência é calculado da seguinte forma:

The length of the lines are 17 (because 3*6 - 1 = 17):
12345678910111213
14151617181920212(2)

Then leave the digits in the third/right-most Olympic Rings pattern:
            1 2 3
             0 1

And sum them:
1+2+3+0+1 = 7

Então n=3resulta em 7.

etc.

Regras do desafio:

• Quando você gera o n'th item na sequência, você pode receber a entrada como indexada 0 em vez de indexada 1, mas lembre-se de que os cálculos de n*6 - 1se tornarão (n+1)*6 - 1ou (n+1)*5 + n.
• Números únicos de mais de um dígito podem ser divididos no final da primeira linha quando atingimos o comprimento n*5 + n-1, portanto, é possível que um número com 2 ou mais dígitos seja parcialmente a parte final da linha 1 e parcialmente a parte principal da linha 2.

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, adicione uma explicação, se necessário.

Casos de teste:

Aqui está uma pasta dos casos de teste de 1 a 1.000 , portanto, fique à vontade para escolher qualquer um deles.

Alguns casos de teste adicionais adicionais:

1010:   24
1011:   24
2500:   19
5000:   23
7500:   8
10000:  8
100000: 25

Casca , 16 bytes

ΣĊ2ṁ↑_5↑2CṁdN←*6

Experimente online!

-3 bytes graças a H.PWiz .

Explicação (apressada):

ΣĊ2ṁ↑_5↑2CṁdN←*6⁰
Σ                 Sum
 Ċ2                Drop every second element
   ṁ↑_5             Map "take last 5 elements", then concatenate
       ↑2            Take first 2 elements
         C            Cut x into sublists of length y
          ṁdN          [1,2,3,4,5,6,7,8,9,1,0,1,1,1,2,1,3,...] (x)
             ←         Decrement (y)
              *6        Multiply with 6
                ⁰        First argument

Retina , 70 68 62 bytes

.+
10**
.
$.>`
~(`.+
6*$+*
)`.(.+)
L`.{$.1}
%,-6`.

,2,9`.
*
_

Experimente online!

Explicação

Vamos chamar a entrada n , e usaremos 3como exemplo.

.+
10**

A 10**é a abreviatura 10*$&*_que substitui a entrada por uma sequência de 10n sublinhados.

.
$.>`

Agora, substituímos cada sublinhado pelo comprimento da cadeia até e incluindo esse sublinhado. Portanto, isso apenas resulta no número de 1 a 10n concatenados juntos ( 10n é sempre suficiente para preencher duas linhas do comprimento necessário).

~(`.+
6*$+*

Eval! Esse e o próximo estágio gerarão o código fonte de outro programa, que será executado na sequência de números inteiros concatenados.

Para gerar esse programa, esse estágio substitui primeiro os números inteiros por uma sequência de 6n sublinhados ( $+refere-se à entrada original do programa).

)`.(.+)
L`.{$.1}

Em seguida, substitua esses sublinhados por L`.{…}, onde …é 6n-1 (o comprimento das linhas que estamos vendo). Então, geramos um regex, cujo quantificador depende da entrada original.

Quando esse programa é avaliado, ele corresponde a pedaços de comprimento 6n-1 , dos quais haverá pelo menos dois. Para nosso exemplo de entrada 3, terminamos com:

12345678910111213
14151617181920212
22324252627282930

Agora só precisamos extrair os dígitos relevantes.

%,-6`.

Primeiro, em cada linha ( %) removemos todos, exceto os últimos cinco dígitos ( ,-6). Isso nos dá

11213
20212
82930

Finalmente:

,2,9`.
*

Expandimos todos os outros dígitos ( 2) nos dez primeiros ( 9isso é baseado em 0) em unário. Por acaso são aqueles nas posições dos Anéis Olímpicos.

_

E contamos o número de sublinhados resultantes, para somar e converter o resultado em decimal.

Python 2 , 94 90 bytes

n=input()*6
s=''.join(map(str,range(n*2)))
print sum(map(int,s[n-5:n:2]+s[n*2-5:n*2-1:2]))

Experimente online!

Japt , 33 32 30 29 28 27 bytes

Oh, isso não é bonito!

Saídas o n ésimo termo, 1-indexado.

*6É
*2 õ ¬òU mt5n)¬¬ë2 ¯5 x

Tente

Explicação

                         :Implicit input of integer U           :e.g., 3
*6É    
*6                       :Input times 6                         :18
  É                      :Subtract 1                            :17
   \n                    :Assign the above to variable U

*2 õ ¬òU mt5n)¬¬ë2 ¯5 x
*2 õ                     :[1,U*2]                               :[1,2,3,...,33,34]
     ¬                   :Join to a string                      :"123...3334"
      òU                 :Partitions of length U                :["123...13","1415...212","22324...30","31323334"]
         m               :Map
          t5n)           :  Get last 5 characters               :["11213","20212","82930","23334"]
              ¬          :Join to a string                      :"11213202128293023334"
               ¬         :Split to an array                     :["1","1","2","1","3","2","0","2","1","2","8","2","9","3","0"],["2","3","3","3","4"]]
                ë2       :Get every second element              :["1","2","3","0","1","8","9","0","3","3"]
                   ¯5    :Get first 5 elements                  :["1","2","3","0","1"]
                      x  :Reduce by addition                    :7
                         :Implicit output of result

Python 2 , 97 bytes

n=input()*6;k=1;s=''
exec's+=`k`;k+=1;'*n*2
print sum(int(s[p])for p in(n-2,n-4,n-6,n*2-4,n*2-6))

Experimente online!

Python 3, 129 123 bytes

p=lambda r,x='',i=1:sum(map(int,str(x[6*r-2]+x[6*r-4]+x[6*r-6]+x[12*r-4]+x[12*r-6])))if len(x)>12*r-2else p(r,x+str(i),i+1)

Experimente Online

Isso é muito complicado, mas funciona.

05AB1E , 22 21 20 bytes

6*<xLJsô2£íε5£}SāÉÏO

Experimente online!

Explicação

6*<                    # push input*6-1
   xL                  # leave it on the stack while pushing [1 ... 12*input-2]
     J                 # join the numbers to a single string
      sô               # split the string into pieces of size input*6-1
        2£             # take the first 2 such pieces
          í            # reverse each string
           ε5£}        # take the first 5 chars of each
               S       # split to a single list of digits
                ā      # push range [1 ... len(list)]
                 ÉÏ    # keep only the numbers in the list of digits which are odd in this
                   O   # sum

Abordagem alternativa de 21 bytes

6*<©·LJƵYS24S®-ì®-(èO

Geléia , 19 bytes

×6’µḤD€Ẏsḣ2ṫ€-4Ẏm2S

Experimente online!

×6’µḤD€Ẏsḣ2ṫ€-4Ẏm2S Arguments: n (1-indexed)
×6                  Multiply by 6
  ’                 Decrement
   µ                Call that value N and start a new chain with argument N
    Ḥ               Double
      €             Create an inclusive range from 1 to 2N and call this link on it
     D               Get the decimal digits of each integer in the range
       Ẏ            Concatenate the lists of digits
        s           Split into length-N chunks
         ḣ2         Get the first two elements
            €-4     Map this link over the length-2 list with right argument -4
           ṫ         Get elements from this index onwards (supports negative indices too)
               Ẏ    Concatenate the two length-5 lists into one length-10 list
                m2  Take every second element starting from the first
                  S Sum

J , 61, 58 57 bytes

g=.3 :'+/".,_2(2{.{.)\,_5{."1(2{.(-.6*y)]\;":&.>1+i.9*y)'

Experimente online!

Ruby , 65 63 56 bytes

->n{[2,4,6,4-n*=6,6-n].sum{|a|([*1..n*2]*'')[n-a].to_i}}

Experimente online!

Limpo , 138 101 bytes

import StdEnv
$n=sum(tl[toInt([c-'0'\\i<-[1..],c<-:toString i]!!(6*i+j))\\i<-[2*n-1,n-1],j<-[4,0,2]])

Experimente online!

Java 8, 138 111 109 bytes

n->{String s="";int r=0,i=1;for(n=n*6-1;i<3*n;s+=i++);for(i=5;i>0;r+=s.charAt(n+n*(i%2^1)-i--)-48);return r;}

Claro que terei que responder ao meu próprio desafio. :)
Perdi meu código inicial que usei para criar os resultados do teste na descrição do desafio, então comecei novamente.

Explicação:

Experimente online.

n->{                               // Method with integer as both parameter and return-type
  String s="";                     //  Temp String
  int r=0,                         //  Result-sum, starting at 0
      i=1;                         //  Index integer, starting at 1
  for(n=n*6-1;                     //  Replace the input with `n*6-1`
      i<3*n;                       //  Loop from 1 up to 3*n (exclusive)
      s+=i++);                     //   And append the temp-String with `i`
  for(i=5;i>0;                     //  Loop from 5 down to 0 (exclusive)
    r+=                            //   Add to the result-sum:
       s.charAt(               )-48);
                                   //    The character at index X, converted to a number,
                n+n*(i%2^1)-i--    //    with X being `n-i` (i=odd) or `n+n-i` (i=even)
  return r;}                       //  Return the result-sum