该七六人序列是可以提供给序列的名字，A087409。我在Numberphile视频中了解了此序列，可以按以下方式构造它：

首先，采用以10为底的6的倍数：

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

JavaScript（ES6）， 71 65  55字节

输出为0索引。

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

在线尝试！

怎么样？

使用递归函数，我们要么“消耗”串连的$6$倍数字符串的前2个字符，要么添加少于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)

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个字节，感谢Grimy
• -3个字节，感谢ArBo
• -6个字节，感谢xnor

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

Haskell，82 ... 65 58 54字节

k$show=<<[6,12..]
k(a:b:c)t|read[a,b]==t=0|let=1+k c t

在线尝试！

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)

木炭，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

J，29 26字节

-3个字节，感谢FrownyFrog！

i.~_2(".\;)6<@":@*1+i.@325

在线尝试！

从0开始

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

Python 3中，87个 81字节：

lambda n:[*zip(*[iter(''.join(map(str,range(6,1951,6))))]*2)].index((*'%02d'%n,))

整数输入，0索引输出。

在线尝试！

_{-6个字节，感谢@TFeld。}

Wolfram语言（Mathematica），74字节

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

在线尝试！

从@Expired Data中保存2个字节

Brachylog，14个字节

;İS∧⟦×₆ᵐcġ₂iSt

在线尝试！

对于具有较大输出的测试用例来说太慢了。

[R ，75 62字节

-13字节，感谢Giuseppe。

match(scan(,''),substring(Reduce(paste0,3*(a=2*1:999)),a-1,a))

在线尝试！

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

APL + WIN，37个字节

提示输入整数。1个索引。

↑(⎕=⍎,((n,2)⍴(⍕6×⍳n)~' '),' ')/⍳n←600

在线尝试！Dyalog经典之作

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

在线尝试！

K（ok），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

果冻，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

爪哇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的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

原始119117字节版本：

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

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

杰普特，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)

红色，97 94字节

func[n][(index? find/skip rejoin collect[repeat i 325[keep i * 6]]pad/left/with n 2 #"0"2)/ 2]

在线尝试！

Stax，11 个字节

Æ▒§±~>ûπ╞öt

运行并调试

输入是整数。输出为0索引。

Perl 5，50 -MList::Util=any -ap个字节

$\=0,$b.=6*++$,while!any{++$\;"@F"==$_}$b=~/../g}{

在线尝试！

基于1的输出

视网膜，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

迅速5 / Xcode的10.2.1，140个 134 133字节的

let s=sequence(first:6){$0+6}.lazy.map{String($0)}.joined();return(0...).first{$0%2==0&&Int(String(s.dropFirst($0).prefix(2)))==n}!/2

在线尝试！

视网膜0.8.2，36字节

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

在线尝试！链接包括测试套件。1个索引。说明：

^
2406$*_

_给输入添加前缀2406 s。

_{6}
$.`

每6 _s用前面的_s 数替换。这产生了序列0，6，12 ... 2400，可自动串接的数字。

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

跳过前导0并找到与最后两位数字匹配的第一对数字，即填充零的输入（因为字符串以结尾0；实际上测试套件使用它以结尾结尾的事实00）。

$#1

输出直到并包括匹配项的数字对的数量。

Retina 1保存了几个字节，因为它的字符串重复运算符短了一个字节，并且已经默认_为它的右侧操作数，因此第二行代码变为just 2406*。视网膜1的另一个功能是>修饰符，该修饰符可在匹配后在分隔符的上下文中生成替换，在这种情况下，$.>`它导致结果中包括匹配的长度。尽管这花费了一个字节，但我们无需将匹配并在替换中乘以6 即可立即将其保存。值得注意的是，这也不会影响总字节数，因为最终结果如下所示：0。（重复次数也必须减少6。）Retina 1也可以进行替代的基本算术运算。这意味着我们不必求助于6的倍数，而只需生成数字1..400

^
400*
_
$.(6*$>`
^(..)+?.*\1$
$#1

Bash，80字节

1个索引。

dc<<<6[p6+lax]salax|sed 's/./\n&/g;s/\n//'|sed 'N;s/\n//'|sed -n "/^0*$1$/{=;q}"

在线尝试！

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的索引。

红宝石，46个字节

->n{[*6.step(5**5,6)].join.scan(/../).index n}

在线尝试！

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

太长！:(