Desafío:

Dado un entero de índice n, ya sea generar el nelemento 'th en esta secuencia, o generar la secuencia hasta e incluyendo el í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

¿Cómo funciona esta secuencia?

NOTA: En esta explicación, el índice nestá indexado en 1.
Poner los números 1a través xde dos líneas de longitud n*6 - 1, donde xdepende de la iteración actual y la longitud de los números que se utilizan, y luego sumar los dígitos de los n'th / derecha-la mayoría de los Anillos Olímpicos de esas dos líneas.

El primer número en la secuencia se calcula de la siguiente manera:

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

Así n=1resulta en 25.

El segundo número en la secuencia se calcula de la siguiente manera:

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

Así n=2resulta en 25.

El tercer número en la secuencia se calcula de la siguiente manera:

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

Así n=3resulta en 7.

etc.

Reglas de desafío:

• Cuando nsaca el 'th elemento en la secuencia, puede tomar la entrada como 0 indexada en lugar de 1 indexada, pero tenga en cuenta que los cálculos de n*6 - 1entonces serán (n+1)*6 - 1o (n+1)*5 + n.
• Los números individuales de más de un dígito se pueden dividir al final de la primera línea cuando hemos alcanzado la longitud n*5 + n-1, por lo que es posible que un número con 2 o más dígitos sea parcialmente la parte posterior de la línea 1, y parcialmente el parte delantera de la línea 2.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

Casos de prueba:

Aquí hay una papelera de los casos de prueba 1-1,000 , así que siéntase libre de elegir cualquiera de ellos.

Algunos casos de prueba más altos adicionales:

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

Casco , 16 bytes

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

Pruébalo en línea!

-3 bytes gracias a H.PWiz .

Explicación (apresurada):

ΣĊ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`.
*
_

Pruébalo en línea!

Explicación

Llamemos a la entrada n , y la usaremos 3como ejemplo.

.+
10**

El 10**es corto para 10*$&*_que reemplaza la entrada con una cadena de 10n guiones bajos.

.
$.>`

Ahora reemplazamos cada guión bajo con la longitud de la cadena hasta e incluyendo ese guión bajo. Entonces, esto solo da como resultado el número de 1 a 10n todos concatenados juntos ( 10n siempre es suficiente para llenar dos líneas de la longitud requerida).

~(`.+
6*$+*

Eval! Esta y la siguiente etapa generarán el código fuente de otro programa, que luego se ejecutará contra esa cadena de enteros concatenados.

Para generar ese programa, esta etapa primero reemplaza los enteros con una cadena de guiones bajos de 6n (se $+refiere a la entrada original del programa).

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

Luego reemplace esos guiones bajos con L`.{…}, donde …es 6n-1 (la longitud de las líneas que estamos viendo). Así que hemos generado una expresión regular, cuyo cuantificador depende de la entrada original.

Cuando este programa se evalúa, coincide con fragmentos de longitud 6n-1 , de los cuales habrá al menos dos. Para nuestro ejemplo de entrada 3, terminamos con:

12345678910111213
14151617181920212
22324252627282930

Ahora solo necesitamos extraer los dígitos relevantes.

%,-6`.

Primero, en cada línea ( %) eliminamos todos menos los últimos cinco dígitos ( ,-6). Eso nos da

11213
20212
82930

Finalmente:

,2,9`.
*

Expandimos cada dos dígitos ( 2) en los primeros diez ( 9, esto está basado en 0) en unario. Esos son los que están en las posiciones de los Anillos Olímpicos.

_

Y contamos el número de guiones bajos resultantes, para sumarlos y convertir el resultado a 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]))

Pruébalo en línea!

Japt , 33 32 30 29 28 27 bytes

¡Oh, esto no es bonito!

Salidas el n º plazo, 1-indexada.

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

Intentalo

Explicación

                         :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))

Pruébalo en línea!

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)

Pruébalo en línea

Sin embargo, esto está bastante desordenado, pero funciona.

05AB1E , 22 21 20 bytes

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

Pruébalo en línea!

Explicación

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

Enfoque alternativo de 21 bytes

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

Jalea , 19 bytes

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

Pruébalo en línea!

×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)'

Pruébalo en línea!

Ruby , 65 63 56 bytes

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

Pruébalo en línea!

Limpio , 138101 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]])

Pruébalo en línea!

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;}

Por supuesto, tendré que responder a mi propio desafío. :)
Perdí mi código inicial que usé para crear los resultados de la prueba en la descripción del desafío, así que acabo de empezar de nuevo.

Explicación:

Pruébalo en línea.

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