서스 시퀀스는 시퀀스에 부여 할 수있는 이름입니다 A087409 . Numberphile 비디오 에서이 시퀀스에 대해 배웠으며 다음과 같이 구성 할 수 있습니다.

먼저 10의 기초로 작성된 6의 배수를 취하십시오.

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

다음으로 숫자를 일련의 숫자로 연결하십시오.

61218243036...

마지막으로 스트림을 쌍으로 다시 그룹화하고 각각을 정수로 해석하십시오.

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

숫자를 쌍으로 그룹화 할 때 시퀀스의 최대 숫자는 99가되고 100보다 작은 모든 음이 아닌 정수가 시퀀스에 표시됩니다. 이 과제는 Sixers 시퀀스에서 숫자의 첫 번째 인스턴스의 인덱스를 찾는 것입니다.

입력

범위의 정수입니다 [0-99]. 이 범위를 벗어난 숫자를 고려할 필요가 없으며, 그러한 입력이 제공되면 솔루션에 동작이있을 수 있습니다.

산출

Sixers 시퀀스에서 처음으로 입력 된 숫자의 색인입니다. 이것은 0 또는 1 색인 일 수 있습니다. 답에 어떤 것을 사용하고 있는지 말하십시오.

규칙

• 소개에 명시된 순서를 생성하는 절차는 설명 목적으로 만 사용되며 결과가 동일한 한 원하는 방법을 사용할 수 있습니다.
• 전체 프로그램 또는 기능을 제출할 수 있습니다.
• 합리적인 입력 및 출력 방법이 허용됩니다.
• 표준 허점은 허용되지 않습니다.
• 온라인으로 코드를 테스트하기위한 링크가 권장됩니다!
• 이것은 code-golf 이므로 각 언어에서 가장 짧은 답변이 이깁니다!

테스트 사례

다음은 형식의 모든 입력 및 출력 목록입니다 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

자바 스크립트 (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의 예 =$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)

파이썬 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)

온라인으로 사용해보십시오!

• Grimy 덕분에 -2 바이트
• ArBo 덕분에 -3 바이트
• xnor 덕분에 -6 바이트

펄 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

하스켈 , 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 바이트

FrownyFrog 덕분에 -3 바이트!

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

파이썬 3 , 87 81 바이트 :

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

정수 입력, 0 인덱스 출력.

온라인으로 사용해보십시오!

_{@TFeld 덕분에 -6 바이트}

Wolfram Language (Mathematica) , 74 바이트

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

온라인으로 사용해보십시오!

@Expired Data에서 2 바이트 저장

Brachylog , 14 바이트

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

온라인으로 사용해보십시오!

출력이 큰 테스트 케이스의 경우 너무 느립니다.

R , 75 62 바이트

주세페 덕분에 -13 바이트.

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 Classic의 쿠테시

C # (Visual C # Interactive Compiler) , 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

apt , 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 인덱스입니다.

펄 5 -MList::Util=any -ap , 50 바이트

$\=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 / 엑스 코드 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 _초 마다 이전 횟수로 교체하십시오 _. 이 시퀀스 생성 0, 6, 12... 2400,하지만 자동으로 번호를 연결합니다.

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

선행 0을 건너 뛰고 마지막 두 자리와 일치하는 첫 번째 숫자 쌍을 찾으십시오. 즉, 0으로 채워진 입력 (문자열이 끝나기 때문입니다 0. 실제로 테스트 스위트는에서 끝나는 사실을 사용합니다 00).

$#1

일치를 포함하여 최대 한 쌍의 자릿수를 출력합니다.

Retina 1은 문자열 반복 연산자가 바이트보다 짧고 이미 _오른쪽 피연산자로 기본 설정되어 있기 때문에 두 번째 바이트가 절약 됩니다 2406*. 레티 나 1의 다른 특징은 >일치 후 분리기의 맥락에서 치환을 생성 하는 변형 제이며, 치환의 경우에는$.>` 결과에 일치 길이를 포함시킵니다. 바이트 비용이 들지만 0더 이상 일치 할 필요가 없으므로 즉시 저장합니다 . (반복도 6으로 줄여야합니다.) Retina 1은 또한 대체에서 기본 산술을 수행 할 수 있습니다. 이것은 우리가 6의 배수를 취하는 트릭에 의지 할 필요가 없으며 대신 숫자를 생성한다는 것을 의미합니다1..400치환에 6을 곱합니다. 놀랍게도 최종 결과는 다음과 같이 전체 바이트 수에 영향을 미치지 않습니다.

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

배쉬 , 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}

온라인으로 사용해보십시오!

클로저, 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))

그럼 또! :(