Первое вхождение в последовательности Шестёрок

17

Последовательность Sixers - это имя, которое можно присвоить последовательности A087409 . Я узнал об этой последовательности в видео Numberphile , и она может быть построена следующим образом:

Сначала возьмем кратные 6, записанные в базе 10:

6, 12, 18, 24, 30, 36, ...

Затем объедините числа в поток цифр:

61218243036...

Наконец, перегруппируйте поток в пары и интерпретируйте каждый как целое число:

61, 21, 82, 43, 3, ...

Поскольку мы группируем числа в пары, максимальное число в последовательности будет 99, и получается, что все неотрицательные целые числа меньше 100 представлены в последовательности. Эта задача состоит в том, чтобы найти индекс первого экземпляра числа в последовательности Sixers.

вход

Целое число в диапазоне [0-99]. Вам не нужно учитывать числа, выходящие за пределы этого диапазона, и ваше решение может иметь любое поведение, если дан такой ввод.

Выход

Индекс первого вхождения входного числа в последовательности Sixers. Это может быть 0- или 1-индексированный; пожалуйста, скажите, что вы используете в своем ответе.

правила

  • Процедура генерации последовательности, отмеченная во введении, предназначена только для иллюстративных целей, вы можете использовать любой понравившийся вам метод, если результаты совпадают.
  • Вы можете представить полные программы или функции.
  • Разрешены любые разумные методы ввода и вывода.
  • Стандартные лазейки запрещены.
  • Рекомендуется использовать ссылки для проверки вашего кода онлайн!
  • Это код-гольф , поэтому выигрывает самый короткий ответ на каждом языке!

Контрольные примеры

Вот список всех входов и выходов в формате input, 0-indexed output, 1-indexed output.

0   241 242
1   21  22
2   16  17
3   4   5
4   96  97
5   126 127
6   9   10
7   171 172
8   201 202
9   14  15
10  17  18
11  277 278
12  20  21
13  23  24
14  19  20
15  29  30
16  32  33
17  297 298
18  35  36
19  38  39
20  41  42
21  1   2
22  46  47
23  69  70
24  6   7
25  53  54
26  22  23
27  11  12
28  62  63
29  219 220
30  65  66
31  68  69
32  71  72
33  74  75
34  49  50
35  357 358
36  80  81
37  83  84
38  25  26
39  89  90
40  92  93
41  27  28
42  42  43
43  3   4
44  101 102
45  104 105
46  8   9
47  177 178
48  110 111
49  13  14
50  28  29
51  119 120
52  122 123
53  417 418
54  79  80
55  128 129
56  131 132
57  134 135
58  55  56
59  437 438
60  140 141
61  0   1
62  31  32
63  75  76
64  5   6
65  120 121
66  82  83
67  10  11
68  161 162
69  164 165
70  58  59
71  477 478
72  170 171
73  173 174
74  34  35
75  179 180
76  182 183
77  497 498
78  85  86
79  188 189
80  191 192
81  18  19
82  2   3
83  78  79
84  93  94
85  7   8
86  37  38
87  168 169
88  12  13
89  228 229
90  88  89
91  218 219
92  221 222
93  224 225
94  64  65
95  557 558
96  230 231
97  233 234
98  40  41
99  239 240
code-golf  sequence 
— Sok
источник
6
Может быть полезно знать, что рассмотрение 6, 2*6, 3*6,..., 325*6достаточно для генерации всех возможных значений
— Луис Мендо
@ LuisMendo Вы правы, я спорил, включить ли это в описание вызова. Комментарий также является хорошим местом для этого: o)
— Sok
Можем ли мы взять на себя ввод-целое число как строку, с теми , проложенный с ведущим 0 (т.е. , , , ...)? n<10000102
— Кевин Круйссен
10
@KevinCruijssen Хммм, ввод в виде строки в порядке, но отступ слева от 0 - это слишком много для ИМО.
— Сок

Ответы:

12

JavaScript (ES6),  71 65  55 байт

Вывод 0 проиндексирован.

n=>(g=([a,b,...c])=>b?a+b-n&&1+g(c):g([a]+6*++i))(i='')

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

Как?

Используя рекурсивную функцию, мы либо «потребляем» первые 2 символа строки сцепленных кратных 6 , либо добавляем новые символы, если у нас их меньше 2.

Пример для n=3 :

 string | operation                          | result
--------+------------------------------------+--------
 ''     | not enough characters: append '6'  |   0
 '6'    | not enough characters: append '12' |   0
 '612'  | consume '61', increment the result |   1
 '2'    | not enough characters: append '18' |   1
 '218'  | consume '21', increment the result |   2
 '8'    | not enough characters: append '24' |   2
 '824'  | consume '82', increment the result |   3
 '4'    | not enough characters: append '30' |   3
 '430'  | consume '43', increment the result |   4
 '0'    | not enough characters: append '36' |   4
 '036'  | consume '03': success              |   4

комментарии

n => (             // n = input
  g = (            // g is a recursive function taking either a string or an array of
                   // characters split into:
    [a, b,         //   a = 1st character, b = 2nd character,
           ...c]   //   c[] = array of all remaining characters
  ) =>             //
    b ?            // if b is defined:
      a + b - n && //   if n subtracted from the concatenation of a and b is not zero:
        1 + g(c)   //     add 1 to the final result and do a recursive call with c[]
                   //   (otherwise: yield 0 and stop recursion)
    :              // else:
      g(           //   do a recursive call with:
        [a] +      //     the concatenation of a (forced to an empty string if undefined)
        6 * ++i    //     and 6 * i, with i pre-incremented
      )            //   end of recursive call
)(i = '')          // initial call to g with an empty string,
                   // and i set to empty string as well (zero'ish)
— Arnauld
источник
12

Python 2 , 93 92 85 83 81 68 65 59 байт

f=lambda n,s='612',i=18:n-int(s[:2])and-~f(n,s[2:]+`i`,i+6)

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

  • -2 байта, спасибо Грими
  • -3 байта, благодаря ArBo
  • -6 байт, благодаря xnor
— TFeld
источник
1
На 3 байта короче лямбды:f=lambda n,s='612',i=3:n-int(s[:2])and f(n,s[2:]+`i*6`,i+1)or i-2
— ArBo
@ArBo Еще лучше, f=lambda n,s='612',i=18:n-int(s[:2])and-~f(n,s[2:]+`i`,i+6)(0-проиндексировано).
— xnor
8

Perl 6 , 31 байт

{+(comb(2,[~] 1..ⅮX*6)...$_)}

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

Использует 1-индексированную последовательность.

Объяснение:

{                            } # Anonymous code block
              1..Ⅾ             # The range 1 to 500
                   X*6         # All multiplied by 6
          [~]                  # Join as one giant string
   comb(2,            )        # Split into pairs of characters
                       ...$_   # Take up to the input
 +(                         )  # And return the length of the list
— Джо Кинг
источник
5

05AB1E , 9 байтов

₄L6*J2ôIk

0 индексированные. Принимает в качестве входных данных одно целое число или список целых чисел.

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

₄L         # Create a list in the range [1,1000]
  6*       # Multiply each value by 6
    J      # Join the entire list of integers together to a string
     2ô    # Split into parts of size 2
       Ik  # Get the index of the input integer(s)
           # (and output the result implicitly)
— Кевин Круйссен
источник
Поведение по умолчанию для присоединения в виде строки, или есть отдельные операторы для присоединения в виде строки и объединения в качестве числа?
— максимум
@maxb В целом 05AB1E не нуждается в явных преобразованиях. Все целые числа также могут использоваться для строковых функций, таких как замена или разбиение, и все созданные строки (которые являются целыми числами) также могут использоваться в качестве чисел. Итак 100, "100"и 100.0одинаковы для большинства функций, таких как равные проверки и тому подобное. В 05AB1E все еще есть функции приведения к типу int и преобразования к строковым функциям для некоторых функций, таких как сортировка (числовая или лексикографическая сортировка) или для удаления десятичных цифр после запятой из числа с плавающей точкой при приведении к int, но они не так часто используются. ,
— Кевин Круйссен
@maxb Соответствующий совет 05AB1E, содержащий несколько дополнительных примеров.
— Кевин Круйссен
4

Древесный уголь , 12 байт

Ｉ⌕Ｉ⪪⭆φ×⁶⊕ι²Ｎ

Попробуйте онлайн! Ссылка на подробную версию кода. 0 индексированные. Объяснение:

     φ           Predefined constant 1000
    ⭆           Map over implicit range and join
        ι       Current index
       ⊕        Incremented
     ×⁶         Multiplied by 6
   ⪪      ²     Split into pairs of digits
  Ｉ             Cast to integer
           Ｎ    Input as a number
 ⌕              Find its index
Ｉ               Cast to string
                Implicitly print
— Нил
источник
4

APL (Dyalog Unicode) , 26 байт

{⍵⍳⍨⍎¨((≠\=⍨)⊂⊢)∊⍕¨6×⍳325}

Попробуйте онлайн! - Тесты для всех действительных входных данных.

Как:

{⍵⍳⍨⍎¨((≠\=⍨)⊂⊢)∊⍕¨6×⍳325} ⍝ Dfn, input is ⍵.
                    6×⍳325  ⍝ Generates the first 325 multiples of 6.
                  ⍕¨        ⍝ Format each number into a string
                 ∊          ⍝ Enlist, flattens the vector
       (      ⊂⊢)           ⍝ Dyadic enclose, takes a boolean mask as left argument
        (≠\=⍨)              ⍝ Generates the mask 1 0 1 0...
                            ⍝ Enclose then returns the Sixers sequence as a string
     ⍎¨                     ⍝ Execute each element in the string, turning it into a numeric vector
 ⍵⍳⍨                        ⍝ Find the first occurrence of ⍵ in the vector
— Ж. Салле
источник
Вы можете изменить форму сплющенного вектора, как вы можете в K? Google предлагает , ⍴но APL меня пугает ...
— streetster
@streetster да, ⍴это перестройка APL. Поэтому, если вы хотите изменить форму сплющенного вектора, вам просто нужно это сделать<new shape vector> ⍴ <vector to reshape>
— J. Sallé
так что вы могли бы использовать Reshape для создания списка 2xN, а затем преобразовать каждый в целое число?
— streetster
Вы могли бы, но я не думаю, что это будет короче, чем мой текущий ответ. Одной из проблем было бы то, что, для моего ответа, преобразование строки в матрицу 1117 × 2, а затем преобразование в целые числа привело бы к созданию вектора с 1117, однозначными целыми числами. Смотрите разницу между методом, который я использую, по сравнению с изменением формы
— J. Sallé
Ах, моя сплющенная строка получает реорганизована в нечто более работоспособное :)
— streetster
3

Wolfram Language (Mathematica) , 74 байта

#&@@Position[FromDigits/@Flatten@IntegerDigits[6Range@365]~Partition~2,#]&

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

2 байта сохранены из @Expired Data

— J42161217
источник
— действия данных
Я работал над этим до того, как увидел твои .. объединил их и получил 77 байтов
— данные
@ExpiredData приятно. 74 байта сейчас
— J42161217
2

MathGolf , 10 байт

•╒6*y░2/i=

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

По сути то же самое, что и ответ 05AB1E, но я теряю байт из-за явного преобразования преобразованного числа в строку.

объяснение

•╒             push [1, 2, ..., 512]
  6*           multiply by 6
    y          join array without separator to string or number
     ░         convert to string (implicit map)
      2/       split into groups of 2 characters
        i      convert to integer (implicit map)
         =     find index of implicit input in the array
— MaxB
источник
2

C # (интерактивный компилятор Visual C #) , 123 байта, 115 байтов

a=>m.First(y=>int.Parse(string.Join("",m.Select((x,i)=>++i*6)).Substring(y*2,2))==a);var m=Enumerable.Range(0,640);

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

— Истек срок действия данных
источник
Я думаю, что в вашем решении где-то есть ошибка, которая f(61)должна вернуться 0(похоже, что ваше решение 0-проиндексировано)
— Sok
1
Спасибо @sok теперь нужно исправить
— Просроченные данные
2

K (ок) , 22 байта

Решение:

(.:'0N 2#,/$6*1+!999)?

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

Объяснение:

0 индексированные.

(.:'0N 2#,/$6*1+!999)? / the solution
                     ? / lookup right in left
(                   )  / do this together
                !999   / range 0..999
              1+       / add 1, range 1...1000
            6*         / multiply by 6, 6...6000
           $           / convert to strings
         ,/            / flatten
    0N 2#              / reshape into 2xN
 .:'                   / value each, convert to numbers
— streetster
источник
2

Желе , 10 байт

ȷ×€6DFs2Ḍi

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

Ссылка TIO дает все значения от 0 до 99.

объяснение

ȷ          | 1000
 ×€6       | each times 6 (using implicit range from 1..1000)
    D      | Convert to decimal digits
     F     | Flatten
      s2   | Split into pairs
        Ḍ  | Convert back from decimal digits to integer
         i | Find index of left argument to link
— Ник Кеннеди
источник
2

Java 10, 119 104 102 байта

n->{int i=2;for(var s="612";!s.substring(0,2).equals(""+n/10+n%10);)s=s.substring(2)+6*++i;return~-i;}

Порт ответа @TFeld 's Python 2 .
-2 байта благодаря @Imus .

1-индексироваться.

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

Объяснение:

n->{                            // Method with integer as both parameter and return-type
  int i=2;                      //  Index-integer, starting at 2
  for(var s="612";              //  String, starting at "612"
      !s.substring(0,2)         //  Loop as long as the first two characters of the String
       .equals(                 //  Are not equal to:
               ""+n/10          //   The input integer-divided by 10 as String
               +n%10);)         //   Concatenated with the input modulo-10
                                //   (which will add leading 0s for inputs < 10)
    s=s.substring(2)            //   Remove the first two characters of the String
      +6*++i;                   //   And append 6 times `i`,
                                //   after we've first increased `i` by 1 with `++i`
return~-i;}                     //  Return `i-1` as result

Оригинальная версия 119 117 байт:

n->{var s="";for(int i=0;i<2e3;)s+=i+=6;return java.util.Arrays.asList(s.split("(?<=\\G..)")).indexOf(""+n/10+n%10);}

0 индексированные.

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

Объяснение:

n->{                            // Method with integer as both parameter and return-type
  var s="";                     //  String we're building, starting empty
  for(int i=0;i<2e3;)           //  Loop `i` in the range [0, 2000):
      s+=i+=6;                  //   Increase `i` by 6 first every iteration
                                //   And then append the updated `i` to String `s`
  return java.util.Arrays.asList(
          s.split("(?<=\\G..)") //  Split the String in parts of size 2 (as array)
         )                      //  Convert the array to a List
          .indexOf(             //  And get the index of the following in this list:
                   ""+n/10      //   The input integer-divided by 10 as String
                   +n%10);}     //   Concatenated with the input modulo-10
— Кевин Круйссен
источник
1
Вы можете сохранить 2 байта, используя "" + n / 10 + n% 10 вместо n> 9? N + "": "0" + n
— Imus
1

CJam , 17 байт

325,:)6f*s2/:~ri#

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

0 на основе.

объяснение

325,   e# Range [0 1 2 ... 324]
:)     e# Add 1 to each: gives [1 2 3 ... 325]
6f*    e# Multiply each by 6: gives [6 12 18 ... 1950]
s      e# Convert to string: gives "61218...1950"
2/     e# Split into chunks of size 2: gives ["61" "21" ... "95" "0"]
       e# Note how the last chunk has size 1; but it is not used
:~     e# Evaluate each string in that array: gives [61 21 ... 95 0]
ri     e# Read input as an integer
#      e# Index of fist occurrence, 0-based
— Луис Мендо
источник
Из любопытства, почему CJam имеет встроенные функции для всех целых чисел в диапазоне [10,20], а также пять различных встроенных функций, которые по умолчанию имеют пустую строку "", но не содержат встроенных100 или 1000?
— Кевин Круйссен
@KevinCruijssen Не уверен ... Но иметь переменные с предопределенными значениями, такими как 0или ""иногда полезными для циклов, потому что они часто являются желаемыми начальными значениями. Что касается отсутствия 100или 1000, да, я согласен, что они были бы более полезными, чем сказать 18или19
— Луис Мендо
1
Обидно, что ведущие нули раздражают, иначе вы можете отказаться от :~и iиз своего кода. :(
— Эрик Outgolfer
1

Japt , 12 байт

0 индексированные.

L²õ*6 ¬ò b¥U

Попробуйте или проверьте все входы

L²õ*6 ¬ò b¥U     :Implicit input of integer U
L                :100
 ²               :Squared
  õ              :Range [1,L²]
   *6            :Multiply each by 6
      ¬          :Join to a string
       ò         :Split to array of strings each of length 2
         b       :First 0-based index of
          ¥U     :Test for equality with U (bU wouldn't work here as each string would first need to be cast to an integer, costing more bytes)
— мохнатый
источник
1

Retina , 83 77 байт

У меня действительно нет практики в сложном программировании в Retina, но я доволен длиной, в которой мне удалось это сделать.

Выводит 0-индексированный результат.

.+
6*1
325+-1%`1+
$0¶6*1$0
1+
$.0
¶

L`..
m`^0

$
¶$+
s`\b(\d+)\b.*\b\1$

C`¶

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

объяснение

.+                   Replace the input with 6 in unary
6*1
325+-1%`1+           Do 325 times: append line with previous + 6
$0¶6*1$0
1+                   Convert all lines to decimal
$.0
¶                    Remove line breaks

L`..                 List pairs of digits
m`^0                 Remove leading zeros

$                    Append the original input N on a new line
¶$+
s`\b(\d+)\b.*\b\1$   Remove occurrences of N and anything in between

C`¶                  Count the number of line breaks
— mbomb007
источник
1

Сетчатка 0.8.2 , 36 байт

^
2406$*_
_{6}
$.`
^0(..)+?.*\1$
$#1

Попробуйте онлайн! Ссылка включает тестовый набор. 1-индексироваться. Объяснение:

^
2406$*_

Префикс 2406 _с на входе.

_{6}
$.`

Заменить каждые 6 _с числом предыдущих _с. Это порождает последовательность 0, 6, 12... 2400, но автоматически присоединяет номера.

^0(..)+?.*\1$

Пропустите начальный 0 и найдите первую пару цифр, которые соответствуют двум последним цифрам, т. Е. Вводу с нулевым отступом (поскольку строка заканчивается 0; фактически, набор тестов использует тот факт, что она заканчивается 00).

$#1

Выведите количество пар цифр до и включая совпадение.

Сетчатка 1 сохраняет пару байтов, потому что ее оператор повторения строк является байтовым короче и уже по умолчанию имеет значение _своего правого операнда, так что вторая строка кода становится справедливой и умножается на 6 при замене. Примечательно, что это также не влияет на общее количество байтов, так как конечный результат выглядит следующим образом:2406* . Еще одна особенность Retina 1 - это> модификатор, который генерирует подстановку в контексте разделителя после совпадения, что в случае $.>`заставляет его включать длину совпадения в результат. Хотя это стоит байт, мы сохраняем его немедленно, поскольку нам не нужно сопоставлять0 . (Количество повторений также должно быть уменьшено на 6.) Сетчатка 1 также может выполнять базовую арифметику в замене. Это означает, что нам не нужно прибегать к уловкам, чтобы брать кратные 6, вместо этого мы просто генерируем числа1..400

^
400*
_
$.(6*$>`
^(..)+?.*\1$
$#1
— Нил
источник
1

C # (интерактивный компилятор Visual C #) , 88 байт

n=>{int i=2;for(var s="612";!s.StartsWith($"{n:d2}");s=s.Substring(2)+6*++i);return~-i;}

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

Другой порт Java и Python отвечает.

Мой оригинальный ответ ниже:

C # (интерактивный компилятор Visual C #) , 102 байта

n=>{dynamic s="",t=$"{n:d2}",i=0;for(;i++<400;s+=i*6);for(i=0;s[i++]!=t[0]|s[i++]!=t[1];);return i/2;}

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

Оба решения используют индексирование на основе 1.

— Dana
источник
1

Clojure, 102 байта

#(count(for[i(partition 2(for[i(range 1 326)c(str(* i 6))]c)):while(not=(seq(str(if(< % 10)0)%))i)]i))

Пока! :(

— NikoNyrh
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.