Échangez la séquence

9

Votre tâche consiste à écrire du code qui génère une séquence OEIS et contient le nom de la séquence dans le code ( A______). Assez simple non? Eh bien, voici le hic, votre code doit également générer une deuxième séquence distincte lorsque le nom de la séquence dans le code est remplacé par le nom de la deuxième séquence.

Entrée sortie

Votre code peut être une fonction ou un programme complet qui prend n via une méthode d'entrée standard et génère le n ème terme de la séquence indexé par l'index fourni sur la page OEIS.

Vous devez prendre en charge toutes les valeurs fournies dans les fichiers b OEIS pour cette séquence, tout nombre ne figurant pas dans les fichiers b n'a pas besoin d'être pris en charge.

Notation

C'est du code-golf . Votre score sera le nombre d'octets dans votre code, avec moins d'octets étant mieux.

Exemple

Voici un exemple dans Haskell qui fonctionne pour A000217 et A000290.

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

Essayez-le en ligne!

code-golf sequence Ad Hoc Garf Hunter
la source
Pour clarifier: Votre code devrait fonctionner pour deux séquences où la mise du nom de la séquence dans cette partie du code affichera le numéro de cette séquence?
HyperNeutrino
@HyperNeutrino Oui. Lorsque le nom de la séquence est substitué, il devrait changer la fonction du programme pour être la deuxième séquence.
Ad Hoc Garf Hunter
1
Les séquences du code doivent-elles avoir des zéros en tête.
pppery
@ppperry Oui, ça devrait.
Ad Hoc Garf Hunter
1
Est-ce Anécessaire?
Okx

Réponses:

8

JavaScript (ES6), 16 15 octets

n=>4&~0xA000004

Fonctionne avec A000004 (tous les 0) et A010709 (tous les 4).

La solution précédente de 17 octets fonctionne avec A010850 à A010859 inclus:

n=>~-0xA010850%36

La solution précédente de 25 octets fonctionne avec A010850 à A010871 inclus:

n=>"A010850".slice(5)-39
Neil
la source
Cela ne fait que montrer (je ne connais pas suffisamment OEIS pour voir à quel point c'est intelligent: P)
TheLethalCoder
Étrange - deux réponses ont commencé à 25 octets et ont toutes deux été jouées à 17 octets en une minute
pppery
@ppperry Heh, mais je pourrais porter votre réponse et ce ne serait que de 15 octets ...
Neil
JS à égalité avec Jelly ?! Très bien fait
Shaggy
@Shaggy Nope; une nouvelle réponse de gelée plus courte a été publiée.
pppery
3

cQuents , 16 octets

=A000007//5#|A:0

Essayez-le en ligne! , A000007 ,1,0,0,0,0...

=A000004//5#|A:0

Essayez-le en ligne! , A000004 ,0,0,0,0,0...

Explication

                    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

Merci à Conor O'Brien pour 4//5 = 0et 7//5 = 1.

Si la spécification était plus flexible, ce serait O7A$et O4A$.

Stephen
la source
2

dc , 13 octets

Edit: Apparemment OEIS répertorie les puissances de 0th à 30th - je viens de faire une recherche sur ces séquences et il s'avère que la 13solution d'octets d' origine est la plus golfique. Mais j'ai trouvé une autre solution pour un 1octet de plus qui fonctionne pour les 9séquences.

Solution pour A000012 (séquence de constante 1):

?A000012 4%^p

Essayez-le en ligne!

Solution pour A001477 (entiers non négatifs):

?A001477 4%^p

Essayez-le en ligne!

Solution pour A000290 (séquence de carrés parfaite):

?A000290 4%^p

Essayez-le en ligne!

Non golfé / Explication

Ces solutions utilisent le fait que l' dcinterprète Acomme 10, A001477devient alors la valeur 10001477. De plus, il exploite que les séquences sont n^0, n^1et n^2qui coïncident avec 10000012 % 4 == 0, 10001477 % 4 == 1et 10000290 % 4 == 2.

Donc, ces séquences le sont 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]

Solution de 14 octets pour 9 séquences

L'idée est toujours la même, cette fois nous devons faire un % 97, pour obtenir la bonne puissance - cela fonctionne pour les séquences A010801 , A010802 , A010803 , A010804 , A010805 , A010806 , A010807 , A010808 et A010809 (ce sont les séquences n^13, .. ., n^21).

Voici le premier:

?A010801 97%^p

Essayez-le en ligne!

ბიმო
la source
1
+1 pour supporter plus de deux séquences!
Neil
1

Python 2, 25 17 octets

print'A000012'[5]

Fonctionne pour A000004 et A000012. (l'entrée est ignorée car les séquences sont toutes des termes constants).

pppery
la source
1

Befunge 98, 10 octets

#A000012$q

Fonctionne également pour A000004. Sortie par code de sortie.

pppery
la source
1

Gelée , 17 octets

“A000578”OS%⁵ạ6*@

Essayez-le en ligne!

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

Fonctionne également avec A000290

HyperNeutrino
la source
Bon travail en utilisant des séquences non constantes.
AdmBorkBork du
1

PowerShell , 23 octets

+(0xA000012-eq160mb+18)

Essayez-le en ligne!

Utilise A000012 (la séquence tous les uns) et A000004 (la séquence tous les zéros).

Exploite plusieurs astuces soignées. Nous utilisons 0xcomme opérateur hexadécimal sur la séquence qui nous donne 167772178. C'est comparé pour voir si son -equal à l' 160mb+18aide de l' mbopérateur ( 160mbest 167772160). Ce résultat booléen est ensuite +converti en int avec pour afficher le bon 1ou 0. Notez que toute séquence dans le code autre que A000012 entraînera la 0sortie.

AdmBorkBork
la source
1

Neim , 10 9 octets

A000012ᛄ>

Explication:

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

A000012 (tous les uns) et A007395 (tous les deux)

Une fonction qui prend l'entrée en haut de la pile et laisse la sortie en haut de la pile.

Essayez-le en ligne!

Okx
la source
0

Gaia , 9 octets

A000012₉/

Fonctionne avec A000012 et A000004 .

Essayez A000012!

Essayez A000004!

Explication

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
Chat d'affaires
la source
Pourquoi tout le monde affiche-t-il A00004 et A00012?
pppery
@ppperry A000004 est la séquence zéro et A000012 est la séquence un. Il suffit de diviser les nombres par 9 et de produire le résultat pour toujours.
Engineer Toast
0

Décortiquer , 20 octets

Celui-ci renvoie des séquences un peu plus intéressantes, encore une fois les solutions sont 1 indexées.

Cela fonctionne pour A000040 (les nombres premiers):

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

Essayez-le en ligne!

Et celui-ci pour A000045 (les numéros de Fibonacci):

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

Essayez-le en ligne!

Explication

Cela utilise le fait que le dernier chiffre des noms de séquence a une parité différente:

                      -- 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
ბიმო
la source
0

AHK , 40 octets

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

Production: 0,0,0,0,0,0,0,0,0,0,0,0,...

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

Production: 1,1,1,1,1,1,1,1,1,1,1,1,...

Ce n'est peut-être pas le code le plus court, mais je parie que c'est la paire de séquences la plus courte que nous pouvons trouver. A000004 est la séquence zéro et A000012 est la séquence un. Il suffit de diviser les nombres par 9 et de produire le résultat pour toujours.

Ingénieur Toast
la source
0

QBIC , 28 octets

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

Cela bascule entre les séquences A000034 (1, 2, 1, 2, 1 ...) et A000035 (0, 1, 0, 1, 0, 1 ...)

Explication

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
la source
0

Husk , 16 octets

Les deux solutions sont 1indexées.

Cela fonctionne pour A000351 (puissances de 5):

!¡*i!6"A000351"1

Essayez-le en ligne!

Et celui-ci pour A000007 (puissances de 0):

!¡*i!6"A000007"1

Essayez-le en ligne!

Explication

Il utilise que les noms A000351 , A000007 contiennent le bon chiffre D à la position 6, de sorte que la séquence est 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
ბიმო
la source