Scambia la sequenza

9

Il tuo compito è scrivere del codice che generi una sequenza OEIS e contenga il nome della sequenza nel codice ( A______). Abbastanza facile giusto? Bene, ecco il problema, il tuo codice deve anche generare una seconda sequenza separata quando il nome della sequenza nel codice viene cambiato con il nome della seconda sequenza.

Input Output

Il codice può essere una funzione o programma completo che prende n tramite un metodo standard input ed emette il n esimo termine della sequenza come indicizzato dall'indice fornito nella pagina OEIS.

È necessario supportare tutti i valori forniti nei file b di OEIS per quella sequenza, non è necessario supportare alcun numero non presente nei file b.

punteggio

Questo è code-golf . Il tuo punteggio sarà il numero di byte nel tuo codice, con meno byte migliori.

Esempio

Ecco un esempio in Haskell che funziona per A000217 e A000290.

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

Provalo online!

code-golf  sequence 
— Ad Hoc Garf Hunter
fonte
Per chiarire: il tuo codice dovrebbe funzionare per due sequenze in cui inserendo il nome della sequenza in quella parte del codice verrà generato il numero di quella sequenza?
— HyperNeutrino,
@HyperNeutrino Sì. Quando il nome della sequenza viene sostituito in esso, la funzione del programma dovrebbe cambiare in seconda sequenza.
— Ad Hoc Garf Hunter
1
Le sequenze nel codice devono avere zeri iniziali.
— pepery
@ppperry Sì, dovrebbe.
— Ad Hoc Garf Hunter
1
È Arichiesto?
— Okx,

Risposte:

8

JavaScript (ES6), 16 15 byte

n=>4&~0xA000004

Funziona con A000004 (tutti gli 0) e A010709 (tutti gli 4).

La precedente soluzione a 17 byte funziona da A010850 a A010859 inclusi:

n=>~-0xA010850%36

La precedente soluzione a 25 byte funziona da A010850 a A010871 inclusi:

n=>"A010850".slice(5)-39
— Neil
fonte
Questo è solo in mostra (non conosco l'OEIS abbastanza bene per vedere quanto sia intelligente: P)
— TheLethalCoder
Strano: due risposte sono iniziate a 25 byte ed entrambe sono state giocate a golf a 17 byte in un minuto
— pepery
@ppperry Heh, ma potrei eseguire il porting della tua risposta e sarebbero solo 15 byte ...
— Neil
JS legato con Jelly ?! Molto ben fatto
— Shaggy
@Shaggy Nope; è stata pubblicata una nuova risposta gelatina più breve.
— pepery
3

cQuents , 16 byte

=A000007//5#|A:0

Provalo online! , A000007 ,1,0,0,0,0...

=A000004//5#|A:0

Provalo online! , A000004 ,0,0,0,0,0...

Spiegazione

                    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

Grazie a Conor O'Brien per 4//5 = 0e 7//5 = 1.

Se la specifica fosse più flessibile, sarebbe O7A$e O4A$.

— Stefano
fonte
2

dc , 13 byte

Modifica: Apparentemente OEIS elenca i poteri da 0th a 30th - ho appena fatto una ricerca su queste sequenze e si scopre che la 13soluzione di byte originale è la più golf. Ma ho trovato un'altra soluzione per solo 1byte in più che funziona per le 9sequenze.

Soluzione per A000012 (sequenza di 1 costante):

?A000012 4%^p

Provalo online!

Soluzione per A001477 (numeri interi non negativi):

?A001477 4%^p

Provalo online!

Soluzione per A000290 (sequenza di quadrati perfetti):

?A000290 4%^p

Provalo online!

Ungolfed / Spiegazione

Queste soluzioni si avvalgono del fatto che dcinterpreta Acome 10, quindi A001477diventa il valore 10001477. Sfrutta inoltre che le sequenze sono n^0, n^1e n^2che coincide con 10000012 % 4 == 0, 10001477 % 4 == 1e 10000290 % 4 == 2.

Quindi queste sequenze sono 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]

Soluzione a 14 byte per 9 sequenze

L'idea è sempre la stessa, questa volta dobbiamo fare una % 97, per ottenere la giusta potenza: funziona per le sequenze A010801 , A010802 , A010803 , A010804 , A010805 , A010806 , A010807 , A010808 e A010809 (queste sono le sequenze n^13, .. ., n^21).

Ecco il primo:

?A010801 97%^p

Provalo online!

— ბიმო
fonte
1
+1 per supportare più di due sequenze!
— Neil,
1

Python 2, 25 17 byte

print'A000012'[5]

Funziona con A000004 e A000012. (l'input viene ignorato perché le sequenze sono tutte termini costanti).

— pppery
fonte
1

Befunge 98, 10 byte

#A000012$q

Funziona anche con A000004. Uscita per codice di uscita.

— pppery
fonte
1

Gelatina , 17 byte

“A000578”OS%⁵ạ6*@

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

Funziona anche con A000290

— HyperNeutrino
fonte
Buon lavoro usando sequenze non costanti.
— AdmBorkBork,
1

PowerShell , 23 byte

+(0xA000012-eq160mb+18)

Provalo online!

Usa A000012 (la sequenza di tutti) e A000004 (la sequenza di tutti zeri).

Sfrutta diversi trucchi accurati. Usiamo 0xcome operatore esadecimale sulla sequenza che ci dà 167772178. Viene confrontato per vedere se è -eqnormale 160mb+18usare l' mboperatore (lo 160mbè 167772160). Quel risultato booleano viene quindi lanciato come int con +l'output del proprio 1o 0. Notare che qualsiasi sequenza nel codice diversa da A000012 si tradurrà in 0output.

— AdmBorkBork
fonte
1

Neim , 10 9 byte

A000012ᛄ>

Spiegazione:

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

A000012 (tutti) e A007395 (tutti i due)

Una funzione che accetta l'input nella parte superiore dello stack e lascia l'output nella parte superiore dello stack.

Provalo online!

— Okx
fonte
0

Gaia , 9 byte

A000012₉/

Funziona con A000012 e A000004 .

Prova A000012!

Prova A000004!

Spiegazione

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
— Gatto di affari
fonte
Perché tutti continuano a pubblicare A00004 e A00012?
— pepery
@ppperry A000004 è la sequenza zero e A000012 è la sequenza. Semplicemente dividi i numeri per 9 e produci il risultato per sempre.
— Ingegnere Toast,
0

Buccia , 20 byte

Questo restituisce sequenze un po 'più interessanti, ancora una volta le soluzioni sono 1indicizzate.

Questo funziona con A000040 (i numeri primi):

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

Provalo online!

E questo per A000045 (i numeri di Fibonacci):

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

Provalo online!

Spiegazione

Questo utilizza il fatto che l'ultima cifra dei nomi delle sequenze ha una parità diversa:

                      -- 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 byte

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

Produzione: 0,0,0,0,0,0,0,0,0,0,0,0,...

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

Produzione: 1,1,1,1,1,1,1,1,1,1,1,1,...

Questo potrebbe non essere il codice più breve ma scommetto che è la coppia di sequenza più breve che possiamo trovare. A000004 è la sequenza zero e A000012 è la sequenza uno. Semplicemente dividi i numeri per 9 e produci il risultato per sempre.

— Ingegnere Toast
fonte
0

QBIC , 28 byte

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

Commuta tra le sequenze A000034 (1, 2, 1, 2, 1 ...) e A000035 (0, 1, 0, 1, 0, 1 ...)

Spiegazione

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

Buccia , 16 byte

Entrambe le soluzioni sono 1sottoindicate.

Funziona con A000351 (potenze di 5):

!¡*i!6"A000351"1

Provalo online!

E questo per A000007 (potenze di 0):

!¡*i!6"A000007"1

Provalo online!

Spiegazione

Fa uso che i nomi A000351 , A000007 contengono la cifra destra D nella posizione 6, in modo tale che la sequenza sia 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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.