ตัวเลขสแควร์คือตัวเลขที่อยู่ในรูปของn^2ที่ซึ่ง n เป็นจำนวนเต็ม สิ่งเหล่านี้เรียกอีกอย่างว่าสี่เหลี่ยมที่สมบูรณ์แบบเพราะเมื่อคุณนำสแควร์รูทของมันมาคุณจะได้จำนวน

ตัวเลข 10 ตารางแรกคือ: ( OEIS )

0, 1, 4, 9, 16, 25, 36, 49, 64, 81

ตัวเลขสามเหลี่ยมคือตัวเลขที่สามารถสร้างรูปสามเหลี่ยมด้านเท่า ตัวเลขสามเหลี่ยม n-th เท่ากับผลรวมของจำนวนธรรมชาติทั้งหมดจาก 1 ถึง n

ตัวเลขสามเหลี่ยม 10 ตัวแรกคือ: ( OEIS )

0, 1, 3, 6, 10, 15, 21, 28, 36, 45

ตัวเลขสามเหลี่ยมจตุรัสคือตัวเลขที่มีทั้งสี่เหลี่ยมจัตุรัสและสามเหลี่ยม

หมายเลขสามเหลี่ยม 10 ตารางแรกคือ: ( OEIS )

0, 1, 36, 1225, 41616, 1413721, 48024900, 1631432881, 55420693056, 1882672131025, 63955431761796

มีจำนวนอนันต์ของหมายเลขสแควร์, สามเหลี่ยมและสามเหลี่ยมสแควร์

เขียนโปรแกรมหรือฟังก์ชั่นที่มีชื่อที่ได้รับจำนวนอินพุต (พารามิเตอร์หรือ stdin) nคำนวณnจำนวนสามเหลี่ยมที่สามตารางและเอาท์พุท / ส่งกลับโดยที่ n เป็นจำนวนที่ไม่ใช่ศูนย์บวก (สำหรับ n = 1 ผลตอบแทน 0)

สำหรับโปรแกรม / ฟังก์ชั่นที่จะส่งที่ถูกต้องมันควรจะสามารถส่งกลับอย่างน้อยจำนวนสามเหลี่ยมรูปสี่เหลี่ยมจัตุรัสขนาดเล็กกว่า 2 ^ 31-1

โบนัส

-4 ไบต์สำหรับความสามารถในการแสดงผลตัวเลขสามเหลี่ยมทั้งหมดน้อยกว่า 2 ^ 63-1

-4 ไบต์สำหรับความสามารถในการส่งออกในทางทฤษฎีตัวเลขรูปสามเหลี่ยมขนาดใด ๆ

การลงโทษ +8 ไบต์สำหรับวิธีการแก้ปัญหาที่ใช้เวลาแบบไม่พหุนาม

กองซ้อนโบนัส

นี่คือความท้าทายของ code-golf ดังนั้นคำตอบที่มีจำนวนไบต์น้อยที่สุดจะเป็นผู้ชนะ

CJam, 12 8 ไบต์

XUri{_34*@-Y+}*;

ใช้ความสัมพันธ์ที่เกิดซ้ำจากบทความ Wikipedia

รหัสมีความยาว 16 ไบต์และมีคุณสมบัติสำหรับโบนัสทั้งสอง

ลองใช้ออนไลน์ในล่าม CJam

มันทำงานอย่างไร

รหัสของฉันกลายเป็นเหมือนกับ xnor ในทุก ๆ ด้านยกเว้นว่าฉันใช้ CJam ของกองซ้อนแทนที่จะเป็นตัวแปร

XU               e# Push 1 and 0 on the stack.
                 e# Since 34 * 0 - 1 + 2 = 1, this compensates for 1-based indexing.
  ri{        }*  e# Do int(input()) times:
     _34*        e#   Copy the topmost integer and multiply it by 34.
         @-      e#   Subtract the bottommost integer from the result.
           Y+    e#   Add 2.
               ; e# Discard the last result.

Python 2, 45 - 4 - 4 = 37

a=1;b=0
exec"a,b=b,34*b-a+2;"*input()
print a

ทำซ้ำโดยใช้ reccurence

f(0) = 1
f(1) = 0
f(k) = 34*f(k-1)-f(k-2)+2

ตามทฤษฎีแล้วสิ่งนี้รองรับจำนวนขนาดใดก็ได้ แต่จะทำงานในเวลาแบบเอ็กซ์โพเนนเชียลดังนั้นจึงไม่ควรมีสิทธิ์ได้รับโบนัส ควรทำงานกับตัวเลขทุกขนาด ตัวอย่างเช่นสำหรับ 100 ให้

1185827220993342542557325920096705939276583904852110550753333094088280194260929920844987597980616456388639477930416411849864965254621398934978872054025

โซลูชันแบบเรียกซ้ำใช้ 41 ตัวอักษร แต่ไม่ควรมีสิทธิ์เนื่องจากต้องใช้เวลาชี้แจง

f=lambda k:k>2and 34*f(k-1)-f(k-2)+2or~-k

Pyth, 16 - 4 - 4 = 8 ไบต์

ใช้สูตรแบบเรียกซ้ำจากบทความ OEIS

K1uhh-*34G~KGtQZ

มันใช้คำสั่ง post-assign ซึ่งค่อนข้างใหม่และดูดีจริงๆ ใช้การลดการวนซ้ำn-1เนื่องจากการทำดัชนีแบบ 1

K1            Set K=1
u       tQ    Reduce input()-1 times
         Z    With zero as base case
 hh            +2
  -           Subtract
   *34G       34 times iterating variable
   ~K         Assign to K and use old value
    G         Assign the iterating variable.

ดูเหมือนว่าจะเป็นพหุนามเพราะมันวนซ้ำและทำคณิตศาสตร์และกำหนดซ้ำแต่ละครั้ง แต่ฉันไม่ใช่นักวิทยาศาสตร์คอมพิวเตอร์ เสร็จสิ้น n = 10,000 เกือบจะในทันที

ลองมันนี่เกมออนไลน์

โอเอซิส , 7 - 4 - 4 = -1 (ไม่แข่งขัน)

34*c-»T

ลองออนไลน์!

การใช้ประโยชน์ a(0) = 0, a(1) = 1; for n >= 2, a(n) = 34 * a(n-1) - a(n-2) + 2

โอเอซิสรองรับจำนวนเต็มความแม่นยำโดยพลการดังนั้นมันควรจะสามารถไปถึงจำนวนใด ๆ ตราบใดที่ไม่มีกองล้นที่เกิดขึ้น แจ้งให้เราทราบว่าสิ่งนี้จะไม่นับรวมกับโบนัสเพราะกองซ้อนล้น อาจเป็นไปได้ว่าอัลกอริทึมนี้ไม่ใช่พหุนามและแจ้งให้เราทราบหากเป็นเช่นนั้น

ไม่แข่งขันเนื่องจากภาษาโพสต์วันท้าทาย

คำอธิบาย:

34*c-»T -> 34*c-»10

a(0) = 0
a(1) = 1
a(n) = 34*c-»

34*c-»
34*    # 34*a(n-1)
   c-  # 34*a(n-1)-a(n-2)
     » # 34*a(n-1)-a(n-2)+2

ทางเลือกอื่น ๆ :

-35*d+T

ใช้แทน a(n) = 35*(a(n-1)-a(n-2)) + a(n-3)

JavaScript (ES6), 29-4 = 25 ไบต์

n=>n>1?34*f(n-1)-f(n-2)+2:n|0

บันทึก 5 ไบต์ด้วย@IsmaelMiguel !

ฉันต้อง hardcode 0, 1 และเชิงลบเพื่อหลีกเลี่ยงการเรียกซ้ำไม่สิ้นสุด

คอนโซลฉันได้ตั้งชื่อฟังก์ชั่นf:

f(1);  // 0
f(13); // 73804512832419600
f(30); // 7.885505171090779e+42 or 7885505171090779000000000000000000000000000

แก้ไข : เปลี่ยนเป็น JavaScript จะปัดเศษตัวเลขเป็น 16 (15) หลัก(ข้อมูลจำเพาะ)เนื่องจากตัวเลขเหล่านี้ใหญ่เกินไปทำให้เกิดการโอเวอร์โฟลว์ ใส่ 714341252076979033 ในคอนโซล JavaScript ของคุณและดูเอง มันเป็นข้อ จำกัด ของ JavaScript

Excel VBA - 90 ไบต์

การใช้ความสัมพันธ์ที่เกิดซ้ำจากหน้า Wikipedia:

n = InputBox("n")
x = 0
y = 1
For i = 1 To n
Cells(i, 1) = x
r = 34 * y - x + 2
x = y
y = r
Next i

เมื่อถูกดำเนินการคุณจะได้รับพร้อมต์สำหรับ n ลำดับนั้นจนถึงและรวมถึง n คือเอาต์พุตไปยังคอลัมน์ A:

มันสามารถทำงานได้ถึงและรวมถึง n = 202 ก่อนที่จะให้ข้อผิดพลาดมากเกินไป

[ไม่แข่งขัน] Pyth (14 - 4 - 4 = 6 ไบต์)

K1u/^tG2~KGQ36

ใช้การกำเริบแรกจากOEISว่าหลังจากที่ 0,1,36 คุณสามารถหา_n = (A _n-1 -1) ² / A n-2 A ไม่แข่งขันเนื่องจากโซลูชันนี้เริ่มต้นที่ 36 ถ้าคุณลดลงคุณจะหารด้วยศูนย์ (ดังนั้นการป้อน 0 เท่ากับ 36) นอกจากนี้ยังมี hardcode 36

ลองที่นี่

Java, 53 - 4 = 49 ไบต์

เป็นการเรียกซ้ำง่าย ๆ แต่ฉันมักจะไม่ได้โพสต์ Java ด้วยคะแนนน้อยกว่า 50 คะแนนดังนั้น ...

long g(int n){return n<2?n<1?1:0:34*g(n-1)-g(n-2)+2;}

ทีนี้สำหรับสิ่งที่ไม่ใช่แบบเรียกซ้ำมันจะค่อนข้างยาวไปหน่อย อันนี้ยาวกว่า (112-4 = 108) - และ - ช้ากว่าดังนั้นฉันไม่แน่ใจว่าทำไมฉันจึงโพสต์มันยกเว้นจะมีบางอย่างซ้ำ ๆ :

long f(int n){long a=0,b,c,d=0;for(;a<1l<<32&n>0;)if((c=(int)Math.sqrt(b=(a*a+a++)/2))*c==b){d=b;n--;}return d;}

Julia, 51 ไบต์ - 4 - 4 = 43

f(n)=(a=b=big(1);b-=1;for i=1:n a,b=b,34b-a+2end;a)

สิ่งนี้ใช้ความสัมพันธ์การเกิดซ้ำครั้งแรกที่ระบุไว้ในหน้า Wikipedia สำหรับตัวเลขสามเหลี่ยมจตุรัส มันคำนวณn = 1,000 ใน 0.006 วินาทีและn = 100000 ใน 6.93 วินาที มันเป็นเพียงไม่กี่ไบต์นานกว่าการแก้ปัญหา recursive แต่มันก็เป็นวิธีที่เร็วขึ้น

คำอธิบาย Ungolfed +:

function f(n)
    # Set a and b to be big integers
    a = big(1)
    b = big(0)

    # Iterate n times
    for i = 1:n
        # Use the recurrence relation, Luke
        a, b = b, 34*b - a + 2
    end

    # Return a
    a
end

ตัวอย่าง:

julia> for i = 1:4 println(f(i)) end
0
1
36
1225

julia> @time for i = 1:1000 println(f(i)) end
0
... (further printing omitted here)
elapsed time: 1.137734341 seconds (403573226 bytes allocated, 38.75% gc time)

PHP, 65 59 56-4 = 52 ไบต์

while($argv[1]--)while((0|$r=sqrt($s+=$f++))-$r);echo$s;

ทำซ้ำจนกระทั่งรากที่สองของ$sคือ∈ℤ: เพิ่ม$fผลรวม$sเพิ่มขึ้น$f;
ทำซ้ำ$argv[1]ครั้ง
ผลรวมเอาท์พุท

Prolog, 70 74 - 4 - 4 = 66

n(X,R):-n(X,0,1,R).
n(X,A,B,R):-X=0,R=A;Z is X-1,E is 34*B-A+2,n(Z,B,E,R).

วิ่งn(100,R)ออก:

X = 40283218019606612026870715051828504163181534465162581625898684828251284020309760525686544840519804069618265491900426463694050293008018241080068813316496

ใช้เวลาประมาณ 1 วินาทีในการทำงานn(10000,X)บนคอมพิวเตอร์ของฉัน

แก้ไข : รุ่น 66 เป็นแบบเรียกซ้ำ เวอร์ชันที่ไม่ใช่หางแบบเรียกซ้ำก่อนหน้านี้มีดังต่อไปนี้:

n(X,[Z|R]):-X>1,Y is X-1,n(Y,R),R=[A,B|_],Z is 34*A-B+2;X=1,Z=1,R=[0];Z=0.

พวกมันมีความยาวเท่ากันในไบต์ แต่ส่วนที่ไม่ใช่หางแบบเรียกซ้ำนั้นจะสร้างสแต็กโอเวอร์โฟลว์ที่ผ่านจุดหนึ่ง (บนคอมพิวเตอร์ของฉันประมาณ 20500)

Javascript ES6, 77 75 71 ตัวอักษร

// 71 chars
f=n=>{for(q=t=w=0;n;++q)for(s=q*q;t<=s;t+=++w)s==t&&--n&console.log(s)}

// No multiplication, 75 chars
f=n=>{for(s=t=w=0,q=-1;n;s+=q+=2)for(;t<=s;t+=++w)s==t&&--n&console.log(s)}

// Old, 77 chars
f=n=>{for(s=t=w=0,q=-1;n;s+=q+=2){for(;t<s;t+=++w);s==t&&--n&console.log(s)}}

• การแก้ปัญหาเป็นเชิงเส้น
• การแก้ปัญหาสามารถส่งออกตัวเลขทั้งหมดน้อยกว่า 2 ^ 53 เพราะประเภทตัวเลข
• อัลกอริธึมเองสามารถใช้กับจำนวนไม่ จำกัด

ทดสอบ:

f(11)

0
1
36
1225
41616
1413721
48024900
1631432881
55420693056
1882672131025
63955431761796

C, 68 ไบต์

นี่เป็นความท้าทายที่สนุกกับซี

main(o,k){o==1?k=0:0;k<9e9&&k>=0&&main(34*o-k+2,o,printf("%d,",k));}

ดูมันทำงานที่นี่: https://ideone.com/0ulGmM

เยลลี่ , 13 - 8 = 5 ไบต์

สิ่งนี้มีคุณสมบัติสำหรับโบนัสทั้งสองอย่าง

×8‘,µÆ²Ạ
0Ç#Ṫ

ลองออนไลน์!

ทำควบคู่ไปกับCaird coinheringaahingในการแชท

คำอธิบาย

× 8 ', µÆ²Ạ ~ ตัวช่วยลิงก์

× 8 ~ 8 คูณจำนวน
  '~ เพิ่มขึ้น
   , ~ จับคู่กับหมายเลขปัจจุบัน
    µ ~ เริ่มลิงค์ monadic (1-arg) ใหม่
     Ʋ ~ Vectorized "Is Square?"
       Ạ ~ ทั้งหมด กลับ 1 เฉพาะเมื่อทั้งสองเป็นความจริง



0Ç # Ṫ ~ ลิงก์หลัก

0 # ~ เริ่มต้นจาก 0 รวบรวมจำนวนเต็ม N แรกด้วยผลลัพธ์จริงเมื่อใช้:
 Ç ~ ลิงก์สุดท้ายเป็น monad
   Ṫ ~ องค์ประกอบสุดท้าย ผลผลิตโดยปริยาย

Perl 6 , 25 - 8 = 17 ไบต์

{(0,1,2-*+34* *…*)[$_]}

ลองออนไลน์!

05AB1E , 10 - 8 = 2 ไบต์

1ÎGDŠ34*Ìα

ลองออนไลน์!

APL (NARS), 67 ตัวอักษร, 134 ไบต์

r←f w;c;i;m
c←0⋄i←¯1⋄r←⍬
→2×⍳0≠1∣√1+8×m←i×i+←1⋄r←r,m⋄→2×⍳w>c+←1

ทดสอบ:

  f 10
0 1 36 1225 41616 1413721 48024900 1631432881 55420693056 1882672131025 

f จะค้นหาลำดับที่เป็นกำลังสองขององค์ประกอบที่เป็นจำนวนรูปสามเหลี่ยมเช่นกันดังนั้นพวกเขาจะต้องทำตามสูตรการตรวจสอบรูปสามเหลี่ยมใน APLs: 0 = 1∣√1 + 8 × m ด้วยหมายเลข m เพื่อตรวจสอบ