Kare sayılar , n^2n'nin bir tamsayı olduğu biçimdeki rakamlardır . Bunlara mükemmel kareler de denir, çünkü karekökünü aldığınızda bir tamsayı elde edersiniz.

İlk 10 kare sayı: ( OEIS )

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

Üçgen sayılar , eşkenar üçgen oluşturabilen sayılardır. N'inci üçgen sayı, 1'den n'ye kadar olan tüm doğal sayıların toplamına eşittir.

İlk 10 üçgen sayı: ( OEIS )

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

Kare üçgen sayılar , hem kare hem de üçgen olan sayılardır .

İlk 10 kare üçgen sayı: ( OEIS )

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

Sonsuz sayıda kare sayı, üçgen sayı ve kare üçgen sayı vardır.

Bir girdi (parametre veya stdin) numarası verilen n, nkare üçgen sayısını hesaplayan ve çıktısını veren / döndüren bir program veya adlandırılmış bir işlev yazın ; burada n, pozitif sıfır olmayan bir sayıdır. (N = 1 için 0 döndürür)

Programın / fonksiyonun geçerli bir sunum olması için, en azından 2 ^ 31-1'den küçük tüm kare üçgen sayılarını döndürebilmesi gerekir.

Bonus

2 ^ 63-1'den küçük tüm kare üçgen sayıları çıktılamak için -4 bayt

Herhangi bir boyutta kare üçgen sayıları teorik olarak çıktılamak için -4 bayt.

Polinom olmayan zaman alan çözümler için +8 bayt ceza.

Bonuslar yığını.

Bu kod-golf meydan okuma, bu yüzden en az bayt ile cevap kazanır.

CJam, 12 8 bayt

XUri{_34*@-Y+}*;

Wikipedia makalesinin yineleme ilişkisini kullanır.

Kod 16 bayt uzunluğundadır ve her iki bonus için de yeterlidir.

CJam yorumlayıcısında çevrimiçi deneyin .

Nasıl çalışır

Kodum değişkenler yerine CJam'ın yığınını kullanmak dışında xnor her zaman her açıdan aynı olduğu ortaya çıktı.

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

Yinelemeyi kullanarak tekrarlar

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

Teorik olarak, bu herhangi bir boyuttaki sayıları destekler, ancak üstel zamanda çalışır, bu yüzden bonuslara hak kazanmamalıdır. Herhangi bir boyuttaki numaralar için çalışmalıdır. Örneğin, 100 için,

1185827220993342542557325920096705939276583904852110550753333094088280194260929920844987597980616456388639477930416411849864965254621398934978872054025

Özyinelemeli bir çözüm 41 karakter kullanır, ancak üstel zaman aldığı için kalifiye olmamalıdır.

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

Pyth, 16-4-4 = 8 bayt

OEIS makalesindeki özyinelemeli formülü kullanır.

K1uhh-*34G~KGtQZ

Oldukça yeni ve gerçekten harika görünen atama sonrası komutunu kullanıyor. n-11 tabanlı dizine ekleme nedeniyle yineleme sürelerini azaltır .

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.

Polinom gibi gözüküyor çünkü n kez dönüyor ve her yinelemede matematik ve ödev yapıyor, ama ben bir bilgisayar bilimcisi değilim. N = 10000'i neredeyse anında bitirir.

Burada çevrimiçi deneyin .

Vaha , 7-4 - 4 = -1 (Müsabaka yok)

34*c-»T

Çevrimiçi deneyin!

Kullanımları a(0) = 0, a(1) = 1; for n >= 2, a(n) = 34 * a(n-1) - a(n-2) + 2

Oasis keyfi hassas tam sayıları destekler, bu nedenle yığın taşması olmadığı sürece herhangi bir sayıya kadar çıkabilmelidir. Yığın taşması nedeniyle bunun bonus için sayılmazsa bana bildirin. Bu özel algoritmanın polinom olmayan olması da mümkündür ve durumun bu olup olmadığını bana bildirin.

Rekabetçi değil, çünkü dil meydan okuma sonrası.

Açıklama:

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

Alternatif çözüm:

-35*d+T

Bunun yerine kullanır a(n) = 35*(a(n-1)-a(n-2)) + a(n-3)

JavaScript (ES6), 29-4 = 25 bayt

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

@IsmaelMiguel sayesinde 5 bayt tasarruf edildi !

Sonsuz özyinelemeyi önlemek için 0, 1 ve negatifleri kodlamak zorunda kaldım.

Konsol, işlevi adlandırdım f:

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

EDIT : JavaScript sayıları 16 (15) basamak (Spec) yuvarlar. 714341252076979033 JavaScript konsolunuza koyun ve kendiniz görün. Daha çok JavaScript sınırlamasıdır

Excel VBA - 90 bayt

Wikipedia sayfasındaki yineleme ilişkisini kullanma:

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

Yürütüldüğünde, sizden n istenir, o zaman n'ye kadar ve n içeren dizi A sütununa çıkar:

Bir taşma hatası vermeden önce n = 202'ye kadar çalıştırılabilir.

[Yarışmıyor] Pyth (14 - 4 - 4 = 6 bayt)

K1u/^tG2~KGQ36

İlk nüks kullanılmış OEIS 0,1,36 sonra bir bulabilirsiniz, _n = (A _{, n-1} -1) ² / A _{, n-2} . A Bu çözüm 36'da başladığı için rekabet etmiyor, eğer aşağıya inerseniz sıfıra bölersiniz (yani 0 girişi 36 verir). Ayrıca hardcode 36 gerekiyordu.

Burada deneyin

Java, 53-4 = 49 bayt

Başka bir basit özyineleme, ancak Java'yı <50 puanla yayınlamıyorum, bu yüzden ...

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

Şimdi, bir şey için sigara -Recursive, oldukça biraz daha uzun olur. Bu hem daha uzun (112-4 = 108) -ve- daha yavaş, bu yüzden yinelenen bir şey dışında neden yayınladığımdan emin değilim:

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

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

Bu, kare üçgen sayılar için Wikipedia sayfasında listelenen ilk yineleme ilişkisini kullanır. 0.006 saniyede n = 1000 ve 6.93 saniyede n = 100000 hesaplar . Birkaç bayt uzun bir özyinelemeli çözümü daha var ama bu kadar yolu daha hızlı.

Ungolfed + açıklaması:

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

Örnekler:

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 bayt

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

kareköküne kadar tekrar $s∈ℤ olup: eklenti $ftoplamı $s, artış $f;
tekrarlama $argv[1]süreleri.
çıktı toplamı.

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

Koşu n(100,R)çıkışları:

X = 40283218019606612026870715051828504163181534465162581625898684828251284020309760525686544840519804069618265491900426463694050293008018241080068813316496

n(10000,X)Bilgisayarımda çalıştırmak yaklaşık 1 saniye sürer.

Düzenleme : 66 sürümü kuyruk özyinelemeli. Önceki kuyruk özyinelemesiz sürüm aşağıdaki gibidir:

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.

Bayt cinsinden aynı uzunluğa sahiptirler, ancak kuyruk olmayan özyinelemeli, belirli bir noktadan (bilgisayarımda 20500 civarında) yığın taşmaları oluşturur.

Javascript ES6, 77 75 71 karakter

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

• Çözelti doğrusaldır.
• Çözüm, sayı türü nedeniyle 2 ^ 53'ten küçük tüm sayıları çıktılayabilir.
• Algoritmanın kendisi sınırsız sayı için kullanılabilir.

Ölçek:

f(11)

0
1
36
1225
41616
1413721
48024900
1631432881
55420693056
1882672131025
63955431761796

C, 68 bayt

Bu C ile eğlenceli bir mücadeleydi

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

Buradan çalıştığını izleyin: https://ideone.com/0ulGmM

Jöle , 13-8 = 5 bayt

Bu her iki bonus için de geçerlidir.

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

Çevrimiçi deneyin!

Yanında Yapıldı Caird coinheringaahing içinde sohbet .

açıklama

× 8 ', µÆ²Ạ ~ Yardımcı bağlantı.

× Sayının 8 ~ 8 katı.
  '~ Artış.
   , ~ Geçerli numara ile eşleştirildi.
    µ ~ Yeni bir monadik (1-arg) bağlantı başlatır.
     Vector² ~ Vectorized "Kare mi?".
       All ~ Hepsi. Yalnızca her ikisi de doğruysa 1 döndürün.



0Ç # Ṫ ~ Ana bağlantı.

0 # ~ 0'dan başlayarak, uygulandığında ilk N tamsayıları doğru sonuçlarla toplayın:
 Ç ~ Monad olarak son halka.
   ~ Son öğe. Çıktı dolaylı olarak.

Perl 6 , 25-8 = 17 bayt

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

Çevrimiçi deneyin!

05AB1E , 10-8 = 2 bayt

1ÎGDŠ34*Ìα

Çevrimiçi deneyin!

APL (NARS), 67 karakter, 134 bayt

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

Ölçek:

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

f, üçgen sayı olan elemanları da ikinci dereceden bir sırada arar, bu yüzden APL'lerde üçgen kontrol formülünü takip etmeleri gerekir: 0 = 1∣√1 + 8 × m, m sayısı ile kontrol edilmelidir.