Intercambia la secuencia

9

Su tarea es escribir un código que genere una secuencia OEIS y que contenga el nombre de la secuencia en el código ( A______). Bastante fácil ¿verdad? Bueno, aquí está el truco, su código también debe generar una segunda secuencia separada cuando el nombre de la secuencia en el código se cambia por el nombre de la segunda secuencia.

De entrada y salida

El código puede ser una función o programa completo que lleva n a través de un método de entrada estándar y da salida a la n º término de la secuencia como indexado por el índice proporcionada en la página OEIS.

Debe admitir todos los valores proporcionados en los archivos b de OEIS para esa secuencia, no es necesario que sea compatible con cualquier número que no esté en los archivos b.

Puntuación

Este es el código de golf . Su puntaje será el número de bytes en su código, con menos bytes mejor.

Ejemplo

Aquí hay un ejemplo en Haskell que funciona para A000217 y A000290.

f x|last"A000217"=='0'=x^2|1>0=sum[1..x]

Pruébalo en línea!

code-golf  sequence 
— Ad Hoc Garf Hunter
fuente
Para aclarar: ¿Su código debería funcionar para dos secuencias donde poner el nombre de la secuencia en esa parte del código generará el número de esa secuencia?
— HyperNeutrino
@HyperNeutrino Sí. Cuando se sustituye el nombre de la secuencia, debe cambiar la función del programa para que sea la segunda secuencia.
— Ad Hoc Garf Hunter
1
¿Las secuencias en el código tienen que tener ceros a la izquierda?
— pppery
@ppperry Sí, debería.
— Ad Hoc Garf Hunter
1
Es el Arequerido?
— Okx

Respuestas:

8

JavaScript (ES6), 16 15 bytes

n=>4&~0xA000004

Funciona con A000004 (todos los 0s) y A010709 (todos los 4s).

La solución anterior de 17 bytes funciona con A010850 a A010859 inclusive:

n=>~-0xA010850%36

La solución anterior de 25 bytes funciona con A010850 a A010871 inclusive:

n=>"A010850".slice(5)-39
— Neil
fuente
Esto se está presumiendo (no conozco OEIS lo suficientemente bien como para ver cuán inteligente es esto: P)
— TheLethalCoder
Extraño: dos respuestas comenzaron con 25 bytes y ambas jugaron golf a 17 bytes en un minuto
— pppery
@ppperry Heh, pero podría transferir tu respuesta y sería solo 15 bytes ...
— Neil
¿JS atado con Jelly ? Muy bien hecho
— Shaggy
@Shaggy Nope; Se publicó una nueva respuesta de jalea más corta.
— pppery
3

cQuents , 16 bytes

=A000007//5#|A:0

Pruébalo en línea! , A000007 ,1,0,0,0,0...

=A000004//5#|A:0

Pruébalo en línea! , A000004 ,0,0,0,0,0...

Explicación

                    Implicit input A
=A000007            First item in the sequence equals A * 7
        //5                                                 intdiv 5 = 1
           #|A      n equals A
              :     Mode : (sequence): output nth item (1-based)
               0    Rest of the sequence is 0


                    Implicit input A
=A000004            First item in the sequence equals A * 4
        //5                                                 intdiv 5 = 0
           #|A      n equals A
              :     Mode : (sequence): output nth item (1-based)
               0    Rest of the sequence is 0

Gracias a Conor O'Brien por 4//5 = 0 y 7//5 = 1.

Si la especificación fuera más flexible, sería O7A$y O4A$.

— Stephen
fuente
2

cc , 13 bytes

Editar: Aparentemente, OEIS enumera los poderes de 0th a 30th: acabo de hacer una búsqueda en estas secuencias y resulta que la 13solución de byte original es la más elegante. Pero encontré otra solución para un 1byte más que funciona para9 secuencias.

Solución para A000012 (secuencia constante de 1):

?A000012 4%^p

Pruébalo en línea!

Solución para A001477 (enteros no negativos):

?A001477 4%^p

Pruébalo en línea!

Solución para A000290 (secuencia de cuadrados perfectos):

?A000290 4%^p

Pruébalo en línea!

Ungolfed / Explicación

Estas soluciones hacen uso del hecho de que dcinterpreta Acomo 10, por lo que se A001477convierte en el valor 10001477. Además explota que las secuencias son n^0, n^1y n^2que coincide con 10000012 % 4 == 0, 10001477 % 4 == 1y10000290 % 4 == 2 .

Entonces estas secuencias son xyz(n) = n ^ (xyz % 4).

Command          Description          Example (3) 
?              # Push the input       [3]
 A000290       # Push sequence name   [3,10000290]
         4%    # Top %= 4             [3,2]
           ^   # Pop x,y & push y^x   [9]
            p  # Print the top        [9]

Solución de 14 bytes para 9 secuencias

La idea sigue siendo la misma, esta vez necesitamos hacer una % 97, para obtener la potencia correcta: funciona para las secuencias A010801 , A010802 , A010803 , A010804 , A010805 , A010806 , A010807 , A010808 y A010809 (estas son las secuencias n^13, .. ., n^21).

Aquí está el primero:

?A010801 97%^p

Pruébalo en línea!

— ბიმო
fuente
1
¡+1 por admitir más de dos secuencias!
— Neil
1

Python 2, 25 17 bytes

print'A000012'[5]

Funciona para A000004 y A000012. (la entrada se ignora porque todas las secuencias son términos constantes).

— pppery
fuente
1

Befunge 98, 10 bytes

#A000012$q

También funciona para A000004. Salida por código de salida.

— pppery
fuente
1

Jalea , 17 bytes

“A000578”OS%⁵ạ6*@

Pruébalo en línea!

“A000578”OS%⁵ạ6*@  Main link
“A000578”          String
         O         Codepoints
          S        Sum (364 for A000290, 373 for A000578)
           %⁵      Modulo 10 (4 for A000290, 3 for A000578)
             ạ6    Absolute Difference with 6 (2 for A000290, 3 for A000578)
               *@  [left argument] ** [result of last link (right argument)]

También funciona con A000290

— Hiperneutrino
fuente
Buen trabajo usando secuencias no constantes.
— AdmBorkBork
1

PowerShell , 23 bytes

+(0xA000012-eq160mb+18)

Pruébalo en línea!

Utiliza A000012 (la secuencia de todos) y A000004 (la secuencia de todos los ceros).

Aprovecha varios trucos geniales. Usamos 0xcomo operador hexadecimal en la secuencia que nos da 167772178. Eso se compara para ver si es -equal al 160mb+18uso del mboperador ( 160mbis 167772160). Ese resultado booleano se convierte entonces como un int con el +resultado correcto 1o 0. Tenga en cuenta que cualquier secuencia en el código que no sea A000012 dará como resultado la 0salida.

— AdmBorkBork
fuente
1

Neim , 10 9 bytes

A000012ᛄ>

Explicación:

A            Push 42
 000012      Push 4
 or
 A007395     Push 7395
        ᛄ     Modulo 2
         >    Increment

A000012 (todos unos) y A007395 (todos dos)

Una función que toma la entrada en la parte superior de la pila y deja la salida en la parte superior de la pila.

Pruébalo en línea!

— Okx
fuente
0

Gaia , 9 bytes

A000012₉/

Funciona con A000012 y A000004 .

¡Prueba A000012!

¡Prueba A000004!

Explicación

A          Undefined (ignored)
 000012    Push 12
       ₉   Push 9
        /  Integer division, results in 1



A          Undefined (ignored)
 000004    Push 4
       ₉   Push 9
        /  Integer division, results in 0
— Gato de negocios
fuente
¿Por qué todos siguen publicando A00004 y A00012?
— pppery
@ppperry A000004 es la secuencia cero y A000012 es la secuencia de las unidades. Simplemente divida los números entre 9 y emita el resultado para siempre.
— Engineer Toast
0

Casco , 20 bytes

Este devuelve secuencias un poco más interesantes, nuevamente las soluciones están 1indexadas.

Esto funciona para A000040 (los números primos):

!!i→"A000040"e:0İfİp

Pruébalo en línea!

Y este para A000045 (los números de Fibonacci):

!!i→"A000045"e:0İfİp

Pruébalo en línea!

Explicación

Esto hace uso del hecho de que el último dígito de los nombres de secuencia tiene una paridad diferente:

                      -- implicit input N
             e        -- construct a list with:
              :0İf    --   list of Fibonacci numbers (prepend 0)
                  İp  --   list of the prime numbers
  i→"Axxxxx?"         -- get the last character and convert to number,
 !                    -- use it as modular index (0 -> primes, 5 -> Fibonacci)
!                     -- get the value at the Nth index
— ბიმო
fuente
0

AHK , 40 bytes

a:=SubStr("A000004",6)//9
Loop
Send %a%,

Salida: 0,0,0,0,0,0,0,0,0,0,0,0,...

a:=SubStr("A000012",6)//9
Loop
Send %a%,

Salida: 1,1,1,1,1,1,1,1,1,1,1,1,...

Puede que este no sea el código más corto, pero apuesto a que es el par de secuencia más corto que podemos encontrar. A000004 es la secuencia cero y A000012 es la secuencia de las unidades . Simplemente divida los números entre 9 y emita el resultado para siempre.

— Tostadas de ingeniero
fuente
0

QBIC , 28 bytes

p=!_s@A000035`,-1|!?:%2+5-p

Esto cambia entre las secuencias A000034 (1, 2, 1, 2, 1 ...) y A000035 (0, 1, 0, 1, 0, 1 ...)

Explicación

p=                  Set p to 
  !            !    A numeric representation of
   _s         |     a substring of
     @A000035`      our sequence code (either A0035 or A0034)
     ,-1            taking just one character from the right.
?:%2                PRINT <n> MOD 2 (gives us a either 0 or 1)
    +5-p            Plus 1 for seq A24 (5-4), or plus 0 for A35
— Steenbergh
fuente
0

Casco , 16 bytes

Ambas soluciones están 1indexadas.

Esto funciona para A000351 (potencias de 5):

!¡*i!6"A000351"1

Pruébalo en línea!

Y este para A000007 (potencias de 0):

!¡*i!6"A000007"1

Pruébalo en línea!

Explicación

Hace uso de que los nombres A000351 , A000007 contienen el dígito derecho D en la posición 6, de modo que la secuencia es D^0,D^1,D^2,...:

                  -- implicit input N
   i!6"AxxxxDx"   -- get the right digit D and convert to number,
 ¡*            1  -- iterate (D*) infinitely beginning with 1,
!                 -- extract the value at Nth position
— ბიმო
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.