Sfida:

Dato un numero intero di indice n, o emette l' nelemento 'th' in questa sequenza, oppure emette la sequenza fino all'indice compreso 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

Come funziona questa sequenza?

NOTA: in questa spiegazione, l'indice nè 1 indicizzato.
Mettere i numeri 1attraverso xdue linee di lunghezza n*6 - 1, in cui xdipende l'iterazione corrente e la lunghezza dei numeri utilizzati, e quindi sommare le cifre dei n'th / più a destra Anelli olimpici di queste due linee.

Il primo numero nella sequenza viene calcolato come segue:

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

Quindi n=1risulta 25.

Il secondo numero nella sequenza viene calcolato come segue:

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

Quindi n=2risulta 25.

Il terzo numero nella sequenza viene calcolato come segue:

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

Quindi n=3risulta 7.

eccetera.

Regole della sfida:

• Quando si emette il n'th elemento nella sequenza, si può prendere l'input come 0-indicizzato anziché 1-indicizzato, ma tenere presente che i calcoli di n*6 - 1diventeranno (n+1)*6 - 1o (n+1)*5 + n.
• I numeri singoli di più di una cifra possono essere suddivisi alla fine della prima riga quando abbiamo raggiunto la lunghezza n*5 + n-1, quindi è possibile che un numero con 2 o più cifre sia in parte la parte finale della riga 1 e in parte il parte iniziale della linea 2.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi test:

Ecco un cestino dei casi di test 1-1.000 , quindi sentiti libero di sceglierne uno qualsiasi.

Alcuni casi di test superiori aggiuntivi:

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

Buccia , 16 byte

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

Provalo online!

-3 byte grazie a H.PWiz .

Spiegazione (affrettata):

ΣĊ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 byte

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

,2,9`.
*
_

Provalo online!

Spiegazione

Chiamiamo l'input n e useremo 3come esempio.

.+
10**

È l' 10**abbreviazione per la 10*$&*_quale sostituisce l'input con una stringa di caratteri di sottolineatura 10n .

.
$.>`

Ora sostituiamo ogni carattere di sottolineatura con la lunghezza della stringa fino a quella di sottolineatura inclusa. Quindi questo porta a un numero compreso tra 1 e 10n tutti concatenati insieme ( 10n è sempre sufficiente per riempire due righe della lunghezza richiesta).

~(`.+
6*$+*

Eval! Questo e lo stadio successivo genereranno il codice sorgente di un altro programma, che verrà quindi eseguito su quella stringa di numeri interi concatenati.

Per generare quel programma, questa fase sostituisce prima gli interi con una stringa di caratteri di sottolineatura 6n (si $+riferisce all'input originale del programma).

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

Quindi sostituisci i trattini bassi con L`.{…}, dove …è 6n-1 (la lunghezza delle linee che stiamo osservando). Quindi abbiamo generato una regex, il cui quantificatore dipende dall'input originale.

Quando questo programma viene valutato, corrisponde a blocchi di lunghezza 6n-1 , di cui ce ne saranno almeno due. Per il nostro esempio di input 3, finiamo con:

12345678910111213
14151617181920212
22324252627282930

Ora dobbiamo solo estrarre le cifre rilevanti.

%,-6`.

Innanzitutto, su ogni riga ( %) rimuoviamo tutti tranne le ultime cinque cifre ( ,-6). Questo ci dà

11213
20212
82930

Infine:

,2,9`.
*

Espandiamo ogni altra cifra ( 2) nei primi dieci ( 9, questo è basato su 0) in unario. Quelli sono quelli nelle posizioni degli anelli olimpici.

_

E contiamo il numero di underscore risultanti, per sommarli e convertire il risultato in decimale.

Python 2 , 94 90 byte

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

Provalo online!

Japt , 33 32 30 29 28 27 byte

Oh, questo non è carino!

Uscite n esimo termine, 1-indicizzati.

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

Provalo

Spiegazione

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

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

Provalo online!

Python 3, 129 123 byte

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)

Provalo online

Questo è praticamente incasinato, ma funziona.

05AB1E , 22 21 20 byte

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

Provalo online!

Spiegazione

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

Approccio alternativo a 21 byte

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

Gelatina , 19 byte

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

Provalo 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 byte

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

Provalo online!

Rubino , 65 63 56 byte

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

Provalo online!

Pulito , 138 101 byte

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

Provalo online!

Java 8, 138 111 109 byte

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

Ovviamente dovrò rispondere alla mia sfida. :)
Ho perso il mio codice iniziale che ho usato per creare i risultati del test nella descrizione della sfida, quindi ho appena ricominciato.

Spiegazione:

Provalo 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