Primera aparición en la secuencia Sixers

17

La secuencia Sixers es un nombre que se puede asignar a la secuencia A087409 . Aprendí sobre esta secuencia en un video de Numberphile , y se puede construir de la siguiente manera:

Primero, tome los múltiplos de 6, escritos en la base 10:

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

A continuación, concatene los números en una secuencia de dígitos:

61218243036...

Finalmente, reagrupe la secuencia en pares e interprete cada uno como un entero:

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

A medida que agrupamos los números en pares, el número máximo en la secuencia será 99, y resulta que todos los enteros no negativos menores que 100 están representados en la secuencia. Este desafío es encontrar el índice de la primera instancia de un número en la secuencia Sixers.

Entrada

Un entero en el rango [0-99]. No es necesario que tenga en cuenta los números que están fuera de este rango, y su solución puede tener algún comportamiento si se proporciona dicha entrada.

Salida

El índice de la primera aparición del número de entrada en la secuencia Sixers. Esto puede ser 0 o 1 indexado; diga cuál está utilizando en su respuesta.

Reglas

  • El procedimiento para generar la secuencia anotada en la introducción es solo para fines ilustrativos, puede usar cualquier método que desee siempre que los resultados sean los mismos.
  • Puede enviar programas o funciones completos.
  • Se permiten todos los métodos razonables de entrada y salida.
  • Las lagunas estándar no están permitidas.
  • Se recomiendan enlaces para probar su código en línea.
  • Este es el código de golf , por lo que gana la respuesta más corta en cada idioma.

Casos de prueba

Aquí hay una lista de todas las entradas y salidas, en el 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
fuente
66
Puede ser útil saber que considerar 6, 2*6, 3*6,..., 325*6es suficiente para generar todos los valores posibles
— Luis Mendo
@LuisMendo Tienes razón, estaba debatiendo si incluir eso en la descripción del desafío. Un comentario también es un buen lugar para ello: o)
— Sok
Podemos tomar la entrada número entero como cadena, con los que acolchado con un 0 (es decir , , , ...)? n<10000102
— Kevin Cruijssen
10
@KevinCruijssen Hmmm, la entrada como una cadena está bien, pero el relleno izquierdo con 0 es un poco demasiado IMO.
— Sok

Respuestas:

12

JavaScript (ES6),  71 65  55 bytes

La salida está indexada en 0.

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

Pruébalo en línea!

¿Cómo?

Usando una función recursiva, 'consumimos' los primeros 2 caracteres de la cadena de múltiplos concatenados de 6 , o agregamos nuevos caracteres si tenemos menos de 2 de ellos.

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

Pruébalo en línea!

  • -2 bytes, gracias a Grimy
  • -3 bytes, gracias a ArBo
  • -6 bytes, gracias a xnor
— TFeld
fuente
1
3 bytes más cortos como 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
@ArBo Aún mejor, f=lambda n,s='612',i=18:n-int(s[:2])and-~f(n,s[2:]+`i`,i+6)(0 indexado).
— xnor
8

Perl 6 , 31 bytes

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

Pruébalo en línea!

Utiliza la secuencia indexada 1.

Explicación:

{                            } # 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
— Jo King
fuente
5

05AB1E , 9 bytes

₄L6*J2ôIk

0 indexado. Acepta un solo entero o una lista de enteros como entrada.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

₄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
fuente
¿El comportamiento predeterminado es unirse como una cadena o hay operadores separados para unirse como una cadena y unirse como un número?
— maxb
@maxb En general 05AB1E no necesita ninguna conversión explícita. Todos los enteros también se pueden usar para funciones de cadena como reemplazar o dividir, y todas las cadenas creadas (que son enteros) también se pueden usar como números. Entonces 100, "100"y 100.0son los mismos para la mayoría de las funciones como verificaciones iguales y tal. Todavía hay funciones de conversión a int y conversión a cadena en 05AB1E para algunas funcionalidades, como la ordenación (clasificación numérica frente a lexicográfica), o para eliminar dígitos decimales después de la coma de un flotante cuando se convierte a int, pero no se usan con tanta frecuencia .
— Kevin Cruijssen
@maxb Sugerencia relevante 05AB1E que da algunos ejemplos adicionales.
— Kevin Cruijssen
4

Carbón de leña , 12 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. 0 indexado. Explicación:

     φ           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
fuente
4

APL (Dyalog Unicode) , 26 bytes

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

Pruébalo en línea! - Pruebas para todas las entradas válidas.

Cómo:

{⍵⍳⍨⍎¨((≠\=⍨)⊂⊢)∊⍕¨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é
fuente
¿Puedes cambiar la forma del vector aplanado como puedes en K? Google sugiere ⍴, pero me da miedo ... APL
— streetster
@streetster sí, ⍴es la remodelación de APL. Entonces, si desea remodelar un vector aplanado, solo tiene que hacerlo<new shape vector> ⍴ <vector to reshape>
— J. Sallé
Entonces, ¿podría usar remodelar para crear la lista 2xN y luego convertir cada uno a entero?
— StreetSter
Podrías, pero no creo que sea más corto que mi respuesta actual. Un problema sería que, para mi respuesta, remodelar la cadena en una matriz de 1117 × 2 y luego convertirla a enteros crearía un vector con 1117 enteros de un dígito. Vea la diferencia entre el método que estoy usando versus la remodelación
— J. Sallé
Ah, mi cuerda aplanada se reconfigura en algo más viable :)
— callejero
3

Python 3 , 87 81 Bytes:

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

entrada entera, salida indexada 0.

Pruébalo en línea!

-6 bytes, gracias a @TFeld.

— MrGeek
fuente
2

MathGolf , 10 bytes

•╒6*y░2/i=

Pruébalo en línea!

Básicamente lo mismo que la respuesta 05AB1E, pero pierdo un byte al tener que convertir el número concatenado a una cadena explícitamente.

Explicación

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

K (oK) , 22 bytes

Solución:

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

Pruébalo en línea!

Explicación:

0 indexado.

(.:'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
— callejero
fuente
2

Jalea , 10 bytes

ȷ×€6DFs2Ḍi

Pruébalo en línea!

El enlace TIO proporciona todos los valores de 0 a 99.

Explicación

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

Puerto de la respuesta Python 2 de @TFeld .
-2 bytes gracias a @Imus .

1 indexado.

Pruébalo en línea.

Explicación:

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

Versión original de 119 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);}

0 indexado.

Pruébalo en línea.

Explicación:

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
fuente
1
Puede guardar 2 bytes utilizando "" + n / 10 + n% 10 en lugar de n> 9? N + "": "0" + n
— Imus
1

CJam , 17 bytes

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

Pruébalo en línea!

Basado en 0.

Explicación

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
fuente
Por curiosidad, ¿por qué CJam tiene incorporados para todos los enteros en el rango [10,20], así como cinco builtins diferentes que todos predeterminan en una cadena vacía "", pero no hay builtins para100 o 1000?
— Kevin Cruijssen
@KevinCruijssen No estoy seguro ... Pero tener variables con valores predefinidos como 0o a ""veces es útil para los bucles, porque esos son a menudo los valores iniciales deseados. En cuanto a no tener 100o 1000, sí, estoy de acuerdo en que serían más útiles que decir 18o19
— Luis Mendo
1
Es una pena que los ceros iniciales sean molestos, de lo contrario, podría deshacerse del código :~y ide él. :(
— Erik the Outgolfer
1

Japt , 12 bytes

0 indexado.

L²õ*6 ¬ò b¥U

Pruébalo o prueba todas las 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)
— Lanudo
fuente
1

Retina , 83 77 bytes

Realmente estoy fuera de práctica en programación complicada en Retina, pero estoy satisfecho con la duración en la que logré hacerlo.

Emite el resultado indexado a 0.

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

L`..
m`^0

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

C`¶

Pruébalo en línea

Explicación

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

Retina 0.8.2 , 36 bytes

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

Pruébalo en línea! El enlace incluye un conjunto de pruebas. 1 indexado. Explicación:

^
2406$*_

Prefijo 2406 _s a la entrada.

_{6}
$.`

Reemplazar cada 6 _ s con el número de _s anteriores . Esto genera la secuencia 0, 6, 12... 2400, pero concatena automáticamente los números.

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

Omita el 0 inicial y encuentre el primer par de dígitos que coincidan con los dos últimos dígitos, es decir, la entrada con relleno de cero (porque la cadena termina en 0; de hecho, el conjunto de pruebas utiliza el hecho de que termina en 00).

$#1

Imprime el número de pares de dígitos hasta e incluyendo la coincidencia.

La Retina 1 guarda un par de bytes porque su operador de repetición de cadena es un byte más corto y ya está predeterminado_ como su operando derecho, de modo que la segunda línea de código se vuelve justa 2406*. Otra característica de Retina 1 es el >modificador que genera la sustitución en el contexto del separador después del partido, que en el caso de$.>` que incluya la duración del partido en el resultado. Aunque esto cuesta un byte, lo guardamos inmediatamente ya que no necesitamos igualar0 . (Las repeticiones también deben reducirse en 6.) La retina 1 también puede hacer aritmética básica en una sustitución. Esto significa que no tenemos que recurrir a trucos para tomar múltiplos de 6, sino que solo generamos los números1..400y multiplicar por 6 en la sustitución. Sorprendentemente, esto tampoco afecta el recuento general de bytes, ya que el resultado final se ve así:

^
400*
_
$.(6*$>`
^(..)+?.*\1$
$#1
— Neil
fuente
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))

¡Hasta la vista! :(

— NikoNyrh
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.