Số vuông là những số có dạng n^2n trong đó là một số nguyên. Chúng cũng được gọi là hình vuông hoàn hảo, bởi vì khi bạn lấy căn bậc hai của chúng, bạn sẽ có được một số nguyên.

10 số vuông đầu tiên là: ( OEIS )

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

Số tam giác là số có thể tạo thành một tam giác đều. Số tam giác thứ n bằng tổng của tất cả các số tự nhiên từ 1 đến n.

10 số tam giác đầu tiên là: ( OEIS )

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

Số tam giác vuông là số có cả hình vuông và hình tam giác.

10 số tam giác vuông đầu tiên là: ( OEIS )

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

Có vô số số vuông, số tam giác và số tam giác vuông.

Viết chương trình hoặc hàm được đặt tên có số đầu vào (tham số hoặc stdin) n, tính toán nsố tam giác vuông thứ ba và xuất / trả về nó, trong đó n là số khác không dương. (Với n = 1 trả về 0)

Để chương trình / hàm trở thành một đệ trình hợp lệ, nó sẽ có thể trả về ít nhất tất cả các số tam giác vuông nhỏ hơn 2 ^ 31-1.

Tặng kem

-4 byte để có thể xuất tất cả các số tam giác vuông nhỏ hơn 2 ^ 63-1

-4 byte để có thể đưa ra các số tam giác vuông có kích thước bất kỳ về mặt lý thuyết.

+8 byte hình phạt cho các giải pháp mất thời gian không đa thức.

Thưởng chồng.

Đây là thử thách chơi gôn, vì vậy câu trả lời có ít byte nhất sẽ thắng.

CJam, 12 8 byte

XUri{_34*@-Y+}*;

Làm cho việc sử dụng các mối quan hệ lặp lại từ bài viết Wikipedia.

Mã này dài 16 byte và đủ điều kiện cho cả hai phần thưởng.

Hãy thử trực tuyến trong trình thông dịch CJam .

Làm thế nào nó hoạt động

Mã của tôi hóa ra giống hệt với xnor ở mọi khía cạnh, ngoại trừ việc tôi sử dụng ngăn xếp của CJam thay vì các biến.

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.

Trăn 2, 45 - 4 - 4 = 37

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

Lặp đi lặp lại bằng cách sử dụng reccurence

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

Về lý thuyết, điều này hỗ trợ các số có kích thước bất kỳ, nhưng chạy theo thời gian theo cấp số nhân, vì vậy nó không đủ điều kiện nhận tiền thưởng. Nên làm việc cho số lượng kích thước bất kỳ. Ví dụ: cho 100, cho

1185827220993342542557325920096705939276583904852110550753333094088280194260929920844987597980616456388639477930416411849864965254621398934978872054025

Một giải pháp đệ quy sử dụng 41 ký tự, nhưng không đủ điều kiện vì mất thời gian theo cấp số nhân.

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

Bình thường, 16 - 4 - 4 = 8 byte

Sử dụng công thức đệ quy từ bài báo OEIS.

K1uhh-*34G~KGtQZ

Nó sử dụng lệnh post-gán khá mới và có vẻ rất tuyệt. Sử dụng giảm xuống số n-1lần lặp lại vì lập chỉ mục dựa trên 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.

Có vẻ là đa thức vì nó lặp đi lặp lại n lần và thực hiện phép toán & chỉ định mỗi lần lặp, nhưng tôi không phải là nhà khoa học máy tính. Kết thúc n = 10000 gần như ngay lập tức.

Hãy thử nó ở đây trực tuyến .

Oasis , 7 - 4 - 4 = -1 (Không cạnh tranh)

34*c-»T

Hãy thử trực tuyến!

Công dụng a(0) = 0, a(1) = 1; for n >= 2, a(n) = 34 * a(n-1) - a(n-2) + 2

Oasis hỗ trợ các số nguyên chính xác tùy ý, do đó, nó có thể đi lên bất kỳ số nào miễn là không xảy ra tình trạng tràn ngăn xếp. Hãy cho tôi biết nếu điều này không được tính cho phần thưởng vì chồng tràn. Cũng có thể thuật toán cụ thể này là không đa thức, và cho tôi biết nếu đó là trường hợp.

Không cạnh tranh vì thách thức ngôn ngữ.

Giải trình:

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

Giải pháp thay thế:

-35*d+T

Thay vào đó sử dụng a(n) = 35*(a(n-1)-a(n-2)) + a(n-3)

JavaScript (ES6), 29-4 = 25 byte

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

Đã lưu 5 byte nhờ @IsmaelMiguel !

Tôi đã phải mã hóa 0, 1 và các phủ định để tránh đệ quy vô hạn.

Bảng điều khiển, tôi đã đặt tên cho chức năng , f:

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

EDIT : Hóa ra JavaScript sẽ làm tròn các số thành 16 (15) chữ số (Spec) vì những số này quá lớn gây ra tràn. Đặt 714341252076979033 Trong bảng điều khiển JavaScript của bạn và tự mình xem. Đó là một hạn chế của JavaScript

VBA Excel - 90 byte

Sử dụng mối quan hệ lặp lại từ trang 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

Khi thực hiện, bạn được nhắc cho n, sau đó chuỗi lên đến và bao gồm n được xuất ra cột A:

Nó có thể được chạy tới và bao gồm n = 202 trước khi nó xảy ra lỗi tràn.

[Không cạnh tranh] Pyth (14 - 4 - 4 = 6 byte)

K1u/^tG2~KGQ36

Đã sử dụng lần tái phát đầu tiên từ OEIS , sau 0,1,36 bạn có thể tìm thấy A _n = (A _n-1 -1) ² / A _n-2 . A Không cạnh tranh vì giải pháp này bắt đầu từ 36, nếu bạn xuống thấp hơn, bạn chia cho 0 (vì vậy đầu vào 0 cho 36). Cũng phải mã hóa cứng 36.

Hãy thử nó ở đây

Java, 53 - 4 = 49 byte

Đó là một đệ quy đơn giản khác, nhưng tôi không thường xuyên đăng bài Java với số điểm <50, vì vậy ...

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

Bây giờ, đối với một cái gì đó không hấp dẫn, nó sẽ khá lâu hơn một chút. Cái này dài hơn cả (112-4 = 108) -và chậm hơn, vì vậy tôi không chắc tại sao tôi lại đăng nó ngoại trừ có một cái gì đó lặp đi lặp lại:

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 byte - 4 - 4 = 43

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

Điều này sử dụng mối quan hệ lặp lại đầu tiên được liệt kê trên trang Wikipedia cho các số tam giác vuông. Nó tính n = 1000 trong 0,006 giây và n = 100000 trong 6,93 giây. Đó là một vài byte dài hơn một giải pháp đệ quy nhưng nó cách nhanh hơn.

Ungolfed + giải thích:

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

Ví dụ:

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 byte

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

lặp lại cho đến khi căn bậc hai của $s: thêm $fvào tổng $s, tăng $f;
lặp lại $argv[1]lần.
tổng đầu ra.

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

Chạy n(100,R)đầu ra:

X = 40283218019606612026870715051828504163181534465162581625898684828251284020309760525686544840519804069618265491900426463694050293008018241080068813316496

Mất khoảng 1 giây để chạy n(10000,X)trên máy tính của tôi.

Chỉnh sửa : Phiên bản 66 là đệ quy đuôi. Phiên bản đệ quy không đuôi trước đây là như sau:

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.

Chúng có cùng độ dài tính bằng byte nhưng không đệ quy tạo ra ngăn xếp tràn qua một điểm nhất định (trên máy tính của tôi, khoảng năm 20500).

Javascript ES6, 77 75 71 ký tự

// 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)}}

• Giải pháp là tuyến tính.
• Giải pháp có thể xuất tất cả các số nhỏ hơn 2 ^ 53 vì loại số.
• Các thuật toán có thể được sử dụng cho số lượng không giới hạn.

Kiểm tra:

f(11)

0
1
36
1225
41616
1413721
48024900
1631432881
55420693056
1882672131025
63955431761796

C, 68 byte

Đây là một thử thách thú vị với C

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

Xem nó chạy ở đây: https://ideone.com/0ulGmM

Thạch , 13 - 8 = 5 byte

Điều này đủ điều kiện cho cả hai tiền thưởng.

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

Hãy thử trực tuyến!

Thực hiện cùng với caird coinheringaahing trong trò chuyện .

Giải trình

× 8 ', từƲẠ ~ Liên kết trợ giúp.

× 8 ~ 8 lần số.
  '~ Tăng.
   , ~ Ghép nối với số hiện tại.
    Tổ hợp ~ Bắt đầu một liên kết đơn âm (1-arg) mới.
     Ʋ ~ Vectorized "Là hình vuông?".
       Ạ ~ Tất cả. Trả lại 1 chỉ khi cả hai là sự thật.



0Ç # Ṫ ~ Liên kết chính.

0 # ~ Bắt đầu từ 0, thu thập số nguyên N đầu tiên với kết quả trung thực, khi được áp dụng:
 Ç ~ Liên kết cuối cùng là một đơn nguyên.
   ~ Yếu tố cuối cùng. Đầu ra ngầm.

Perl 6 , 25 - 8 = 17 byte

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

Hãy thử trực tuyến!

05AB1E , 10 - 8 = 2 byte

1ÎGDŠ34*Ìα

Hãy thử trực tuyến!

APL (NARS), 67 ký tự, 134 byte

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

kiểm tra:

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

f cũng sẽ tìm kiếm theo thứ tự bậc hai các phần tử là số tam giác, vì vậy chúng phải tuân theo công thức kiểm tra tam giác trong các APL: 0 = 1∣√1 + 8 × m với số m để kiểm tra.