[Question]
  [
The **Sixers sequence** is a name that can be given to sequence [A087409](http://oeis.org/A087409). I learned about this sequence in a [Numberphile video](https://youtu.be/OeGSQggDkxI?t=114), and it can be constructed as follows:
First, take the multiples of 6, written in base 10:
`6, 12, 18, 24, 30, 36, ...`
Next, concatenate the numbers into a stream of digits:
`61218243036...`
Finally, regroup the stream into pairs and interpret each as an integer:
`61, 21, 82, 43, 3, ...`
As we're grouping the numbers into pairs, the maximum number in the sequence will be 99, and it turns out that all non-negative integers less than 100 are represented in the sequence. This challenge is to find the index of the first instance of a number in the Sixers sequence.
## Input
An integer in the range `[0-99]`. You do not need to account for numbers outside this range, and your solution can have any behaviour if such an input is given.
## Output
The index of the first occurrence of the input number in the Sixers sequence. This may be 0- or 1-indexed; please say which you are using in your answer.
## Rules
* The procedure to generate the sequence noted in the introduction is for illustrative purposes only, you can use any method you like as long as the results are the same.
* You can submit full programs or functions.
* Any sensible methods of input and output are allowed.
* Standard loopholes are disallowed.
* Links to test your code online are recommended!
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in each language wins!
## Test cases
Here is a list of all input and outputs, in the format `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
```
  
[Answer]
# JavaScript (ES6), ~~71 65~~ 55 bytes
Output is 0-indexed.
```
n=>(g=([a,b,...c])=>b?a+b-n&&1+g(c):g([a]+6*++i))(i='')
```
[Try it online!](https://tio.run/##FcpBCoMwEEDRvaeYhehMR4NuuqiNPUgRjKmGiEyKlm7Es6d29@H92XzNZlf//pQSXmOcdBTdotP4NMVQKKVsR7odHoaHUrKsZoeWbu7kjq8XZk@EXuc5xSmsKKChakDgDnX1D2aCPQGwQbawjGoJDnuD6S4HnW@6Tyh09NQkR/wB "JavaScript (Node.js) – Try It Online")
### How?
Using a recursive function, we either 'consume' the first 2 characters of the string of concatenated multiples of \$6\$, or append new characters if we have less than 2 of them.
Example for \$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
```
### Commented
```
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)
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~93~~ ~~92~~ ~~85~~ ~~83~~ ~~81~~ ~~68~~ ~~65~~ 59 bytes
```
f=lambda n,s='612',i=18:n-int(s[:2])and-~f(n,s[2:]+`i`,i+6)
```
[Try it online!](https://tio.run/##DcpBCoAgEADAr3jTJYP0ECH4EgnaMEuoTdRLl75uzXnSU4@bdGvBnnitHhnJYvmoNJfRqslQH6mK4oyeAcn3bxD/cNrM3RIXGbsRWsr/YRcmESTLSPsm1DAAtA8 "Python 2 – Try It Online")
---
* -2 bytes, thanks to Grimy
* -3 bytes, thanks to ArBo
* -6 bytes, thanks to xnor
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 31 bytes
```
{+(comb(2,[~] 1..ⅮX*6)...$_)}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwv1pbIzk/N0nDSCe6LlbBUE/vUeu6CC0zTT09PZV4zdr/aflFCnGGBgYK1VwKCsWJlQp6amlctf8B "Perl 6 – Try It Online")
Uses the 1-indexed sequence.
### Explanation:
```
{                            } # 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
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~82 ... 65 58~~ 54 bytes
```
k$show=<<[6,12..]
k(a:b:c)t|read[a,b]==t=0|let=1+k c t
```
[Try it online!](https://tio.run/##DchLDsIgEADQvaeYRRd@KmldmLRhvIEnQBZTREuAlhQSE9OzO3b53kjZ2xA44oN9lcf5g1Kqa91ehNA7v6d@6M2hrIulp6J60IgFmzXYgu3Jg4HCkdyEkdId0uKmAhV8XQJ5vMGWEDerRoiu0/wzr0DvzGeT0h8)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 9 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
₄L6*J2ôIk
```
0-indexed. Accepts either a single integer, or a list of integers as input.
[Try it online](https://tio.run/##yy9OTMpM/f//UVOLj5mWl9HhLZ7Z//8bAAA) or [verify all test cases](https://tio.run/##DZC7TUVREAP7QROc/e@WAKKDJwKQCBABAR0gSqIDOqGRy6aWbI/98fn88vZ6XX9f349596C/P/fv13U7CIrhBEnRDLKiIIoY4kggiRTSyKAHXY@ihjoaaKKFNjrYwQTbSMMcCyyxwhob/OCCK76NjgeeeOGND3EIIZQwYoGCSKKIJoY8pJBKGunk8iZZZJNDHUoopYxyKqidU1RTQx9aaKWNdjropHdt08McRhhljHEmmGSK2TPm6R8).
**Explanation:**
```
₄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)
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 26 bytes
```
{⍵⍳⍨⍎¨((≠\=⍨)⊂⊢)∊⍕¨6×⍳325}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v/pR79ZHvZsf9a541Nt3aIWGxqPOBTG2QK7mo66mR12LNB91dD3qnXpohdnh6UB1xkamtf/THrVNAKp@1DfV0/9RV/Oh9caP2iYCecFBzkAyxMMz@P@j3lVph1YY6AC1WFoCAA "APL (Dyalog Unicode) – Try It Online") - Tests for all valid inputs.
### How:
```
{⍵⍳⍨⍎¨((≠\=⍨)⊂⊢)∊⍕¨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
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 12 bytes
```
Ｉ⌕Ｉ⪪⭆φ×⁶⊕ι²Ｎ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sbhEwy0zLwXCCi7IyQSSJUC5dN/EAo00HYWQzNzUYg0zHQXPvOSi1NzUvJLUFI1MTU1NHQUjEOGZV1Ba4leam5RapAEU1bT@/9/gv25ZDgA "Charcoal – Try It Online") Link is to verbose version of code. 0-indexed. Explanation:
```
     φ           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
```
[Answer]
# [J](http://jsoftware.com/), ~~29~~ 26 bytes
-3 bytes thanks to FrownyFrog! 
```
i.~_2(".\;)6<@":@*1+i.@325
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/M/Xq4o00lPRirDXNbByUrBy0DLUz9RyMjUz/a3IpcKUmZ@QraFgrGSikaWbqGRn8BwA "J – Try It Online")
0-based
[Answer]
# [Python 3](https://docs.python.org/3/), ~~87~~ 81 Bytes:
```
lambda n:[*zip(*[iter(''.join(map(str,range(6,1951,6))))]*2)].index((*'%02d'%n,))
```
integer input, 0-indexed output.
[Try it online!](https://tio.run/##LctBCoMwEADAr/Qi2SxBEqVChb5EPUQS7Za6hjQH9fOpBec@YU@vles8Pfv8scvo7I3bDg8KgB0lH0GI8r0Sw2IDfFNU0fLsoVHmcTeqkacBKzmUxM5vACgKXTlRsJIyh0icAP91uqLR@iz5Bw)
---
-6 bytes, thanks to @TFeld.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 74 bytes
```
#&@@Position[FromDigits/@Flatten@IntegerDigits[6Range@365]~Partition~2,#]&
```
[Try it online!](https://tio.run/##JcuxCsIwEAbghwl0UgqKhQ7KDVJwi64hwyHXeGAukP6uffUodv3gy4yXZIY@uc3n5joiXxaFFgtTLfmqSbH0NL0ZEKObQZLUjcPwYEtCx@EUV88V/7cedi527f5RQfBVDcHtLzP9sKctjGNsXw "Wolfram Language (Mathematica) – Try It Online")
2 bytes saved from @Expired Data
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 14 bytes
```
;İS∧⟦×₆ᵐcġ₂iSt
```
[Try it online!](https://tio.run/##AS0A0v9icmFjaHlsb2cy//87xLBT4oin4p@mw5figobhtZBjxKHigoJpU3T//zEw/1o "Brachylog – Try It Online")
Too slow for test cases with larger outputs.
[Answer]
# [R](https://www.r-project.org/), ~~75~~ 62 bytes
-13 bytes thanks to Giuseppe.
```
match(scan(,''),substring(Reduce(paste0,3*(a=2*1:999)),a-1,a))
```
[Try it online!](https://tio.run/##K/r/PzexJDlDozg5MU9DR11dU6e4NKm4pCgzL10jKDWlNDlVoyCxuCTVQMdYSyPR1kjL0MrS0lJTUydR11AnUVPzv7n5fwA "R – Try It Online")
[Answer]
# x86-16 machine code, ~~54~~ 53 bytes
```
00000000: bde5 032b e58b fc57 9633 c0b9 2701 0506  ...+...W.3..'...
00000010: 0050 e80d 0058 e2f6 965f 49f2 aff7 d103  .P...X..._I.....
00000020: e5c3 bb0a 0052 33d2 f7f3 85c0 7403 e8f4  .....R3.....t...
00000030: ff92 aa5a c3                             ...Z.
```
**Listing:**
```
BD 03E5     MOV   BP, 997       ; digits list buffer size
2B E5       SUB   SP, BP        ; allocate from stack
8B FC       MOV   DI, SP        ; DI = start of digits buffer 
50          PUSH  AX            ; save input value
57          PUSH  DI            ; save buffer offset
33 C0       XOR   AX, AX        ; counter in AX = 0 
B9 0127     MOV   CX, 295       ; generate 295*6 multiples 
        SIX_LOOP: 
05 0006     ADD   AX, 6         ; increment counter by 6 
50          PUSH  AX            ; save AX (clobbered by OUT_DECU) 
E8 000D     CALL  OUT_DECU      ; write AX to BCD at ES:DI 
58          POP   AX 
E2 F6       LOOP  SIX_LOOP      ; loop 295 times 
5F          POP   DI            ; restore start of output buffer 
58          POP   AX            ; restore input number 
49          DEC   CX            ; loop count FFFFh (solution guaranteed)
F2 AF       REPNZ SCASW         ; search for input value
F7 D1       NOT   CX            ; ones complement sign without increment
03 E5       ADD   SP, BP        ; restore stack pointer
C3          RET 
        OUT_DECU:               ; divide unsigned word AX into base 10
                                ;  decimal digits to buffer at ES:DI
BB 000A     MOV   BX, 10        ; decimal divisor = 10 
        OUT_DECU_R: 
52          PUSH  DX            ; save remainder digit / caller DX 
33 D2       XOR   DX, DX        ; clear high word of dividend 
F7 F3       DIV   BX            ; AX = DX:AX / 10, DX = DX:AX % 10 
85 C0       TEST  AX, AX        ; is zero? 
74 03       JZ    OUT_DECU_DONE ; loop while AX > 0 
E8 FFF4     CALL  OUT_DECU_R    ; recursive call to next division
        OUT_DECU_DONE: 
92          XCHG  AX, DX        ; AL = digit 
AA          STOSB               ; write to digits list
5A          POP   DX            ; restore digit 
C3          RET
```
Callable function, input value as little endian BCD in `AX`. Output 1-based index in `CX`.
The easy approach... generate the entire list and search it.
Note: I found experimentally that `295*6` is sufficient to generate needed values: `295*6 = 1770` of which the `77` is the value for the highest index (497 or 498). This would produce a string 997 digits long.
**Tests:**
[![enter image description here](https://i.stack.imgur.com/FjNUA.png)](https://i.stack.imgur.com/FjNUA.png)
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 10 bytes
```
•╒6*y░2/i=
```
[Try it online!](https://tio.run/##FZJNapZBEIT3dYoiSzfOdPf8LQLeRCRoFNRACIhIwCso6AG8iOBRcpH4fJuefmequ6ur3k9vHt7f3n189/z89P3P06@f88XXp98/4uWH6@fXr67//f125Zu7@/u3Nw9Xj@Rf7u8@3149PjdHdXVHV7hPpUvlMzXcY2r6aLmvru1oXce91Bs36hQtjuBBPR2pXu5HfTiI0xnqixzQdg7149yKZiZGNyFcU5GeR1EmHR6pmI5QMBfI9iQ/EDzK5jmU3XMrw7DK9CpluXgdDFnK6d2UyzuVsKbgeB9V8wnVhbWKweTpVMGZxYp9G6tTrLpsDGhDoKnYOTUQamvAGh4DqWA4EAshRnlxdxEMxATdNWiRpbE9hsZx5dJEtmqa3YQwqAn7oVkmXMq5Z35oUk3O/AmI@bO0msfW6i6oLQisppUcqVVm1qIDPBYEaLEWkgDc3kOLFntrQ@DgJEvwgW/aECDF8NQeXtq4RmQ@Em8IgEF7FjvNtDiXP4WDYv6Yg@tROlhHxDvkP5iXTQfjM3W2WfnQIs9/ "MathGolf – Try It Online")
Basically the same as the 05AB1E answer, but I lose a byte by having to convert the concatenated number to string explicitly. 
## Explanation
```
•╒             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
```
[Answer]
# APL+WIN, 37 bytes
Prompts for input of integer. 1 indexed.
```
↑(⎕=⍎,((n,2)⍴(⍕6×⍳n)~' '),' ')/⍳n←600
```
[Try it online! Coutesy of Dyalog Classic](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob6qvz6O2CcZcjzra0/4/apuoARSyfdTbp6OhkadjpPmod4vGo96pZoenP@rdnKdZp66grqkDIvRBfKBOMwOD/0C9/9O4zAy50rgMgNjSFERYAgA "APL (Dyalog Classic) – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~123 bytes~~ 115 bytes
```
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);
```
[Try it online!](https://tio.run/##VcqxDoIwEIDh3acgTndQGySGBdtNBuNgZHAu5CCX0Jq0xcjTVxInh3/58g/hMARO7eKGM7sotnQ2qmSUtrJlHyKsSm8q78YHghA9u0leX@xgvxdWdjTTEAE@glHpouC8RpTd0v9OWPNKVIhKGWzexmdWXdxiyZt@JvkwbiIoRX0qsUm7p@dIN3YEI9RHxOZPqnKT9AU "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 22 bytes
**Solution:**
```
(.:'0N 2#,/$6*1+!999)?
```
[Try it online!](https://tio.run/##y9bNz/7/X0PPSt3AT8FIWUdfxUzLUFvR0tJS097S8v9/AA "K (oK) – Try It Online")
**Explanation:**
0-indexed.
```
(.:'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
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 bytes
```
ȷ×€6DFs2Ḍi
```
[Try it online!](https://tio.run/##y0rNyan8///E9sPTHzWtMXNxKzZ6uKMn87@hgcHDHduO7jncDhRWcf8PAA "Jelly – Try It Online")
TIO link gives all values for 0 to 99. 
### Explanation
```
ȷ          | 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
```
[Answer]
# Java 10, ~~119~~ ~~104~~ 102 bytes
```
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;}
```
Port of [*@TFeld*'s Python 2 answer](https://codegolf.stackexchange.com/a/186890/52210).  
-2 bytes thanks to *@Imus*.
1-indexed.
[Try it online.](https://tio.run/##TY9NbsIwEIX3nGJqqZJdN6mTBYua9AZlw7LtwgSDBoJDPXakCqVXT@3Aops3mp@n983RDKY47k5T2xkieDforgsAdMH6vWktrHM7D6DlWZ3QaTIuklAwAVtYg4NmcsXbNe@xqfW@93wwHqhhy6pm@oFKilsKHt2Bq@dalPY7mo44Y9K9VEq6x0oJLaj5f1gLuXySErW3IXr3W6AeJ52DL3HbpeB7/tDjDs6JnG9m48cXGHHDziA3KKUBV5XKRUoxLwE2PxTsuexjKC/JGTrHUbLXz5CwyvSuuP86Tn8)
**Explanation:**
```
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
```
---
**Original ~~119~~ 117 bytes version:**
```
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-indexed.
[Try it online.](https://tio.run/##TY8xT8QwDIX3@xVWJKRE0YUWJAbSgJhY4Bhu5BhCmyKXXlolbsXp1N9e0nIDiy0/23rfa@xot031PZetjRFeLfrzBgA9uVDb0sFuGVcBSr5UL3RSpk0qkSxhCTvwYGa/fTiPNkA0jOm6C@sxmkxjceNutYjSoDR3OjgagocmGauBsFVPIdhTVDa@YCQeVexbJM74Y2EOh2elBBNCoa/cz1vNGZP@Os@kv8ozoadZLxz98NkmjgvO2GEFxxSE7ymg/3r/ACv@UvzHAizybGlSinUJsD9FckfVDaT69Emt5yjZ/YGSqUrpxSX6NP8C)
**Explanation:**
```
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
```
[Answer]
# [PHP](https://php.net/), 58 bytes
```
<?=array_search($argn,str_split(join(range(6,1950,6)),2));
```
[Try it online!](https://tio.run/##K8go@P/fxt42sagosTK@ODWxKDlDQyWxKD1Pp7ikKL64ICezRCMrPzNPoygxLz1Vw0zH0NLUQMdMU1PHSFPT@v9/U4N/@QUlmfl5xf913QA "PHP – Try It Online")
Input is 0-based via `STDIN`.
```
$ echo 0|php -F sixers.php
241
$ echo 50|php -F sixers.php
131
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 17 bytes
```
325,:)6f*s2/:~ri#
```
[Try it online!](https://tio.run/##S85KzP3/39jIVMdK0yxNq9hI36quKFP5/39LSwA "CJam – Try It Online")
0-based.
### Explanation
```
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
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 12 bytes
0-indexed.
```
L²õ*6 ¬ò b¥U
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=TLL1KjYgrPIgYqVV&input=NjE) or [test all inputs](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=TLL1KjYgrPIgYqVV&input=MTAwCi1t)
```
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)
```
[Answer]
# [Red](http://www.red-lang.org), ~~97~~ 94 bytes
```
func[n][(index? find/skip rejoin collect[repeat i 325[keep i * 6]]pad/left/with n 2 #"0"2)/ 2]
```
[Try it online!](https://tio.run/##PcuxCsIwFEbh3af4iYsKkjaiQxffwfVyh5Lc4LUlDTGibx@Lg9P5llMktJsE4k0cWnwlT4lppynI54q41j4nzSjyWDTBL/MsvlKRLGOF4uTONInklQdcmPMY7Cyx2rfWOxIctqYzbm/huP2vvutAuWiqIMURPcxgEPEzc/sC "Red – Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 11 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
Æ▒§±~>ûπ╞öt
```
[Run and debug it](https://staxlang.xyz/#p=92b115f17e3e96e3c69474&i=0%0A99&a=1&m=2)
Input is an integer. Output is 0-indexed.
[Answer]
# [Perl 5](https://www.perl.org/) `-MList::Util=any -ap`, 50 bytes
```
$\=0,$b.=6*++$,while!any{++$\;"@F"==$_}$b=~/../g}{
```
[Try it online!](https://tio.run/##K0gtyjH9/18lxtZARyVJz9ZMS1tbRac8IzMnVTExr7IayIuxVnJwU7K1VYmvVUmyrdPX09NPr63@/9/oX35BSWZ@XvF/XV9TPQNDAyDtk1lcYmUVWpKZYwvU/V83sQAA "Perl 5 – Try It Online")
1-based output
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~83~~ 77 bytes
I am really out of practice at complicated programming in Retina, but I'm satisfied with the length I managed to do it in.
Outputs the 0-indexed result.
```
.+
6*1
325+-1%`1+
$0¶6*1$0
1+
$.0
¶
L`..
m`^0
$
¶$+
s`\b(\d+)\b.*\b\1$
C`¶
```
[**Try it Online**](https://tio.run/##JcixDYNADAXQ/s9hJMDCOoOAAWgzghU5JygooCCZ7Qa4xQ6kvPJd228/P1qKMKZWMfQj151WrgwKOT1HAU3X/0cCcgJeLoLD3wGgJ4jxdYu1rdxYlNaiKQGL51TKrDc "Retina – Try It Online")
---
### Explanation
```
.+                   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
```
[Answer]
# [Swift 5/Xcode 10.2.1](https://developer.apple.com/swift/), ~~140~~ ~~134~~ 133 bytes
```
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
```
[Try it online!](https://tio.run/##lZjNbtNAFIX3fQojlcoWwtjzP0VmidQVizxBlTqVUXGD7YhClGcPSe7Nvt@qqpKTa5/55sy9M/8ZNos7bnbjutgM07z8WK9309SP6/5hXA1v/TSv@t@78//leF88jEtVfP52/lvsjy/9UszdfP38or8P1f62@RQO9cvjv7/1r8ftfrVMw/hc3jbVof75Ooz9U1l9nfplN41lU9d1VV@UJ9lH03XN3d3p10sVzfXT9Lr9fv78/AP1duo3w1tpqqrquvHw4Ys5Hm5utqfvLuU7nr@piq4rjGur92ta0RCJuUjaACT2InFA4S6KTIp4eS5DNEHKAEWUKpE4lsTkhmiy1CGetY0@G9EoABGJjL4Q0QgDxhKNUNCS9WkFA4M0goE1RBO1DjJOSLCeaIQEm8gWFRJQEhghAUmEA0d2nBEOAlkfIxygMoKBJ7gZwcAQDIzmAbJNKAioTtagJr5ZwSAQ3KxgEAhuVjhAmWiFg0gCzgoHDnngdcuRfWqFhEQCzgoJiRBn9WRACyQkJGKCExAyIc5dTwai0UBAdQQEYpvTcwEdqE77gwa1IQoCkVw7BGRc0hghxDntEYh1XptE8kZeTwaUPV7bRJSmXhtF1MJ4oSGip7s2i8iHoH4T7LziYAl2XnDwJBe80OAs8S5oy@gId0F4QBKhATkX9IQgJgRhAUmuKKD30VwgcAclAdXRXAjIOM2FQJCLQoInGyIKCA5FXdRgiMSHaFVEsi4KDGjnRaUBpUnUYEA4xKjNDDJPeEgE8Kg4JLK0SYMhozlXDwpUSGdJItFgQGX0QoHwk4QFsj5JJ0mk0VxALXfSYEC@6QyBDr0sICB48vVWCYkUBHQXlfVWwZA9nnWcRBqdJ9EYkXWgtCTqsl4sWIJqFhzQMZ4Vh9NAcfwP "Swift – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 36 bytes
```
^
2406$*_
_{6}
$.`
^0(..)+?.*\1$
$#1
```
[Try it online!](https://tio.run/##K0otycxL/M9laamixWXIdWiboYpeApeqhnvC/zguIxMDMxWteK74arNaLpB4nIGGnp6mtr2eVoyhCpeKsuH//wA "Retina 0.8.2 – Try It Online") Link includes test suite. 1-indexed. Explanation:
```
^
2406$*_
```
Prefix 2406 `_`s to the input.
```
_{6}
$.`
```
Replace every 6 `_`s with the number of preceding `_`s. This generates the sequence `0`, `6`, `12` ... `2400`, but automatically concatenates the numbers.
```
^0(..)+?.*\1$
```
Skip the leading 0 and find the first pair of digits that match the last two digits i.e. the zero-padded input (because the string ends in `0`; in fact the test suite uses the fact that it ends in `00`).
```
$#1
```
Output the number of pairs of digits up to and including the match.
Retina 1 saves a couple of bytes because its string repetition operator is a byte shorter and already defaults to `_` as its right-hand operand, so that the second line of code becomes just `2406*`. Another feature of Retina 1 is the `>` modifier which generates the substitution in the context of the separator after the match, which in the case of `$.>`` causes it to include the length of the match in the result. Although this costs a byte we save it immediately as we don't need to match the `0` any more. (The repetitions also have to be reduced by 6.) Retina 1 can also do basic arithmetic in a substitution. This means that we don't have to resort to tricks to take multiples of 6, instead we just generate the numbers `1..400` and multiply by 6 in the substitution. Remarkably, this also doesn't affect the overall byte count, as the final result looks like this:
```
^
400*
_
$.(6*$>`
^(..)+?.*\1$
$#1
```
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 80 bytes
1-indexed.
```
dc<<<6[p6+lax]salax|sed 's/./\n&/g;s/\n//'|sed 'N;s/\n//'|sed -n "/^0*$1$/{=;q}"
```
[Try it online!](https://tio.run/##S0oszvj/PyXZxsbGLLrATDsnsSK2OBFI1hSnpiioF@vr6cfkqemnWxcDaX19dYiwHwpXN09BST/OQEvFUEW/2ta6sFbp////lhYA "Bash – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 88 bytes
```
n=>{int i=2;for(var s="612";!s.StartsWith($"{n:d2}");s=s.Substring(2)+6*++i);return~-i;}
```
[Try it online!](https://tio.run/##JYyxDoIwFEV3vqI2Dq0VAx0YeJTRyc2BGRH0Lc@kr3Uh@Ou1xuHcnOQmZ@JyYkznSFOHFI6ZfnGJXL9mFegsLC@v3qMX7GRTWwk7Pl3D6AMPGJ5qL1dq73aTGtjlJ944eKSHsto0B2NQg59D9PQpEbYExS/3T1eAXV3lNUYXQgwew3xBmhUa2Qpp1KJQaw3pCw "C# (Visual C# Interactive Compiler) – Try It Online")
Another port of the [Java](https://codegolf.stackexchange.com/a/186887/8340) and [Python](https://codegolf.stackexchange.com/a/186890/8340) answers.
My original answer below:
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 102 bytes
```
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;}
```
[Try it online!](https://tio.run/##RYwxD4IwFIR3fkVtHFqLsRDiwKOMTu4OhMEUSN7gM2nLYJDfXguLww13391Zf7Ye420m2yCFPKmdTCTTLsOHni@0zBvO82COfKF6KFeeo9EwvZ0AVKqptAavDJ6ucg836LtE@oMJne6/f1P0IMGNYXbE8FLCGiHbJxTYNsOmSGepLTPGHg7DeEcaBSpeM67EJFBKCfEH "C# (Visual C# Interactive Compiler) – Try It Online")
Both solutions use 1-based indexing.
]