Défi:

Étant donné un entier d'index n, sortez le n'e élément de cette séquence, ou sortez la séquence jusqu'à et y compris l'index 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

Comment fonctionne cette séquence?

REMARQUE: dans cette explication, l'index nest indexé sur 1.
Mettez les chiffres 1par xdeux lignes de longueur n*6 - 1, où xdépend de l'itération courante et la longueur des numéros utilisés, et puis on additionne les chiffres des n« e / droit la plupart des anneaux olympiques de ces deux lignes.

Le premier nombre de la séquence est calculé comme suit:

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

Il en n=1résulte donc 25.

Le deuxième nombre de la séquence est calculé comme suit:

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

Il en n=2résulte donc 25.

Le troisième nombre de la séquence est calculé comme suit:

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

Il en n=3résulte donc 7.

etc.

Règles du défi:

• Lorsque vous sortez le n'e élément de la séquence, vous êtes autorisé à prendre l'entrée comme indexée 0 au lieu de indexée 1, mais gardez à l'esprit que les calculs de n*6 - 1deviendront alors (n+1)*6 - 1ou (n+1)*5 + n.
• Les nombres uniques de plus d'un chiffre peuvent être divisés à la fin de la première ligne lorsque nous avons atteint la longueur n*5 + n-1, il est donc possible qu'un nombre de 2 chiffres ou plus soit partiellement la dernière partie de la ligne 1 et partiellement le partie avant de la ligne 2.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de test:

Voici une boîte à pâte des cas de test 1-1 000 , alors n'hésitez pas à en choisir un.

Quelques cas de test supérieurs supplémentaires:

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

Husk , 16 octets

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

Essayez-le en ligne!

-3 octets grâce à H.PWiz .

Explication (précipitée):

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

Rétine , 70 68 62 octets

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

,2,9`.
*
_

Essayez-le en ligne!

Explication

Appelons l'entrée n , et nous utiliserons 3comme exemple.

.+
10**

Le 10**est court pour 10*$&*_lequel remplace l'entrée par une chaîne de 10n soulignés.

.
$.>`

Maintenant, nous remplaçons chaque trait de soulignement par la longueur de la chaîne jusqu'à et y compris ce trait de soulignement. Il en résulte donc juste le nombre de 1 à 10n tous concaténés ensemble ( 10n est toujours suffisant pour remplir deux lignes de la longueur requise).

~(`.+
6*$+*

Eval! Ceci et l'étape suivante généreront le code source d'un autre programme, qui sera ensuite exécuté sur cette chaîne d'entiers concaténés.

Pour générer ce programme, cette étape remplace d'abord les entiers par une chaîne de 6n soulignés ( $+fait référence à l'entrée d'origine du programme).

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

Remplacez ensuite ces traits de soulignement par L`.{…}, où …est 6n-1 (la longueur des lignes que nous regardons). Nous avons donc généré une expression régulière, dont le quantificateur dépend de l'entrée d'origine.

Lorsque ce programme est évalué, il correspond à des morceaux de longueur 6n-1 , dont il y en aura au moins deux. Pour notre exemple d'entrée 3, nous nous retrouvons avec:

12345678910111213
14151617181920212
22324252627282930

Il nous suffit maintenant d'extraire les chiffres pertinents.

%,-6`.

Tout d'abord, sur chaque ligne ( %), nous supprimons tous, sauf les cinq derniers chiffres ( ,-6). Cela nous donne

11213
20212
82930

Finalement:

,2,9`.
*

Nous développons tous les deux chiffres ( 2) dans les dix premiers ( 9, il s'agit d'un 0) en unaire. Ce sont ceux qui occupent les positions des anneaux olympiques.

_

Et nous comptons le nombre de soulignements résultants, pour les additionner et convertir le résultat en décimal.

Python 2 , 94 90 octets

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

Essayez-le en ligne!

Japt , 33 32 30 29 28 27 octets

Oh, ce n'est pas joli!

Sorties du n ième terme, 1-indexé.

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

Essayez-le

Explication

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

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

Essayez-le en ligne!

Python 3, 129 123 octets

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)

Essayez-le en ligne

C'est à peu près tout foiré, mais ça marche.

05AB1E , 22 21 20 octets

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

Essayez-le en ligne!

Explication

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

Approche alternative de 21 octets

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

Gelée , 19 octets

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

Essayez-le en ligne!

×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 octets

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

Essayez-le en ligne!

Rubis , 65 63 56 octets

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

Essayez-le en ligne!

Propre , 138 101 octets

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

Essayez-le en ligne!

Java 8, 138 111 109 109 octets

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

Je devrai bien sûr répondre à mon propre défi. :)
J'ai perdu mon code initial que j'ai utilisé pour créer les résultats du test dans la description du défi, alors je viens de recommencer.

Explication:

Essayez-le en ligne.

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