L' Enciclopedia on-line di sequenze di interi (OEIS) è un database online di sequenze di numeri interi. Contiene quasi 280000 sequenze di interesse matematico.

Esempi di sequenze:

• numeri interi positivi ( A000027 )
• numeri primi ( A000040 )
• Numeri di Fibonacci ( A000045 )

Il tuo compito è scrivere un programma o una funzione che mostri quante più sequenze OEIS che puoi, con un codice sorgente di 100 byte massimo. Il tuo programma dovrebbe accettare come input l'id sequenza (senza prepending Ae zero) e produrre i primi 20 numeri in quella sequenza.

Non è consentito recuperare i dati direttamente dal sito Web OEIS; tutte le sequenze devono essere calcolate dal tuo codice.

punteggio

Il punteggio è il numero di sequenze OEIS che il programma può visualizzare. Le risposte dovranno elencare gli ID delle sequenze riconosciute dal loro programma.

Esempio

Ecco una risposta valida in Java 8:

(int a) -> {
    for (int i = 0; i < 20; i++) {
        System.out.println(a==27?i+1:i*i); 
    }
};

Questo programma può visualizzare numeri interi positivi (A000027 - input 27) e quadrati (A000290 - input 290), quindi il suo punteggio è 2.

Nota

Si prega di evitare di raschiare l'intero sito Web OEIS :-) è possibile scaricare i nomi della sequenza (circa 3 mega) o i valori della sequenza (circa 9 mega). Si noti che questo download è coperto dal Contratto di licenza per l'utente finale OEIS .

CJam ( 2182 2780 3034 sequenze)

{:ZA3#:Cb(40-z_!!:B-\+CbB)/)_mqmo:M+:NK{)[N0{N1$_*-@/M@+1$md@M@-}K*]<W%B{X0@{2$*+\}%}*ZB&=}%\C)<f*}

Questo dà risposte corrette per gli intervalli inclusivi

• [A040000, A040003], [A040005, A040008], [A040011, A040013], A040015, [A040019, A040022], A040024, [A040029, A040033], A040035, A040037, [A040041, A040043], A040048, A040052, [A040055, A040057], A040059, A040063, [A040071, A040074], A040077, A040080, [A040090, A040091], [A040093, A040094], A040097, A040099, [A040109, A040111], A040118,A040120 , [A040131, A040135], A040137, A040139, [A040142, A040143], A040151, [A040155, A040157], A040166, A040168, [A040181, A040183],[A040185, A040968]
• [A041006, A041011], [A041014, A042937]
• A006983, [A011734, A011745], [A023975, A023976], [A025438, A025439], [A025443, A025444], A025466, A025469, [A034422, A034423], A034427, A034429, A034432, A034435, [A034437, A034439], A034441, A034443, A034445, A034447, [A034449, A034459], [A034461, A034462], [A034464, A034469], A034471, A034473, [A034475, A034477], [A034479, A034487], [A034489, A034490], [A034492, A034493], A034495, [A034497, A034512], [A034514, A034516], [A034518, A034523], [A034525, A034582], A036861, A047752, A052375, A055967, A061858, A065687, A066035, A067159, A067168, A070097, A070202, A070204, [A070205, A070206], A072325, A072769, A076142, A082998, A083344, A085974, A085982, A086007, A086015, A089458, A093392, A094382, A105517,A108322, A111855, A111859, [A111898, A111899], A112802, A122180, A129947, A137579, A159708, [A161277, A161280], A165766,A167263, A178780, A178798, A180472, A180601, A181340, A181735, A184946, A185037, A185203, [A185237, A185238], [A185245, A185246], A185255, A185264, A185284, A191928, A192541, A197629, A198255, A200214, A206499, A210632, A212619, [A217148, A217149], A217151, [A217155, A217156], A228953, A230533, A230686, A235044, A235358, A236265, A236417, A236460, A238403,[A243831, A243836] , A248805, A250002, A256974, A260502, A264668, A276183, A277165, A280492,A280815

Il A040??? sequenze corrispondono alle continue frazioni di radici quadrate non razionali da sqrt(2)a sqrt(1000)(con gli spazi corrispondenti a quelli che appaiono in precedenza nell'OEIS, ma convenientemente riempiti con sequenze casuali). Le A041???sequenze corrispondono ai numeratori e denominatori dei convergenti di frazione continua per radici quadrate non razionali da sqrt(6)a sqrt(1000)(con il divario corrispondente a sqrt(10), a A005667 and A005668). Le altre sequenze assortite hanno zero per i loro primi venti valori.

La risposta porta elementi di due mie precedenti risposte in GolfScript:

• Determinare le frazioni continue di radici quadrate
• Buone approssimazioni razionali di pi

Mille grazie a xnor per la breve x -> x + round(sqrt(x))sequenza di mappatura dei moduli chiusi si sul valore a sqrt. I risparmi rispetto al mio calcolo precedente (generazione dell'elenco di non quadrati e selezione per indice) hanno fornito abbastanza per avere un fallback a zero per la maggior parte degli indici fuori range.

Python 2, 875 sequenze

print', '.join('%020d'%(10**20/(input()-21004)))

Funziona con 875 sequenze da 21016 (cifre decimali da 1/12) a 21999 (cifre decimali di 1/995).

Ho trovato questo pezzo con il sofisticato algoritmo di ricerca di digitare casualmente in id di sequenza a mano. Alcune delle sequenze nell'intervallo non sono di questo formato e appaiono altrove (grazie a Mitchell Spector per averlo sottolineato). Per esempio, 21021 non è l'espansione di 1/17.

Anche con le interruzioni, le sequenze per 1 / n appaiono come id n+21004. Il resto non viene spostato, ma le sequenze mancanti appaiono altrove. Ad esempio, 1/17 appare come 7450 .

Ho contato quelli corrispondenti usando una copia scaricata dei nomi delle sequenze.

Un blocco diverso fornisce 848 sequenze da 16742 a 17664 .

n=input()-16729
for i in range(20):k=n/12;a=int((8*k+1)**.5/2+.5);print(a*i+k-a*(a-1)/2)**(n%12+1)

Questi hanno tutti forma n -> (a*n+b)^c , dove 2≤a≤12, 0≤b<a, 1≤c≤12. Il codice estrae i coefficienti invertendo numeri e moduli triangolari. Come prima, non tutte le sequenze nell'intervallo corrispondono. Se queste due espressioni potessero adattarsi a 100 byte, darebbe 1723 sequenze.

Bocconi promettenti:

• 1929 sequenze corrispondenti: 41006 attraverso 42397 , numeratori e denominatori di convergenti frazione continua.
• ~ 3300 sequenze corrispondenti: da 147999 a 151254 : numero di passi su Z ^ 3, se riesci a trovare come sono ordinati gli elenchi dei vettori.

Ecco le categorie per altri potenziali blocchi, raggruppando i nomi delle sequenze OEIS rimuovendo tutti i numeri (cifre, segno meno, punto decimale). Sono ordinati per numero di presenze.

3010    Number of walks within N^ (the first octant of Z^) starting at (,,) and consisting of n steps taken from {(, , ), (, , ), (, , ), (, , ), (, , )}
2302    Number of reduced words of length n in Coxeter group on  generators S_i with relations (S_i)^ = (S_i S_j)^ = I
979     Primes congruent to  mod 
969     Numerators of continued fraction convergents to sqrt()
967     Denominators of continued fraction convergents to sqrt()
966     Continued fraction for sqrt()
932     Decimal expansion of /
894     Duplicate of A
659     Partial sums of A
577     Divisors of 
517     Inverse of th cyclotomic polynomial
488     Expansion of /((x)(x)(x)(x))
480     Decimal expansion of th root of 
471     Number of nX  arrays with each element x equal to the number its horizontal and vertical neighbors equal to ,,,, for x=,,,,
455     First differences of A
448     Decimal expansion of log_ ()
380     Numbers n such that string , occurs in the base  representation of n but not of n+
378     Erroneous version of A
375     Numbers n such that string , occurs in the base  representation of n but not of n
340     Numbers n with property that in base  representation the numbers of 's and 's are  and , respectively

35 sequenze:

c=input()
for n in range(20):print[(c-1010)**n,(c-8582)*n][c>2e3]

Funziona da 8585 (multipli di 3) a 8607 (multipli di 25) e 1018 (poteri di 8) fino a 1029 (poteri di 19). Convenientemente, questi sono tutti in un pezzo ordinato da ID.

Questo utilizza solo 65 dei 100 byte consentiti e non è ancora completamente giocato a golf, quindi cercherò un altro bel pezzo.

Bash + coreutils, 252 sequenze

yes 0|head -20

Provalo online!

Funziona con 252 sequenze OEIS: A000004, A006983, A011734, A011735, A011736, A011737, A011738, A011739, A011740, A011741, A011742, A011743, A011744, A011745, A023975, A023976 ,02544, A25254 A034422, A034423, A034427, A034429, A034432, A034435, A034437, A034438, A034439, A034441, A034443, A034445, A034447, A034449, A034450, A034451, A034452, A034453, A034454, A034455, A034456, A034457, A034458, A034459, A034461, A034462, A034464, A034465, A034466, A034467, A034468, A034469, A034471, A034473, A034475, A034476, A034477, A034479, A034480, A034481, A034482, A034483, A034484, A034485, A034486, A034487, A034489, A034490, A034492, A034493, A034495, A034497, A034498, A034499, A034500, A034501, A034502, A034503, A034504, A034505, A034506, A034507, A034508, A034509, A034510, A034545 ,03451212A034518, A034519, A034520, A034521, A034522, A034523, A034525, A034526, A034527, A034528, A034529, A034530, A034531, A034532, A034533, A034534, A03453503030303030303030303030303030303030303030303030303030303030303030303 A034544, A034545, A034546, A034547, A034548, A034549, A034550, A034551, A034552, A034553, A034554, A034555, A034556, A034557, A034558, A034559, A034560, A034561, A034562 A0345 A0345 A A034569, A034570, A034571, A034572, A034573, A034574, A034575, A034576, A034577, A034578, A034579, A034580, A034581, A034582, A036861, A047756760660660 A67456 A070204, A070205, A070206, A072325, A072769, A076142, A082998, A083344, A085974, A085982, A086007, A086015, A089458, A093392, A094382, A10551811 AA111899, A112802, A122180, A129947, A137579, A159708, A161277, A161278, A161279, A161280, A165766, A167263, A178780, A178798, A180472, A180601, A181340, A1817185185 A185255, A185264, A185284, A191928, A192541, A197629, A198255, A200214, A206499, A210632, A212619, A217148, A217149, A217151, A217155, A217353650 A243831, A243832, A243833, A243834, A243835, A243836, A248805, A250002, A256974, A260502, A264668, A276183, A277165, A280492, A280815A198255, A200214, A206499, A210632, A212619, A217148, A217149, A217151, A217155, A217156, A228953, A230533, A230686, A235044, A235358, A2438324 A2438324 A2438324 A A248805, A250002, A256974, A260502, A264668, A276183, A277165, A280492, A280815A198255, A200214, A206499, A210632, A212619, A217148, A217149, A217151, A217155, A217156, A228953, A230533, A230686, A235044, A235358, A2438324 A2438324 A2438324 A A248805, A250002, A256974, A260502, A264668, A276183, A277165, A280492, A280815

Python (con sympy), 144 146 sequenze

import sympy
f=lambda a,M=16627:[int(c)for c in str(sympy.log((a<M)*46.5+4+a-M).n(20))if'.'<c][-20:]

La funzione ffunziona per le sequenze 146 da A016578 a A016723 incluso.

Tutti questi sono prodotti dal cablaggio di prova su repl.it .

Le 49 sequenze da A016578 a A016626 incluse sono le espansioni decimali di log (3/2), log (5/2), log (7/2), ..., log (99/2).

Le 97 sequenze da A016627 a A016723 incluse sono le espansioni decimali di log (4), log (5), log (6), ..., log (100).

I primi due dei 49 iniziano con il primo decimale poiché i valori di log per loro sono inferiori a 1 , quindi [-20:]prende le 20 posizioni decimali finali del risultato della chiamata a ...n(20)cui ottengono 20 cifre significative. I if'.'<cfiltri fuori il carattere decimale, ei int(c)calchi ogni personaggio rimanente cifre in un numero intero (anche se forse non necessario).

Jelly, 1127 1975 sequenze

- questo attualmente combina i risultati di xnor e Mitchell Spector , ma ha ancora spazio per la crescita a 78 byte. Vai a dare loro un po 'di credito!

0x20
_21004µȷ20:DU¢oU
20Ḷ×⁸+µ*þ12
11R‘µẋ`€F$ç"Ḷ€F$;/
_108ị¢

“æÑØ‘×ȷ3¤>J×$S‘µĿ

TryItOnline!

Le sequenze del 1975 sono:

• i 252 che iniziano con venti zeri (il comportamento per l'input esterno a [16000,21999] );
• le 848 sequenze comprese nell'intervallo da 16742 a 17664 che corrispondono a(a*n+b)**c formula (il comportamento per l'input in [16000,17999]); e
• le 875 sequenze comprese nell'intervallo da 21016 a 21999 che corrispondono all'espansione decimale di 1/n(il comportamento per l'input in[18000,21999] ).

Come?

0x20 - Link 1, TwentyZeros: no arguments
0    - zero
  20 - twenty
 x   - repeat

_21004µȷ20:DU¢oU - Link 2, DecimalExpansionOfReciprocal: oeisIndexNumber
      µ          - monadic chain separation
       ȷ20       - 1e20
_21004           - subtract 21004 from oeisNumber to get the n value
          :      - integer division, i.e. 1e20 // n
           D     - decimal list
            U    - reverse
             ¢   - call last link (1) as a nilad, i.e. get twenty zeros
              o  - logical or, i.e. pad the right of the reversed list to twenty with zeros
               U - reverse again

20Ḷ×⁸+µ*þ12 - Link 3, BlockOf12abcFormulaResults: a, b
20Ḷ         - lowered range of 20 [0,1,...,19] i.e. the values of n in (a*n+b)**c
    ⁸       - left argument, a
   ×        - multiply
     +      - add b
      µ     - monadic chain separation
        þ12 - outer product with [1,2,...,12] of... i.e. the values of c in (a*n+b)**c
       *    -     exponentiation

11R‘µẋ`€F$ç"Ḷ€F$;/ - link 4, AllabcFormulaResults: no aguments
11R                - range of 11 [1,2,...,11]
   ‘               - increment   [2,3,...12] i.e. the values of a in (a*n+b)**c
    µ              - monadic chain separation
         $         - last two links as a monad
     ẋ`€           - repeat list with repeated arguments for €ach [[2,2],[3,3,3],...,[12,12,12,12,12,12,12,12,12,12,12,12]]
        F          - flatten into one list
               $   - last two links as a monad
            Ḷ€     - lowered range of €ach [[0,1],[0,1,2],...,[0,1,2,3,4,5,6,7,8,9,10,11]]
              F    - flatten into one list
          ç"       - zip with (") last link (3) as a dydad (ç) i.e. get all the results
                 / - reduce with
                ;  - concatenation i.e. make the list of lists of lists one list of lists.

_108ị¢ - Link 5, abcFormulaResult: oeisIndexNumber
_108   - subtract 108 from the oeisNumber (indexes in Jelly are modular and there are 924 entries, this is shorter than _16740)
     ¢ - call last link (4) as a nilad
    ị  - index into i.e. get the one relevant result of 20 terms

 - Link 6, an empty link (cheaper in bytes than the %6 alternative in the main link)

“æÑØ‘×ȷ3¤>J×$S‘µĿ - Main link: oeisIndexNumber           e.g. 1-15999; 16000-17999; 18000-21999; 22000+
        ¤         - nilad followed by link(s) as a nilad
“æÑØ‘             - codePage indexes [22,16,18]
      ȷ3          - 1e3
     ×            - multiply [22000,16000,18000]
         >        - greater than (vectorises)            e.g. [1,1,1]; [1,0,1];     [1,0,0];     [0,0,0]
            $     - last two links as a monad
          J       - range(length) [1,2,3]
           ×      - multiply                             e.g. [1,2,3]; [1,0,3];     [1,0,0];     [0,0,0]
             S    - sum                                  e.g. 6;       4;           1;           0
              ‘   - increment                            e.g. 7;       5;           2;           1
               µ  - monadic chain separation
                Ŀ - call link(index) as a monad with the oeisIndexNumber
                        link indexing is 1-based and modular so 7 calls link 1
              ><        hence the empty link 6 replacing a %6 here

Mathematica, 39 173 189 sequenze

If[l=0~Range~19;#<4^7,l,If[#<3^9,#&@@RealDigits[Log[j=16627;#-j+If[#<j,49.5,4]],10,20],#-22956-l]]&

Ispirato dalla risposta di Jonathan Allan .

Lavora per:

• 1477 , 2837 , 4830 e 8554 (i primi 20 termini sono {0, 1, 2, ... , 19})
• Da 16578 a 16626 (espansione decimale del registro (3/2), espansione decimale del registro (5/2), ... espansione decimale del registro (99/2))
• Da 16627 a 16723 (espansione decimale del registro (4), espansione decimale del registro (5), ... espansione decimale del registro (100))
• Da 22958 a 22996 (2-n, 3-n, ... 40-n)

CJam, sequenze del 1831

{168680-:Zz1320b900b48md:R;H+:QB+2*,:!1_tQWtQ)WtK{[WQW*_(]+1$f=[1R2+R~R4+*2/WR-X$-].*1b+}/J~>ZW>f*}

Ciò fornisce un output corretto per 199 sequenze a partire 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0e tutte le sequenze negli intervalli inclusivi [A168680, A169579]e [A170000, A170731]. La maggior parte si occupa di quei due intervalli, con un fallback per tutti gli zero prima dell'inizio del primo intervallo.

I due intervalli in questione hanno la forma

Numero di parole ridotte di lunghezza $n$ nel gruppo Coxeter su $P$ generatori $S_i$ con le relazioni $(S_i)^2 = (S_i S_j)^Q = I$

per valori di $P$ che vanno da $3$ a $50$ e valori di $Q$ che vanno da $17$ a $50$. Le loro funzioni generatrici sono date in modo del tutto inefficiente: ho trovato utile moltiplicare numeratori e denominatori per$(t - 1)$ per dare gf

Lotto, 62 sequenze

@for /l %%i in (1,1,20)do @set/a"n=(n=22956-%1)*(n>>=16)+%%i*(n|%1-8582)"&call echo %%n%%

È stato difficile implementare un solo blocco di sequenze, ma ne ho gestite due in 89 byte! Spiegazione: Per un parametro %1di 8585-8607, 22956-%1>>16restituisce zero, facendo sì che l' (22956-%1)espressione venga ignorata e finiamo per moltiplicare rispettivamente la variabile del ciclo per 3-25, mentre per un parametro di 22958-22996 restituisce meno uno causando l'espressione negato, mentre ciò n|provoca la sostituzione del fattore di moltiplicazione con meno uno sottraendo efficacemente la variabile di loop.

PHP , 28 byte, 33 sequenze presumo

for(;;)print_r(range(0,32));

Provalo online!

https://oeis.org/A000004 0 https://oeis.org/A007395 2 https://oeis.org/A010701 3 https://oeis.org/A010709 4 https://oeis.org/A010716 5 https://oeis.org/A010722 6 https://oeis.org/A010727 7 https://oeis.org/A010731 8 https://oeis.org/A010734 9 https://oeis.org/A010692 10 https://oeis.org/A010850 11 https://oeis.org/A010851 12 https://oeis.org/A010852 13 https://oeis.org/A010854 15 https://oeis.org/A010855 16 https://oeis.org/A010857 18 https://oeis.org/A010859 20 https : //oeis.org/A010861 22 https://oeis.org/A010863 24 https://oeis.org/A010871 32