งานของคุณคือการเขียนรหัสบางอย่างที่ส่งออกลำดับ OEIS และมีชื่อของลำดับในรหัส ( A______) ง่ายพอใช่ไหม นี่คือการจับรหัสของคุณจะต้องส่งออกลำดับที่สองแยกเมื่อชื่อของลำดับในรหัสเปลี่ยนเป็นชื่อของลำดับที่สอง

อินพุตเอาต์พุต

รหัสของคุณอาจเป็นฟังก์ชั่นหรือโปรแกรมที่สมบูรณ์ที่ใช้nผ่านวิธีการป้อนข้อมูลมาตรฐานและส่งออกคำที่nของลำดับตามดัชนีโดยดัชนีที่ให้ไว้ในหน้า OEIS

คุณต้องสนับสนุนค่าทั้งหมดที่มีให้ในไฟล์ OEIS b สำหรับลำดับนั้นหมายเลขใด ๆ ที่ไม่ได้อยู่ในไฟล์ b ไม่จำเป็นต้องได้รับการสนับสนุน

เกณฑ์การให้คะแนน

นี่คือ รหัสกอล์ฟ. คะแนนของคุณจะเป็นจำนวนไบต์ในรหัสของคุณโดยน้อยกว่าจะดีกว่า

ตัวอย่าง

นี่คือตัวอย่างใน Haskell ที่ใช้งานได้กับ A000217 และ A000290

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

ลองออนไลน์!

JavaScript (ES6), 16 15 ไบต์

n=>4&~0xA000004

ใช้งานได้กับ A000004 (ทั้งหมด 0 วินาที) และ A010709 (ทั้ง 4s)

โซลูชัน 17 ไบต์ก่อนหน้านี้ทำงานร่วมกับ A010850 ถึง A010859 แบบรวม:

n=>~-0xA010850%36

โซลูชัน 25 ไบต์ก่อนหน้านี้ทำงานร่วมกับ A010850 ถึง A010871

n=>"A010850".slice(5)-39

C #, 28 ไบต์

n=>n*n*("A000290"[6]<49?1:n)

ทำงานร่วมกับA000290 (สแควร์)และA000578 (ก้อน)

ลองออนไลน์!

Haskell, 28 ไบต์

f x|"A000012"!!6<'3'=1|1<2=x

ลำดับที่สองคือ A007953 ลองออนไลน์!

cQuents , 16 ไบต์

=A000007//5#|A:0

ลองออนไลน์! , A000007 ,1,0,0,0,0...

=A000004//5#|A:0

ลองออนไลน์! , A000004 ,0,0,0,0,0...

คำอธิบาย

                    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

ขอขอบคุณที่ Conor โอไบรอันสำหรับและ4//5 = 07//5 = 1

หากข้อมูลจำเพาะเป็นความยืดหยุ่นมากขึ้นก็จะเป็นและO7A$O4A$

Cubix , 28 ไบต์

I:uU**...L..A000578@O\s<s(;?

ส่งคืนลูกบาศก์ที่สมบูรณ์แบบ , a(n)=n^3.

ลองออนไลน์!

ในทางกลับกัน,

I:uU**...L..A068601@O\s<s(;?

ส่งคืนลูกบาศก์ที่สมบูรณ์แบบลบหนึ่ง , a(n)=n^3-1.

dc , 13 ไบต์

แก้ไข:เห็นได้ชัดว่า OEIS แสดงรายการพลังจาก0th ถึง30th - ฉันเพิ่งค้นหาลำดับเหล่านี้และปรากฎว่า13โซลูชัน byte ดั้งเดิมคือ golfiest แต่ฉันได้พบวิธีแก้ปัญหาอื่นเพียงแค่1ไบต์เพิ่มเติมที่ทำงานสำหรับ9ลำดับ

คำตอบสำหรับA000012 (ลำดับ 1 คงที่):

?A000012 4%^p

ลองออนไลน์!

โซลูชั่นสำหรับA001477 (จำนวนเต็มไม่เป็นลบ):

?A001477 4%^p

ลองออนไลน์!

โซลูชันสำหรับA000290 (ลำดับกำลังสองสมบูรณ์แบบ):

?A000290 4%^p

ลองออนไลน์!

Ungolfed / คำอธิบาย

โซลูชั่นเหล่านี้ใช้ประโยชน์จากความจริงที่ว่าdcตีความAเป็น10เพื่อให้กลายเป็นค่าA001477 10001477นอกจากนี้มันหาประโยชน์ที่วนเวียนอยู่n^0, n^1และn^2ที่เกิดขึ้นพร้อมกับ10000012 % 4 == 0, และ10001477 % 4 == 110000290 % 4 == 2

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 ไบต์สำหรับ 9 ลำดับ

ความคิดยังคงเหมือนเดิมคราวนี้เราต้องทำ% 97เพื่อให้ได้พลังที่ถูกต้อง - มันใช้งานได้กับลำดับA010801 , A010802 , A010803 , A010804 , A010804 , A010806 , A010808 , A010808และA010809 (นี่คือลำดับn^13, .. ., n^21)

นี่คือคนแรก:

?A010801 97%^p

ลองออนไลน์!

Python 2, 25 17 ไบต์

print'A000012'[5]

ใช้งานได้กับ A000004 และ A000012 (อินพุตถูกละเว้นเนื่องจากลำดับเป็นเงื่อนไขคงที่ทั้งหมด)

Befunge 98, 10 ไบต์

#A000012$q

ใช้ได้กับ A000004 ด้วย ออกโดยรหัสทางออก

เยลลี่ขนาด 17 ไบต์

“A000578”OS%⁵ạ6*@

ลองออนไลน์!

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

ใช้ได้กับ A000290 ด้วย

PowerShellขนาด 23 ไบต์

+(0xA000012-eq160mb+18)

ลองออนไลน์!

ใช้A000012 (ลำดับทุกคน) และA000004 (ลำดับเลขศูนย์ทั้งหมด)

ยกระดับเทคนิคที่ประณีตหลายอย่าง เราใช้เป็นผู้ประกอบการเลขฐานสิบหกลงบนลำดับซึ่งจะช่วยให้เรา0x 167772178นั่นคือการเปรียบเทียบเพื่อดูว่ามัน-eqจะ160mb+18ใช้mbโอเปอเรเตอร์ ( 160mbคือ167772160) หรือไม่ ว่าผลบูลีนถูกโยนแล้วเป็น int กับ+การส่งออกที่เหมาะสมหรือ1 0โปรดทราบว่าลำดับใด ๆในรหัสอื่นที่ไม่ใช่ A000012 จะส่งผลให้เกิด0ผลลัพธ์

Neim , 10 9 ไบต์

A000012ᛄ>

คำอธิบาย:

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

A000012 (ทุกรายการ) และ A007395 (ทุก twos)

ฟังก์ชันที่รับอินพุตที่ด้านบนของสแต็กและปล่อยเอาต์พุตที่ด้านบนของสแต็ก

ลองออนไลน์!

Gaiaขนาด 9 ไบต์

A000012₉/

ทำงานร่วมกับA000012และA000004

ลอง A000012!

ลอง A000004!

คำอธิบาย

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

PowerShellขนาด 12 ไบต์

'A000012'[5]

ลองออนไลน์!

ใช้งานได้กับ A000012 (ลำดับทุกคน) และ A000004 (ลำดับเลขศูนย์ทั้งหมด)

ท่าเรือppperry คำตอบของงูหลาม

05AB1E , 9 ไบต์

A000004¨θ

ลองออนไลน์!

ใช้งานได้กับ A000004 และ A000012

ที่จริงแล้ว 10 ไบต์

A000004X.⌂

ลองออนไลน์!

ใช้งานได้กับ A000004 และ A000012

เยลลี่ 10 ไบต์

6ị“A000004

ลองออนไลน์!

ใช้งานได้กับ A000004 และ A000012

Pyth, 11 ไบต์

@"A000004"5

ลองที่นี่

รองรับ A000004 และ A000012

Husk , 20 ไบต์

อันนี้กลับมาเป็นลำดับที่น่าสนใจขึ้นอีก1เล็กน้อย

ใช้งานได้กับA000040 (หมายเลขเฉพาะ):

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

ลองออนไลน์!

และอันนี้สำหรับA000045 (ตัวเลขฟีโบนักชี):

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

ลองออนไลน์!

คำอธิบาย

สิ่งนี้ทำให้การใช้ความจริงที่ว่าตัวเลขสุดท้ายของชื่อลำดับมีความเท่าเทียมกันที่แตกต่างกัน:

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

AHK , 40 ไบต์

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

เอาท์พุท: 0,0,0,0,0,0,0,0,0,0,0,0,...

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

เอาท์พุท: 1,1,1,1,1,1,1,1,1,1,1,1,...

นี่อาจไม่ใช่รหัสที่สั้นที่สุด แต่ฉันคิดว่ามันเป็นคู่ลำดับที่สั้นที่สุดที่เราสามารถหาได้ A000004เป็นลำดับศูนย์และA000012เป็นลำดับลำดับ เพียงชั้นแบ่งจำนวนโดย 9 และส่งออกผลลัพธ์ตลอดไป

QBICขนาด 28 ไบต์

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

สิ่งนี้สลับระหว่างลำดับA000034 (1, 2, 1, 2, 1 ... ) และA000035 (0, 1, 0, 1, 0, 1, 0, 1 ... )

คำอธิบาย

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

Husk , 16 ไบต์

โซลูชันทั้งสองถูก1-exexed

ใช้งานได้กับA000351 (พลังของ 5):

!¡*i!6"A000351"1

ลองออนไลน์!

และอันนี้สำหรับA000007 (พลังของ 0):

!¡*i!6"A000007"1

ลองออนไลน์!

คำอธิบาย

มันทำให้การใช้งานที่ชื่อA000351 , A000007มี D หลักที่ถูกต้องที่ตำแหน่ง 6 เช่นลำดับคือ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

MATL , 14 ไบต์

A000027จำนวนเต็มบวก

A000027 3\Gw-&

ลองออนไลน์!

A001477จำนวนเต็มที่ไม่ใช่ค่าลบ

A001477 3\Gw-&

ลองออนไลน์!