Primeira ocorrência na sequência de Sixers

17

A sequência de Sixers é um nome que pode ser atribuído à sequência A087409 . Eu aprendi sobre essa sequência em um vídeo do Numberphile e ela pode ser construída da seguinte maneira:

Primeiro, pegue os múltiplos de 6, escritos na base 10:

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

Em seguida, concatene os números em um fluxo de dígitos:

61218243036...

Por fim, reagrupe o fluxo em pares e interprete cada um como um número inteiro:

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

À medida que agrupamos os números em pares, o número máximo na sequência será 99, e todos os números inteiros não negativos menores que 100 são representados na sequência. Esse desafio é encontrar o índice da primeira instância de um número na sequência de Sixers.

Entrada

Um número inteiro no intervalo [0-99]. Você não precisa contabilizar números fora desse intervalo e sua solução pode ter algum comportamento se essa entrada for fornecida.

Resultado

O índice da primeira ocorrência do número de entrada na sequência de Sixers. Isso pode ser indexado em 0 ou 1; diga o que você está usando em sua resposta.

Regras

  • O procedimento para gerar a sequência observada na introdução é apenas para fins ilustrativos. Você pode usar qualquer método que desejar, desde que os resultados sejam os mesmos.
  • Você pode enviar programas ou funções completos.
  • Quaisquer métodos sensíveis de entrada e saída são permitidos.
  • As brechas padrão não são permitidas.
  • Links para testar seu código online são recomendados!
  • Isso é código-golfe , então a resposta mais curta em cada idioma vence!

Casos de teste

Aqui está uma lista de todas as entradas e saídas, no formato 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
fonte
6
Pode ser útil saber que considerar 6, 2*6, 3*6,..., 325*6é suficiente para gerar todos os valores possíveis
— Luis Mendo
@LuisMendo Você está certo, eu estava debatendo se deveria incluir isso na descrição do desafio. Um comentário também é um bom local para isso: o)
— Sok
Podemos tomar o input-inteiro como corda, com os acolchoado com um 0 (ou seja , , , ...)? n<10000102
— Kevin Cruijssen 14/06
10
@KevinCruijssen Hmmm, a entrada como uma string é boa, mas o preenchimento esquerdo com 0 é um IMO um pouco distante demais.
— Sok

Respostas:

12

JavaScript (ES6),  71 65  55 bytes

A saída é indexada em 0.

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

Experimente online!

Quão?

Usando uma função recursiva, 'consumimos' os 2 primeiros caracteres da sequência de múltiplos concatenados de 6 ou acrescentamos novos caracteres se tivermos menos de 2 deles.

Exemplo para 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

Comentado

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
fonte
12

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

Experimente online!

  • -2 bytes, graças ao Grimy
  • -3 bytes, graças ao ArBo
  • -6 bytes, graças ao xnor
— TFeld
fonte
1
3 bytes mais curtos como um lambda:f=lambda n,s='612',i=3:n-int(s[:2])and f(n,s[2:]+`i*6`,i+1)or i-2
— ArBo 14/06
@ArBo Ainda melhor, f=lambda n,s='612',i=18:n-int(s[:2])and-~f(n,s[2:]+`i`,i+6)(indexado 0).
— xnor 15/06
8

Perl 6 , 31 bytes

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

Experimente online!

Usa a sequência indexada em 1.

Explicação:

{                            } # 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
— Brincadeira
fonte
5

05AB1E , 9 bytes

₄L6*J2ôIk

Indexado a 0. Aceita um único número inteiro ou uma lista de números inteiros como entrada.

Experimente online ou verifique todos os casos de teste .

Explicação:

₄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)
— Kevin Cruijssen
fonte
O comportamento padrão é associar como sequência ou existem operadores separados para ingressar como sequência e ingressar como número?
— maxb 14/06
@maxb No geral, o 05AB1E não precisa de conversões explícitas. Todos os números inteiros também podem ser usados ​​para funções de string, como substituir ou dividir, e todas as strings criadas (que são números inteiros) também podem ser usadas como números. Assim 100, "100"e 100.0são os mesmos para a maioria das funções como cheques iguais e tal. Ainda há conversão para int e conversão para funções de string em 05AB1E para algumas funcionalidades, como classificação (classificação numérica x lexicográfica) ou para remover dígitos decimais após a vírgula de um float ao converter para int, mas eles não são usados ​​com frequência .
— Kevin Cruijssen 14/06
@maxb Dica relevante 05AB1E, com alguns exemplos adicionais.
— Kevin Cruijssen 14/06
4

Carvão , 12 bytes

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

Experimente online! Link é a versão detalhada do código. Indexado a 0. Explicação:

     φ           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
— Neil
fonte
4

APL (Dyalog Unicode) , 26 bytes

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

Experimente online! - Testes para todas as entradas válidas.

Quão:

{⍵⍳⍨⍎¨((≠\=⍨)⊂⊢)∊⍕¨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
— J. Sallé
fonte
você pode remodelar o vetor achatado como em K? Google sugere, ⍴mas APL me assusta ...
— streetster 15/06
@ streetster sim, ⍴é a remodelação da APL. Então, se você deseja remodelar um vetor achatado, basta fazê-lo<new shape vector> ⍴ <vector to reshape>
— J. Sallé 17/06
então você pode usar a remodelagem para criar a lista 2xN e converter cada uma em número inteiro?
— streetster 17/06
Você poderia, mas acho que não seria mais curto do que minha resposta atual. Um problema seria que, para minha resposta, remodelar a string em uma matriz 1117 × 2 e depois converter para números inteiros criaria um vetor com 1117, números inteiros de um dígito. Veja a diferença entre o método que estou usando e a reformulação
— J. Sallé
Ah, minha corda achatada é remodelada para algo mais viável :)
— streetster 17/06
3

Python 3 , 87 81 bytes:

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

entrada inteira, saída indexada em 0.

Experimente online!

-6 bytes, graças a @TFeld.

— MrGeek
fonte
2

MathGolf , 10 bytes

•╒6*y░2/i=

Experimente online!

Basicamente, o mesmo que a resposta 05AB1E, mas perco um byte ao converter o número concatenado em string explicitamente.

Explicação

•╒             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
fonte
2

K (oK) , 22 bytes

Solução:

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

Experimente online!

Explicação:

Indexado a 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
— rua
fonte
2

Gelatina , 10 bytes

ȷ×€6DFs2Ḍi

Experimente online!

O link TIO fornece todos os valores de 0 a 99.

Explicação

ȷ          | 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
— Nick Kennedy
fonte
2

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

Porta da resposta Python 2 do @TFeld .
-2 bytes graças a @Imus .

1 indexado.

Experimente online.

Explicação:

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

Versão original de 117 117 bytes:

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

Indexado a 0.

Experimente online.

Explicação:

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
— Kevin Cruijssen
fonte
1
Você pode salvar 2 bytes usando "" + n / 10 + n% 10 em vez de n> 9? N + "": "0" + n
— Imus
1

CJam , 17 bytes

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

Experimente online!

Baseado em 0.

Explicação

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
— Luis Mendo
fonte
Por curiosidade, por que o CJam tem embutidos para todos os números inteiros no intervalo [10,20], bem como cinco componentes internos diferentes, todos padronizados para uma sequência vazia "", mas nenhum componente interno para100 ou 1000?
— Kevin Cruijssen 14/06
@KevinCruijssen Não tenho certeza ... Mas ter variáveis ​​com valores predefinidos como 0ou ""às vezes é útil para loops, porque esses geralmente são os valores iniciais desejados. Quanto a não ter 100ou 1000, sim, concordo que seriam mais úteis do que dizer 18ou19
— Luis Mendo
1
É uma pena que os zeros à esquerda sejam irritantes; caso contrário, você pode abandonar o código :~e io código. :(
— Erik the Outgolfer
1

Japonês , 12 bytes

Indexado a 0.

L²õ*6 ¬ò b¥U

Experimente ou teste todas as entradas

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)
— Shaggy
fonte
1

Retina , 83 77 bytes

Estou realmente sem prática em programação complicada na Retina, mas estou satisfeito com a extensão em que consegui fazê-lo.

Produz o resultado indexado em 0.

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

L`..
m`^0

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

C`¶

Experimente Online

Explicação

.+                   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
fonte
1

Retina 0.8.2 , 36 bytes

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

Experimente online! O link inclui o conjunto de testes. 1 indexado. Explicação:

^
2406$*_

Prefixe 2406 _s para a entrada.

_{6}
$.`

Substitua a cada 6 _s pelo número de _s anteriores . Isso gera a seqüência 0, 6, 12... 2400, mas concatena automaticamente os números.

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

Pule o 0 inicial e encontre o primeiro par de dígitos que corresponde aos dois últimos dígitos, ou seja, a entrada preenchida com zero (porque a sequência termina em 0 ; na verdade, a suíte de testes usa o fato de que termina em 00).

$#1

Emita o número de pares de dígitos até e incluindo a correspondência.

A Retina 1 salva alguns bytes porque seu operador de repetição de string é um byte mais curto e já é padronizado _como operando à direita, para que a segunda linha de código se torne justa 2406*. Outro recurso da Retina 1 é o >modificador que gera a substituição no contexto do separador após a partida, o que, no caso, $.>`faz com que inclua a duração da partida no resultado. Embora isso custe um byte, nós o salvamos imediatamente, pois não precisamos corresponder e multiplicar por 6 na substituição. Notavelmente, isso também não afeta a contagem geral de bytes, pois o resultado final se parece com o seguinte:0 . (As repetições também precisam ser reduzidas em 6). A retina 1 também pode fazer aritmética básica em uma substituição. Isso significa que não precisamos recorrer a truques para obter múltiplos de 6, apenas geramos os números1..400

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

Clojure, 102 bytes

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

Tanto tempo! :(

— NikoNyrh
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.