Вызов:

Учитывая целое число индекса n, либо выведите n'-ый элемент в этой последовательности, либо выведите последовательность до индекса включительно 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

Как работает эта последовательность?

ПРИМЕЧАНИЕ. В этом описании индекс индексируется nкак 1.
Поместите цифры 1через xна двух линиях длиной n*6 - 1, где xзависит от текущей итерации и длины используемых чисел, а затем просуммировать цифры в n-м / правого большинства олимпийских колец этих двух линий.

Первое число в последовательности рассчитывается следующим образом:

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

Так что n=1результаты в 25.

Второе число в последовательности рассчитывается следующим образом:

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

Так что n=2результаты в 25.

Третье число в последовательности рассчитывается следующим образом:

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

Так что n=3результаты в 7.

и т.п.

Правила соревнований:

• Когда вы nвыводите элемент 'th в последовательности, вам разрешается принимать входные данные как 0-индексированные вместо 1-индексированных, но имейте в виду, что вычисления n*6 - 1затем станут (n+1)*6 - 1или (n+1)*5 + n.
• Отдельные числа, состоящие более чем из одной цифры, могут быть разделены в конце первой строки, когда мы достигли длины n*5 + n-1, поэтому возможно, что число с 2 или более цифрами будет частично завершающей частью строки 1, а частично ведущая часть линии 2.

Основные правила:

• Это код-гольф , поэтому выигрывает самый короткий ответ в байтах.
  Не позволяйте языкам кода-гольфа отговаривать вас от публикации ответов на языках, не относящихся к кодексу. Попробуйте придумать как можно более короткий ответ для «любого» языка программирования.
• К вашему ответу применяются стандартные правила , поэтому вы можете использовать STDIN / STDOUT, функции / метод с правильными параметрами и типом возврата, полные программы. Ваш звонок.
• По умолчанию лазейки запрещены.
• Если возможно, добавьте ссылку с тестом для вашего кода.
• Также, пожалуйста, добавьте объяснение, если это необходимо.

Тестовые случаи:

Вот набор тестовых наборов 1-1000 , поэтому вы можете выбрать любой из них.

Некоторые дополнительные более высокие тесты:

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

Шелуха , 16 байт

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

Попробуйте онлайн!

-3 байта благодаря H.PWiz .

(Бросился) объяснение:

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

Сетчатка , 70 68 62 байта

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

,2,9`.
*
_

Попробуйте онлайн!

объяснение

Давайте назовем вход n , и мы будем использовать 3в качестве примера.

.+
10**

Это 10**сокращение, 10*$&*_которое заменяет ввод строкой из 10n подчеркиваний.

.
$.>`

Теперь мы заменим каждое подчеркивание длиной строки до того, включая это подчеркивание. Таким образом, это просто приводит к объединению числа от 1 до 10n ( 10n всегда достаточно, чтобы заполнить две строки необходимой длины).

~(`.+
6*$+*

Eval! На этом и следующем этапах будет сгенерирован исходный код другой программы, которая затем будет запущена для этой строки сцепленных целых чисел.

Чтобы сгенерировать эту программу, этот этап сначала заменяет целые числа строкой 6n подчеркиваний ( $+относится к исходному вводу программы).

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

Затем замените эти подчеркивания с L`.{…}, где …находится 6n-1 (длина линий , которые мы ищем в). Итак, мы сгенерировали регулярное выражение, квантификатор которого зависит от исходного ввода.

Когда эта программа получает значение eval'ed, она соответствует фрагментам длиной 6n-1 , из которых будет как минимум два. Для нашего примера ввода 3мы получаем:

12345678910111213
14151617181920212
22324252627282930

Теперь нам просто нужно извлечь соответствующие цифры.

%,-6`.

Сначала в каждой строке ( %) мы удаляем все, кроме последних пяти цифр ( ,-6). Это дает нам

11213
20212
82930

В заключение:

,2,9`.
*

Мы расширяем все остальные цифры ( 2) в первой десятке ( 9это основано на 0) в унарном виде. Это те, кто находится на позициях олимпийских колец.

_

И мы подсчитываем количество результирующих подчеркиваний, суммируем их и преобразовываем результат в десятичную.

Python 2 , 94 90 байт

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

Попробуйте онлайн!

Japt , 33 32 30 29 28 27 байт

О, это не красиво!

Выводит n- й член, 1-индексированный.

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

Попытайся

объяснение

                         :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 байт

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

Попробуйте онлайн!

Python 3, 129 123 байта

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)

Попробуйте онлайн

Это в значительной степени запутано, но работает.

05AB1E , 22 21 20 байт

6*<xLJsô2£íε5£}SāÉÏ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

Альтернативный 21-байтовый подход

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

Желе , 19 байт

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

Попробуйте онлайн!

×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 байт

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

Попробуйте онлайн!

Рубин , 65 63 56 байт

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

Попробуйте онлайн!

Чисто , 138 101 байт

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

Попробуйте онлайн!

Java 8, 138 111 109 байт

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

Я, конечно, должен ответить на свой собственный вызов. :)
Я потерял свой исходный код, который использовал для создания результатов теста в описании задания, поэтому я только начал заново.

Объяснение:

Попробуйте онлайн.

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