Wyzwanie:

Biorąc pod uwagę liczbę całkowitą indeksu n, albo nwypisz pozycję th w tej sekwencji, albo wypisz sekwencję do indeksu włącznie 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

Jak działa ta sekwencja?

UWAGA: W tym objaśnieniu indeks nma indeks 1.
Umieścić numery 1przez xdwóch linii długości n*6 - 1, gdzie xzależy od bieżącej iteracji i długości numerów używanych, a następnie zsumować cyfry n„TH / prawym większości olimpijskich pierścieni tych dwóch linii.

Pierwszą liczbę w sekwencji oblicza się w następujący sposób:

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

Więc n=1wyniki w 25.

Druga liczba w sekwencji jest obliczana w następujący sposób:

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

Więc n=2wyniki w 25.

Trzecią liczbę w sekwencji oblicza się w następujący sposób:

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

Więc n=3wyniki w 7.

itp.

Zasady konkursu:

• Kiedy wypisujesz n'ósmy element w sekwencji, możesz wziąć dane wejściowe jako 0-indeksowane zamiast 1-indeksowane, ale pamiętaj, że obliczenia n*6 - 1będą wtedy (n+1)*6 - 1lub (n+1)*5 + n.
• Pojedyncze liczby więcej niż jednej cyfry można podzielić na końcu pierwszego wiersza, gdy osiągniemy długość n*5 + n-1, więc możliwe jest, że liczba z 2 lub więcej cyframi jest częściowo końcową częścią linii 1, a częściowo wiodąca część linii 2.

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i zwracanymi typami, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem swojego kodu.
• W razie potrzeby dodaj również wyjaśnienie.

Przypadki testowe:

Oto kosz na śmieci z przypadków testowych 1-1,000 , więc możesz wybrać dowolny z nich.

Niektóre dodatkowe wyższe przypadki testowe:

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

Łuska , 16 bajtów

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

Wypróbuj online!

-3 bajty dzięki H.PWiz .

(Rzucili) wyjaśnienie:

ΣĊ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 bajtów

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

,2,9`.
*
_

Wypróbuj online!

Wyjaśnienie

Nazwijmy wejście n , a wykorzystamy 3jako przykład.

.+
10**

10**Jest skrótem 10*$&*_, który zastępuje wejście z ciągiem 10n podkreślenia.

.
$.>`

Teraz zastępujemy każdy znak podkreślenia długością łańcucha do tego podkreślenia włącznie. W ten sposób powstaje tylko liczba od 1 do 10n połączonych razem ( 10n jest zawsze wystarczające, aby wypełnić dwie linie o wymaganej długości).

~(`.+
6*$+*

Eval! Ten i następny etap wygeneruje kod źródłowy innego programu, który jest następnie uruchamiany dla tego ciągu połączonych liczb całkowitych.

Aby wygenerować ten program, ten etap najpierw zastępuje liczby całkowite ciągiem znaków podkreślenia 6n ( $+odnosi się do oryginalnego wejścia programu).

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

Następnie zamień te podkreślenia na L`.{…}, gdzie …wynosi 6n-1 (długość linii, na które patrzymy). Wygenerowaliśmy więc wyrażenie regularne, którego kwantyfikator zależy od oryginalnych danych wejściowych.

Kiedy program zostanie sprawdzony, dopasowuje fragmenty o długości 6n-1 , z których będą co najmniej dwa. W naszym przykładowym danych wejściowych 3otrzymujemy:

12345678910111213
14151617181920212
22324252627282930

Teraz musimy tylko wyodrębnić odpowiednie cyfry.

%,-6`.

Najpierw w każdej linii ( %) usuwamy wszystkie oprócz ostatnich pięciu cyfr ( ,-6). To nam daje

11213
20212
82930

Wreszcie:

,2,9`.
*

Rozwijamy każdą inną cyfrę ( 2) w pierwszej dziesiątce ( 9ta jest oparta na 0) w postaci jedności. Tak się składa, że ​​znajdują się na pozycjach pierścieni olimpijskich.

_

I zliczamy liczbę wynikowych podkreśleń, aby je zsumować i przekonwertować wynik na dziesiętny.

Python 2 , 94 90 bajtów

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

Wypróbuj online!

Japt , 33 32 30 29 28 27 bajtów

Och, to nie jest ładne!

Wysyła n- ty składnik , indeksowany 1.

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

Spróbuj

Wyjaśnienie

                         :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 bajtów

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

Wypróbuj online!

Python 3, 129 123 bajtów

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)

Wypróbuj online

Jest to jednak dość popsute, ale działa.

05AB1E , 22 21 20 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

Alternatywne podejście 21 bajtów

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

Galaretka , 19 bajtów

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

Wypróbuj 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 bajtów

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

Wypróbuj online!

Rubin , 65 63 56 bajtów

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

Wypróbuj online!

Czysty , 138 101 bajtów

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

Wypróbuj online!

Java 8, 138 111 109 bajtów

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

Oczywiście będę musiał odpowiedzieć na własne wyzwanie. :)
Straciłem początkowy kod, którego użyłem do stworzenia wyników testu w opisie wyzwania, więc zacząłem od nowa.

Wyjaśnienie:

Wypróbuj 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