Troque a sequência

9

Sua tarefa é escrever um código que produza uma sequência OEIS e contém o nome da sequência no código ( A______). Fácil o suficiente, certo? Bem, aqui está o problema: seu código também deve gerar uma segunda sequência separada quando o nome da sequência no código for alterado para o nome da segunda sequência.

Saída de Entrada

O seu código pode ser uma função ou um programa completo que tem n através de um método padrão de entrada e emite o n ésimo termo da sequência como indexada pelo índice fornecido na página OEIS.

Você deve suportar todos os valores fornecidos nos arquivos OEIS b para essa sequência, qualquer número que não esteja nos arquivos b não precisa ser suportado.

Pontuação

Isso é código-golfe . Sua pontuação será o número de bytes no seu código, com menos bytes sendo melhores.

Exemplo

Aqui está um exemplo em Haskell que funciona para A000217 e A000290.

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

Experimente online!

code-golf sequence Caçador Ad Hoc Garf
fonte
Para esclarecer: Seu código deve funcionar para duas seqüências em que colocar o nome da sequência nessa parte do código produzirá o número dessa sequência?
HyperNeutrino 2/17/17
@HyperNeutrino Yes. Quando o nome da sequência é substituído, deve alterar a função do programa para ser a segunda sequência.
Ad Hoc Garf Hunter
11
As seqüências no código precisam ter zeros à esquerda.
precisa saber é
@ppperry Sim, deveria.
Ad Hoc Garf Hunter
11
É Anecessário?
Okx 02/08/19

Respostas:

8

JavaScript (ES6), 16 15 bytes

n=>4&~0xA000004

Funciona com A000004 (todos os 0s) e A010709 (todos os 4s).

A solução anterior de 17 bytes funciona com A010850 a A010859, inclusive:

n=>~-0xA010850%36

A solução anterior de 25 bytes funciona com A010850 a A010871, inclusive:

n=>"A010850".slice(5)-39
Neil
fonte
Esta é apenas mostrar off (Eu não sei OEIS bem o suficiente para ver quão inteligente é: P)
TheLethalCoder
Estranho - duas respostas começou em 25 bytes e foram ambos golfed para 17 bytes em um minuto
pppery
@ppperry Heh, mas eu poderia port sua resposta e seria apenas 15 bytes ...
Neil
JS amarrado com geléia ?! Muito bem feito
Shaggy
@Shaggy Nope; uma nova resposta mais curta de geléia foi postada.
achou
3

cQuents , 16 bytes

=A000007//5#|A:0

Experimente online! , A000007 ,1,0,0,0,0...

=A000004//5#|A:0

Experimente online! , A000004 ,0,0,0,0,0...

Explicação

                    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

Agradecimentos a Conor O'Brien por 4//5 = 0e 7//5 = 1.

Se a especificação fosse mais flexível, seria O7A$e O4A$.

Stephen
fonte
2

dc , 13 bytes

Edit: Aparentemente, o OEIS lista os poderes de 0th a 30th - acabei de fazer uma pesquisa nessas seqüências e verifica-se que a 13solução original de bytes é a mais golfista. Mas eu encontrei outra solução para apenas 1mais byte que funciona para 9seqüências.

Solução para A000012 (sequência constante 1):

?A000012 4%^p

Experimente online!

Solução para A001477 (números inteiros não negativos):

?A001477 4%^p

Experimente online!

Solução para A000290 (sequência de quadrados perfeitos):

?A000290 4%^p

Experimente online!

Ungolfed / Explicação

Essas soluções fazem uso do fato de que dcinterpreta Acomo 10, então A001477se torna o valor 10001477. Além disso ele explora que as sequências são n^0, n^1e n^2que coincide com 10000012 % 4 == 0, 10001477 % 4 == 1e 10000290 % 4 == 2.

Então, essas sequências são 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]

Solução de 14 bytes para 9 sequências

A idéia ainda é a mesma, desta vez precisamos fazer a % 97, para obter a potência certa - funciona para as seqüências A010801 , A010802 , A010803 , A010804 , A010805 , A010806 , A010807 , A010808 e A010809 (estas são as seqüências n^13, .. ., n^21).

Aqui está o primeiro:

?A010801 97%^p

Experimente online!

ბიმო
fonte
11
+1 por suportar mais de duas sequências!
Neil
1

Python 2, 25 17 bytes

print'A000012'[5]

Funciona para A000004 e A000012. (a entrada é ignorada porque as seqüências são todos termos constantes).

pppery
fonte
1

Entre 98, 10 bytes

#A000012$q

Também funciona para A000004. Saída pelo código de saída.

pppery
fonte
1

Geléia , 17 bytes

“A000578”OS%⁵ạ6*@

Experimente online!

“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)]

Também funciona com A000290

HyperNeutrino
fonte
Bom trabalho usando seqüências não constantes.
AdmBorkBork 2/17/17
1

PowerShell , 23 bytes

+(0xA000012-eq160mb+18)

Experimente online!

Usa A000012 (a sequência todos) e A000004 (a sequência todos os zeros).

Aproveita vários truques legais. Usamos 0xcomo operador hexadecimal na sequência que nos fornece 167772178. Isso é comparado para ver se a sua -equal para 160mb+18usando o mboperador ( 160mbé 167772160). Esse resultado booleano é então convertido como int com +a saída do 1ou 0. Observe que qualquer sequência no código que não seja A000012 resultará na 0saída.

AdmBorkBork
fonte
1

Neim , 10 9 bytes

A000012ᛄ>

Explicação:

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

A000012 (todos) e A007395 (todos os dois)

Uma função que pega a entrada no topo da pilha e deixa a saída no topo da pilha.

Experimente online!

Okx
fonte
0

Gaia , 9 bytes

A000012₉/

Funciona com A000012 e A000004 .

Experimente A000012!

Experimente o A000004!

Explicação

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 negócios
fonte
Por que todo mundo continua postando A00004 e A00012?
precisa saber é
@ppperry A000004 é a sequência zero e A000012 é a sequência unidades. Simplesmente divida os números por 9 e produza o resultado para sempre.
Engenheiro Toast
0

05AB1E , 9 bytes

A000004¨θ

Experimente online!

Funciona para A000004 e A000012.

Erik, o Outgolfer
fonte
0

Gelatina , 10 bytes

6ị“A000004

Experimente online!

Funciona para A000004 e A000012.

Erik, o Outgolfer
fonte
0

Casca , 20 bytes

Este retorna sequências um pouco mais interessantes, mais uma vez as soluções são 1indexadas.

Isso funciona para A000040 (os números primos):

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

Experimente online!

E este para A000045 (os números de Fibonacci):

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

Experimente online!

Explicação

Isso faz uso do fato de que o último dígito dos nomes de sequência tem uma paridade 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
ბიმო
fonte
0

AHK , 40 bytes

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

Resultado: 0,0,0,0,0,0,0,0,0,0,0,0,...

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

Resultado: 1,1,1,1,1,1,1,1,1,1,1,1,...

Pode não ser o código mais curto, mas aposto que é o menor par de sequências que podemos encontrar. A000004 é a sequência zero e A000012 é a sequência unidades . Simplesmente divida os números por 9 e produza o resultado para sempre.

Engenheiro Toast
fonte
0

QBIC , 28 bytes

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

Comuta entre as seqüências A000034 (1, 2, 1, 2, 1 ...) e A000035 (0, 1, 0, 1, 0, 1 ...)

Explicação

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

Casca , 16 bytes

Ambas as soluções são 1indexadas.

Isso funciona para A000351 (potências de 5):

!¡*i!6"A000351"1

Experimente online!

E este para A000007 (potências de 0):

!¡*i!6"A000007"1

Experimente online!

Explicação

Faz uso que os nomes A000351 , A000007 contenham o dígito direito D na posição 6, de modo que a sequência seja 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
ბიმო
fonte