Zamień sekwencję

9

Twoim zadaniem jest napisanie kodu, który generuje sekwencję OEIS i zawiera nazwę sekwencji w code ( A______). Łatwo, prawda? Cóż, oto haczyk, twój kod musi również wypisać drugą osobną sekwencję, gdy nazwa sekwencji w kodzie zostanie zmieniona na nazwę drugiej sekwencji.

Wejście wyjście

Kod może być funkcją lub kompletnym programem, który pobiera n za pomocą standardowej metody wprowadzania i generuje n- ty ciąg sekwencji indeksowany przez podany indeks na stronie OEIS.

Musisz obsługiwać wszystkie wartości podane w plikach OEIS b dla tej sekwencji, dowolna liczba nie w plikach b nie musi być obsługiwana.

Punktacja

To jest golf-golf. Twój wynik będzie liczbą bajtów w kodzie, przy czym mniej bajtów będzie lepszych.

Przykład

Oto przykład w Haskell, który działa dla A000217 i A000290.

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

Wypróbuj online!

code-golf sequence Ad Hoc Garf Hunter
źródło
Aby wyjaśnić: Twój kod powinien działać dla dwóch sekwencji, w których umieszczenie nazwy sekwencji w tej części kodu spowoduje wyświetlenie numeru tej sekwencji?
HyperNeutrino,
@HyperNeutrino Tak. Gdy nazwa sekwencji zostanie podstawiona, powinna zmienić funkcję programu na drugą sekwencję.
Ad Hoc Garf Hunter
1
Czy sekwencje w kodzie muszą mieć początkowe zera.
pppery
@ppperry Tak, powinno.
Ad Hoc Garf Hunter
1
Czy jest to Awymagane?
Okx,

Odpowiedzi:

8

JavaScript (ES6), 16 15 bajtów

n=>4&~0xA000004

Współpracuje z A000004 (wszystkie 0) i A010709 (wszystkie 4).

Poprzednie 17-bajtowe rozwiązanie współpracuje z A010850 do A010859 włącznie:

n=>~-0xA010850%36

Poprzednie 25-bajtowe rozwiązanie współpracuje z A010850 do A010871 włącznie:

n=>"A010850".slice(5)-39
Neil
źródło
To tylko popisuje się (nie znam wystarczająco OEIS, aby zobaczyć, jak sprytne jest to: P)
TheLethalCoder
Dziwne - dwie odpowiedzi zaczynały się od 25 bajtów i obie były rozgrywane w golfa do 17 bajtów na minutę
pppery
@ppperry Heh, ale mógłbym przenieść twoją odpowiedź, a byłoby to tylko 15 bajtów ...
Neil
JS związany z galaretką ? Bardzo ładnie wykonane
Shaggy
@Shaggy Nope; opublikowano nową krótszą odpowiedź na galaretkę.
pppery
3

cQuents , 16 bajtów

=A000007//5#|A:0

Wypróbuj online! , A000007 ,1,0,0,0,0...

=A000004//5#|A:0

Wypróbuj online! , A000004 ,0,0,0,0,0...

Wyjaśnienie

                    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

Dzięki Conor O'Brien za 4//5 = 0i 7//5 = 1.

Gdyby specyfikacja była bardziej elastyczna, byłaby O7A$i O4A$.

Stephen
źródło
2

dc , 13 bajtów

Edycja: Najwyraźniej OEIS wymienia moce od 0th do 30th - Właśnie przeszukałem te sekwencje i okazało się, że oryginalne 13rozwiązanie bajtowe jest najbardziej golfowe. Ale znalazłem inne rozwiązanie dla 1bajtu więcej, które działa dla 9sekwencji.

Rozwiązanie dla A000012 (stała sekwencja 1):

?A000012 4%^p

Wypróbuj online!

Rozwiązanie dla A001477 (nieujemne liczby całkowite):

?A001477 4%^p

Wypróbuj online!

Rozwiązanie dla A000290 (idealna sekwencja kwadratów):

?A000290 4%^p

Wypróbuj online!

Niegolfowane / Wyjaśnienie

Rozwiązania te wykorzystują fakt, że dcinterpretuje Ajako 10, więc A001477staje się wartością 10001477. Dalsze eksploatuje że sekwencje są n^0, n^1i n^2który zbiega się z 10000012 % 4 == 0, 10001477 % 4 == 1i 10000290 % 4 == 2.

Więc te sekwencje są 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]

14 bajtowe rozwiązanie dla 9 sekwencji

Pomysł jest nadal ten sam, tym razem musimy zrobić % 97, aby uzyskać odpowiednią moc - działa dla sekwencji A010801 , A010802 , A010803 , A010804 , A010805 , A010806 , A010807 , A010808 i A010809 (są to sekwencje n^13, .. ., n^21).

Oto pierwszy:

?A010801 97%^p

Wypróbuj online!

ბიმო
źródło
1
+1 za obsługę więcej niż dwóch sekwencji!
Neil
1

Python 2, 25 17 bajtów

print'A000012'[5]

Działa dla A000004 i A000012. (dane wejściowe są ignorowane, ponieważ wszystkie sekwencje są stałymi terminami).

pppery
źródło
1

Befunge 98, 10 bajtów

#A000012$q

Działa również dla A000004. Wyjście według kodu wyjścia.

pppery
źródło
1

Galaretka , 17 bajtów

“A000578”OS%⁵ạ6*@

Wypróbuj 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)]

Współpracuje również z A000290

HyperNeutrino
źródło
Dobra robota przy użyciu ciągłych sekwencji.
AdmBorkBork
1

PowerShell , 23 bajty

+(0xA000012-eq160mb+18)

Wypróbuj online!

Używa A000012 (sekwencja wszystkich zer ) i A000004 (sekwencja wszystkich zer).

Wykorzystuje kilka schludnych sztuczek. Używamy 0xjako operator szesnastkowy w sekwencji, która nam daje 167772178. Że w porównaniu do sprawdzenia, czy jego -eqUAL się 160mb+18za pomocą mboperatora ( 160mbma 167772160). Ten wynik boolowski jest następnie rzutowany jako int z +wyjściem właściwego 1lub 0. Zauważ, że każda sekwencja w kodzie innym niż A000012 spowoduje 0wyjście.

AdmBorkBork
źródło
1

Neim , 10 9 bajtów

A000012ᛄ>

Wyjaśnienie:

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

A000012 (wszystkie) i A007395 (wszystkie dwie pary)

Funkcja, która pobiera dane wejściowe na górze stosu i pozostawia dane wyjściowe na górze stosu.

Wypróbuj online!

Okx
źródło
0

Gaia , 9 bajtów

A000012₉/

Współpracuje z A000012 i A000004 .

Wypróbuj A000012!

Wypróbuj A000004!

Wyjaśnienie

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
Business Cat
źródło
Dlaczego wszyscy nadal publikują A00004 i A00012?
pppery
@ppperry A000004 to sekwencja zerowa, a A000012 to sekwencja jedynek. Wystarczy podzielić podłogę przez 9 i wyprowadzić wynik na zawsze.
Engineer Toast
0

05AB1E , 9 bajtów

A000004¨θ

Wypróbuj online!

Działa dla A000004 i A000012.

Erik the Outgolfer
źródło
0

Łuska , 20 bajtów

Ta zwraca nieco bardziej interesujące sekwencje, ponownie rozwiązania są 1indeksowane.

Działa to dla A000040 (liczby pierwsze):

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

Wypróbuj online!

I ten dla A000045 (liczby Fibonacciego):

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

Wypróbuj online!

Wyjaśnienie

Wykorzystuje to fakt, że ostatnia cyfra nazw sekwencji ma inną parzystość:

                      -- 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
ბიმო
źródło
0

AHK , 40 bajtów

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

Wynik: 0,0,0,0,0,0,0,0,0,0,0,0,...

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

Wynik: 1,1,1,1,1,1,1,1,1,1,1,1,...

To może nie jest najkrótszy kod, ale założę się, że jest to najkrótsza para sekwencji, jaką możemy znaleźć. A000004 to sekwencja zerowa, a A000012 to sekwencja jedynek. Po prostu podziel liczbę przez 9 i wyprowadź wynik na zawsze.

Inżynier Toast
źródło
0

QBIC , 28 bajtów

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

Przełącza między sekwencjami A000034 (1, 2, 1, 2, 1 ...) i A000035 (0, 1, 0, 1, 0, 1 ...)

Wyjaśnienie

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
źródło
0

Łuska , 16 bajtów

Oba rozwiązania są 1indeksowane.

Działa to dla A000351 (moce 5):

!¡*i!6"A000351"1

Wypróbuj online!

A ten dla A000007 (potęgi 0):

!¡*i!6"A000007"1

Wypróbuj online!

Wyjaśnienie

Wykorzystuje to, że nazwy A000351 , A000007 zawierają prawą cyfrę D w pozycji 6, tak że sekwencja jest 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
ბიმო
źródło