Binom karesini göstermek

28

İki farklı doğal sayı (herhangi bir makul büyüklükte) verilen (herhangi bir şekilde), aşağıdaki örneklerde olduğu gibi toplamlarının karesini çıktı (herhangi bir şekilde):

Verilen 4 ve 3, çıktı:

12 12 12 12  9  9  9
12 12 12 12  9  9  9
12 12 12 12  9  9  9
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12

Verilen 1 ve 3, çıktı:

3 9 9 9
3 9 9 9
3 9 9 9
1 3 3 3

Boşluk nedene göre değişebilir, ancak sütunlar sola hizalı, sağa hizalı veya (sahte) ortalanmış olmalıdır.

Sondaki yeni satır iyi, ancak standart boşluklar değil.

Bu kod-golf'dür, bu nedenle # LanguageName, 123cevabınızdaki gibi bir başlık içerir ; buradaki sayının karakterleridir (metin tabanlı olmayan diller için bayt). Kodun büyük Unicode karakterlerine gönderilmesine izin verilmez.

Bonus: -3, sayılardan biri 0 olduğunda kodunuz yalnızca bir kare çıkarsa; örneğin verilen 0 ve 3, çıktı:

9 9 9
9 9 9
9 9 9
code-golf  math  arithmetic  array-manipulation  grid 
— Adem
kaynak
Giriş numaralarının maksimum değeri nedir? Teşekkürler.
— don parlak
1
@ Donbright Yapay limit yok. Yalnızca sınırlama, bilgisayarınızın ve dilinizin temsil, hesaplama (seçtiğiniz algoritma ile) ve sonuç söz konusu olduğunda ne yapabileceğidir. Potansiyel olarak, satır satır veri kabul eden bir yazıcıya sahip modern bir bilgisayar neredeyse sınırsız olurdu ... :-)
— Adám
Kare yönü verilen mi, yoksa 90 derece döndürebilir miyiz?
— John Dvorak
1
Neden 0 değer için bonus olsa? Sadece bir kare olmasaydı beklenen çıktı ne olurdu?
— Mart Ho,
@MarchHo Bu yüzden bonus bu kadar küçük. Yine de, bazı diller boş dizileri kullanamayabilir.
— Ad’m

Yanıtlar:

14

J, 9 bayt - 3 = 6

#~@|.*/#~

@ NBZ'nin APL cevabından esinlenerek @randomra tarafından golf oynadı. Bu sayılar bir dizi alır bir fiil tanımlar. Aşağıdaki gibi kullanılır:

   (#~@|.*/#~) 4 3
12 12 12 12  9  9  9
12 12 12 12  9  9  9
12 12 12 12  9  9  9
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12

Ayrıca 0 baytlık bir sıfır büyüklüğünde alt matrisler ürettiği için 3 baytlık bonusu talep ediyorum.

   (#~@|.*/#~) 4 0
16 16 16 16
16 16 16 16
16 16 16 16
16 16 16 16
   (#~@|.*/#~) 0 3
9 9 9
9 9 9
9 9 9

açıklama

J'nin bu mücadelede kesin bir üstünlüğü var. Kahvaltıda dizi işleme problemlerine ek olarak, 2D matrisleri varsayılan olarak doğru formatta yazdırır.

       #~  Replicate each number n in input n times
#~@|.      The same for reversed input
     */    Compute their multiplication table
— Zgarb
kaynak
Bu bana evde haklı hissettiriyor.
— Ad’m
3
Bu çözüm table flipperASCII ifadesinin belirsiz bir varyasyonuna benziyor (╯ ° □ °） ╯︵ ┻━┻
— Pete TNT
10

Oktav, 45 bayt - 3 = 42

s=@(m,n)[a=ones(n,1)*n;b=ones(m,1)*m].*[b;a]'

açıklama

Bu iki vektör oluşturur (varsayalım m = 4ve n = 3):

ones(n, 1)boyutta bir dizi oluşturur n x 1, bu yüzden nelde ettiğimiz ile çarparak :

ones(n, 1) * n => [3 3 3]' (where ' is transpose... n x 1 is a column vector)

a = [3 3 3  4 4 4 4]'   %// a is a column vector
b = [4 4 4 4  3 3 3]    %// b is a row vector

Ardından, vektörler eleman şeklinde, 7 yaylı vektörlerin 7x7 elemanlı bir matris üretmesi için otomatik yayın genişletme ile çarpılır:

    [3] .* [4 4 4 4 3 3 3]
    [3]
    [3]
    [4]
    [4]
    [4]
    [4]

Örneğin, birinci sıranın çarpma asaldırıdaki bverir:

    [3] .* [4 4 4 4 3 3 3] = [12 12 12 12  9  9  9]

Ve benzer şekilde kalan satırlar için a.

Çıktı:

>> s(4,3)
ans =

   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12

>> s(3,0)
ans =

   9   9   9
   9   9   9
   9   9   9

Burada ideone üzerinde deneyebilirsiniz

— deney şişesi
kaynak
Kaldırabilirsiniz s=. Anonim fonksiyonların / lambdaların bir değişkende saklanması gerekmediği kanısındayız.
— kusur,
6
@flawr ama sonra cevap 42 olmazdı ...
— beher
Tamam.
— Adam
9

Dyalog APL , 10-3 = 7

Tarafından İlham * Bu yanıt argümanlar bir çarpma tablosunda yinelenen ve sonra kullanılır:

⊖∘.×⍨(/⍨⎕)

⎕İstemi yayınlar ( ⎕:) ve ardından girilen ifadeleri değerlendirir. (Güvenlik nedeniyle, bu TryAPL'de çalışmaz ancak NGN / APL'de çalışır .)
/⍨Argümanını kendi zamanlarında çoğaltır ( /⍨4 3⇔ 3 3 3 4 4 4 4)
∘.×⍨Bir çarpım tablosu oluşturur.
⊖Baş aşağı döner.

Bu herhangi bir uzunluk girişinde işe yarar (giriş 6 boşluk girintili, çıktı sol kenardadır):

      ⊖∘.×⍨(/⍨⎕)
⎕:
      ⍬      ⍝ Empty list (the square of nothing)
      ⊖∘.×⍨(/⍨⎕)
⎕:
      0      ⍝ 0​² = 0
      ⊖∘.×⍨(/⍨⎕)
⎕:
      0 1      ⍝ (0+1)​² = 1²
1
      ⊖∘.×⍨(/⍨⎕)
⎕:
      2 3      ⍝ (2+3)​² = 2² + 3²
6 6 9 9 9
6 6 9 9 9
6 6 9 9 9
4 4 6 6 6
4 4 6 6 6
      ⊖∘.×⍨(/⍨⎕)
⎕:
      1 2 3      ⍝ (1+2+3)​² = 1² + 2(1×2) + 2(1×3) + 2² + 2(2×3) + 3²
3 6 6 9 9 9
3 6 6 9 9 9
3 6 6 9 9 9
2 4 4 6 6 6
2 4 4 6 6 6
1 2 2 3 3 3
      ⊖∘.×⍨(/⍨⎕)
⎕:
      ⍳4    ⍝ Integers 1 through 4
4 8 8 12 12 12 16 16 16 16
4 8 8 12 12 12 16 16 16 16
4 8 8 12 12 12 16 16 16 16
4 8 8 12 12 12 16 16 16 16
3 6 6  9  9  9 12 12 12 12
3 6 6  9  9  9 12 12 12 12
3 6 6  9  9  9 12 12 12 12
2 4 4  6  6  6  8  8  8  8
2 4 4  6  6  6  8  8  8  8
1 2 2  3  3  3  4  4  4  4

* Aslında, aklımda farklı bir çözüm vardı: Her dikdörtgen, iki argümanın her birleşimi için bir çarpım tablosu oluşturarak ayrı ayrı oluşturulur. Daha sonra dört kare dikey ve yatay olarak birleştirilir. Bu gibi görünüyor:

,/⍪⌿⊖∘.(,⍴×)⍨⎕

⎕İstemi, yukarıdaki gibi.
,⍴×<Arguları birleştirin ( ,) ve bunu ( ⍴) ile dolu bir dikdörtgeni şekillendirmek için kullanın ×.
∘.(… )⍨Her bir hücrenin içinde belirtileni içeren bir tablo oluşturun (… )
⊖Dikey olarak döndürün.
⍪⌿Dikey olarak hücreleri birleştirin.
,/Hücreleri yatay olarak birleştirin.

— Adem
kaynak
1
Güzel! J ile aynı skorla aynı fikir:(|.*/])@#~
— Zgarb 20:15
@Zgarb Cevabınızı güncelleyin ve benim gibi bir dipnot ekleyin. J bunu hak ediyor!
— Ad’m
7

R, 31 - 3 = 28

rev(b<-rep(a<-scan(),a))%*%t(b)

Açıklama:

           a<-scan()            # take numeric input and store as vector a
    b<-rep(         ,a)         # repeat each numeric input by itself and store as vector b
rev(                   )        # the reverse of vector b
                        %*%     # matrix multiplication
                           t(b) # the transposed of vector b

Bu, ikiden fazla sayı için de geçerlidir. Örneğin, (5,3,2) için çıktı şöyle görünür:

      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
 [1,]   10   10   10   10   10    6    6    6    4     4
 [2,]   10   10   10   10   10    6    6    6    4     4
 [3,]   15   15   15   15   15    9    9    9    6     6
 [4,]   15   15   15   15   15    9    9    9    6     6
 [5,]   15   15   15   15   15    9    9    9    6     6
 [6,]   25   25   25   25   25   15   15   15   10    10
 [7,]   25   25   25   25   25   15   15   15   10    10
 [8,]   25   25   25   25   25   15   15   15   10    10
 [9,]   25   25   25   25   25   15   15   15   10    10
[10,]   25   25   25   25   25   15   15   15   10    10
— freekvd
kaynak
Muhtemelen geçerli bir cevap olması için içine catveya içine sarmanız gerekecektir write.
— David Arenburg
@DavidArenburg Neden göremiyorum? "Çıktı (herhangi bir şekilde)" yazıyor. Beni bir gereksinim içine sokmak için tek bir çıktı almam gerekiyordu.
— freekvd 20:15
Evet, belki de haklısın. Bununla ne kastettiklerini bilmiyorum.
— David Arenburg
@DavidArenburg Evet, sorun değil. Bu bir veri / metin mücadelesidir, giriş / çıkış mücadelesi değildir.
— Adám
5

Haskell, 153 125 bayt - 3 = 122

(#)=replicate
d=length.show
y%x=unlines$(>>= \n->(1+d(x*x+y*y)-d n)#' '++show n)<$>x#(y#(x*y)++x#(x*x))++y#(y#(y*y)++x#(x*y))

Kodun yarısı çıktı formatlaması içindir. Keyfi büyük tamsayılar için çalışır. Örnek çıktı:

> putStrLn $ 4 % 3
12 12 12 12  9  9  9
12 12 12 12  9  9  9
12 12 12 12  9  9  9
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12

> putStrLn $ 6 % 0
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36

Bazen sayılar arasında ek bir boşluk vardır, çünkü örneğin x*x+y*yyerine dayalı olarak gereken alanı hesaplıyorum.max (x*x) (y*y)

> putStrLn $ 2 % 3
  6  6  9  9  9
  6  6  9  9  9
  6  6  9  9  9
  4  4  6  6  6
  4  4  6  6  6

Ama en fazla bir boşluk.

— niml'i
kaynak
4

Mathematica 56-3 = 53

Güncelleme : Adlandırılmış bir işlevi kullanan tam olarak aynı kod boyutunda ikinci bir yöntem ekledim. Bir Arrayyerine bir kullanır Tableancak aynı mantığı izler. (Aşağıya bakınız.)

Yöntem 1

Bu, faktörleri satır değerine, sütun değerlerine bağlı olan bir ürün tablosu yapar. Sayı çifti bir tamsayı listesi olarak girilir. Aşağıdaki gibi anonim işlevler, bir programda yalnızca bir kez kullanılmaları halinde en kullanışlıdır. Aksi halde, adlandırılmış bir işlevi kullanmak daha mantıklı olur.

Grid@Table[If[r>#2,#,#2]If[c>#,#2,#],{r,#+#2},{c,#+#2}]&

Her faktör bir If-then deyimidir:

  • If[r>#2,#,#2] "Satır sayısı ikinci girişten büyükse, ilk girişi faktör olarak kullanın, aksi halde ikinci girişi kullanın.
  • If[c>#,#2,#] "Eğer sütun numarası ilk girişten büyükse, ikinci girişi faktör olarak kullanın, aksi halde ilk girişi kullanın.

örnek 1

 Grid@Table[If[r>#2,#,#2]If[c>#,#2,#],{r,#+#2},{c,#+#2}]&@@{5,3}

ex1

Örnek 2

Grid@Table[If[r>#2,#,#2]If[c>#,#2,#],{r,#+#2},{c,#+#2}]&@@{0,3}

ex2

Yöntem 2 (ayrıca 56-3 = 53)

Bu, Yöntem 1'e benzer şekilde çalışır. Ancak çağrıldığında daha az kod gerektirir. Ve hücreler, tablodaki hücrelerin aksine adreslenebilir. İşlev bir kereden fazla kullanılacaksa, bu yöntem daha iyidir.

a_~f~b_:=Grid@Array[If[#>a,a,b]If[#2>a,b,a]&,{a+b,a+b}]

Yukarıdaki örnekler aşağıdakiler tarafından üretilmiştir:

Örnek 1:

f[4,3]

Örnek 2:

f[0,3]
— DavidC
kaynak
1
Bu ustaca. Bu yöntemle kendi çözümümü 4 karakter azaltabilirim.
— Adám
Teşekkürler. Az önce aynı yaklaşımın adlandırılmış bir fonksiyonla çalıştığını anladım. Yukarıdaki Yöntem 2'ye bakınız.
— DavidC
4

Octave, 34 - 3 = 31

@(a)rot90(b=repelems(a,[1,2;a]))*b

Örnekler:

octave:1> f = @(a)rot90(b=repelems(a,[1,2;a]))*b;
octave:2> f([4,3])
ans =

   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12

octave:3> f([0,3])
ans =

   9   9   9
   9   9   9
   9   9   9
— alephalpha
kaynak
Vay, hiçbir fikrim yoktu repelems. Müthiş!
— kabı
4

CJam, 27 bayt - 3 = 24

q:L~_]ze~_ff{*sL,2*Se[}W%N*

CJam stil dizisi olarak girdi alır. Gerektiğinden biraz daha fazla boşluk kullanıyor, ancak bence "akla bağlı" ve her zaman doğru bir şekilde hizalanmış durumda.

Burada test et.

açıklama

q:L    e# Read the input and store it in L.
~_     e# Evaluate the input, pushing [A B] onto the stack and duplicate it.
]z     e# Wrap both in an array and transpose it to get [[A A] [B B]].
e~     e# Run-length decode, getting A copies of A and B copies of B.
_ff{   e# Double map over each pair of entries in this new array...
  *s   e#   Multiply the two values.
  L,2* e#   Push twice the length of the input string.
  Se[  e#   Pad the result to this width with spaces (from the left).
}
W%     e# Reverse the resulting matrix to get the correct orientation.
N*     e# Join the rows with linefeed characters.
— Martin Ender
kaynak
Güzel, ama bu kadar fazla boşluğa neden olan nedir ve onu azaltmak için neye ihtiyaç duyulur?
— Adám
1
@NBZ Hücre genişliğinde güvenilir bir üst sınır hesaplamak için şimdiye kadar bulduğum en kısa yol girdi dizesinin iki katı uzunluğunu kullanmaktır (çünkü kare büyük sayı, sayı sayının iki katından daha fazla haneye sahip olmaz) kendisi) bulunur. Tabii ki, ortaya çıkan rakamlara göre gerekli olan gerçek miktarı hesaplayabilirdim, ancak bu biraz daha uzun olacaktır.
— Martin Ender
4

C işlevi (glibc kullanarak), 122 bayt - 3 = 119

2 döngü ile çoğunlukla basit uygulama. Burada kaçırdığım bazı golf fırsatları olmasını bekliyorum:

f(n,m,x,y){for(x=0;x<n+m;x+=puts(""))for(y=0;y<n+m;y++)printf(" %*d",snprintf(0,0,"%d",n>m?n*n:m*m),(x<m?m:n)*(y<n?n:m));}

Girdiler, işlevin ilk iki parametresinde geçirilirken, diğer ikisi sahtedir. Sütunlar sağa hizalanır.

Not glibc puts()her zaman örtük izleyen yeni satır da dahil olmak üzere yazılı bayt sayısını döndürüyor gibi görünmektedir, burada ihtiyacımız olan şey budur. Bunun başka bir libc ile çalışacağının garantisi yok.

Tam bir programda:

f(n,m,x,y){for(x=0;x<n+m;x+=puts(""))for(y=0;y<n+m;y++)printf(" %*d",snprintf(0,0,"%d",n>m?n*n:m*m),(x<m?m:n)*(y<n?n:m));}

int main (int argc, char **argv) {
    if (argc == 3) {
        f(atoi(argv[1]),atoi(argv[2]));
    }
}

gcc sqrbin.c -o sqrbin(Veya make sqrbin) olarak derleyin . Uyarılar güvenle göz ardı edilebilir.

Örnek çıktı:

$ ./sqrbin 4 3
 12 12 12 12  9  9  9
 12 12 12 12  9  9  9
 12 12 12 12  9  9  9
 16 16 16 16 12 12 12
 16 16 16 16 12 12 12
 16 16 16 16 12 12 12
 16 16 16 16 12 12 12
$ ./sqrbin 4 0
 16 16 16 16
 16 16 16 16
 16 16 16 16
 16 16 16 16
$
— Dijital Travma
kaynak
Tecrübelerime dayanarak, dönüş değeri puts()makineye bağlıdır. Mesela benim için 10. Ayrıca, burada bir ipucu: sayacı harici döngüde koşullu olarak artırırsanız, genellikle iki döngüyü bire sıkıştırabilirsiniz. Benim çözümüm nasıl yapılabileceğini gösteriyor.
— xsot
@ xsot Evet, puts()dönüş kodunun yalnızca başarı için + ve olması garantilidir. Ancak benim glibc ile yaptığım test, geri dönüş değerinin yazılan bayt sayısı olduğunu gösteriyor. Döngü konsolidasyonuna gelince - evet, bu tekniğin farkındayım ve şimdiye kadar denedim, şu ana kadar bu durumda hiç kısalma yok.
— Dijital Travma
2

Ruby, (133 - 3) = 130 bayt

s=1
a=ARGV.map{|e|s*=(e=e.to_i);[e]*e}.flatten
s=s.to_s.size
a.reverse.each{|i|a.each{|j|print (i*j).to_s.rjust(s).ljust(s+3)};puts}

4,3 için

12   12   12   12    9    9    9   
12   12   12   12    9    9    9   
12   12   12   12    9    9    9   
16   16   16   16   12   12   12   
16   16   16   16   12   12   12   
16   16   16   16   12   12   12   
16   16   16   16   12   12   12

1,3 için

3   9   9   9   
3   9   9   9   
3   9   9   9   
1   3   3   3

0,3 için

9   9   9   
9   9   9   
9   9   9
— Golgappa
kaynak
2
PPCG'ye Hoşgeldiniz! Dolgunluğun çok fazla için yeterli olduğunu sanmıyorum. 1Gibi bir ve çok sayıda düşünün 9999. Daha ssonra ortaya çıkacak 4, bu yüzden genişliğine kadar yastığa çıkıyorsunuz s+3 = 7ama 9999^28 rakam gerekiyor. Bunun 2*syerine kullanmak isteyebilirsiniz .
— Martin Ender
2
Ne olursa olsun, işte bazı golf ipuçlarını: Neden daha rjustönce yapmanıza gerek olmadığını anlamıyorum ljust. Sen kısaltabilir printiçin $><<(ve ondan sonra boşluk kurtulmak). ARGVtakma adı var $*. Sen kaçınmak mümkün olabilir flatten: Böyle bir şey dizinizi kurarak codegolf.stackexchange.com/a/19493/8478 . Ayrıca, yalnızca işlevlerin cevaplarına kesinlikle buralarda izin verilir (adsız işlevler bile), böylece işlev tamsayıları girdi olarak alabilir ve hiçbir şey yapmanıza gerek kalmaz .to_i.
— Martin Ender
@ MartinBüttner, ipuçları için teşekkür ederiz.
— Harsh Gupta
2

Python 2, 176 bayt - 3 = 173

def g(m,n):
 y,x,z,l,f='y','x','z','l','%'+str(len(str(max(m*m,n*n))))+'s'
 d={y:m*n,x:n*n,z:m*m,l:'\n'}
 for i in map(lambda x:d[x],(y*m+x*n+l)*n+(z*m+y*n+l)*m): print f % i,

Bu, karakter ızgarası oluşturmak için Python string işlevlerini kullanır, ardından karakterleri tamsayılarla değiştirir ve formatlanmış çıktılar yazdırır.

— parlak değil
kaynak
İlginç bir yöntem.
— Ad’m
1

Matlab, 58 - 3 = 55

İsimsiz bir işlev kullanma:

@(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)

Örnek:

>> @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
ans = 
    @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
>> ans(4,3)
ans =
    12    12    12    12     9     9     9
    12    12    12    12     9     9     9
    12    12    12    12     9     9     9
    16    16    16    16    12    12    12
    16    16    16    16    12    12    12
    16    16    16    16    12    12    12
    16    16    16    16    12    12    12

>> @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
ans = 
    @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
>> ans(0,3)
ans =
     9     9     9
     9     9     9
     9     9     9

(Eski çözüm) 59 - 3 = 56

İsimsiz bir işlev kullanma:

@(a,b)[b*a*ones(b,a) b^2*ones(b);a^2*ones(a) a*b*ones(a,b)]
— Luis Mendo
kaynak
1

C, (125 - 3) bayt

i,j,a;main(b,s){for(sscanf(gets(s),"%d %d",&a,&b);j<a+b;)printf(++i>a+b?i=!++j,"\n":"%*d",strlen(s)*2,(i<a?a:b)*(j<b?b:a));}

Giriş, aynı satırda boşlukla ayrılmış iki tam sayı olarak alınmıştır. Her hücre, giriş dizesinin iki katı uzunluğa kadar boşluklarla doldurulur.

— xsot
kaynak
sorun gcc (4.8.4) ile derlemek için bu çok zorlanıyoruz im ...
— parlak don
1
Bunu gcc-4.6.1-2 debian paketini kullanan golf.shinh.org/check.rb adresinde test ettim. Ne derleme hataları alıyorsunuz?
— xsot
üzgünüm hepsi bir satır olarak tekrar denedim ve işe yaradı, ama kaçtığımda bir segfault alıyorum. i 2 3 ve isabet iade dize girmiş ve onu Bölümleme hatası (çekirdek döküldü) diyor
— Don parlak
Üzgünüm ama neden senin için işe yaramayacağını bilmiyorum. En azından daha önce bağladığım sitedeki kodu hala deneyebilirsin :)
— xsot
1

Pyth, 39 - 3 = 36

Pyth, çıktı numaralarını elle doldurmak zorunda olduğundan, büyüklüğü artıran yerleşik matris biçimlendirmesine sahip değildir. İşte benim geldiğim şey.

JAQL*b]jdm.[`d\ l`eS^R2Jsm*d]*bdJj+yHyG

Çevrimiçi deneyin.

— PurkkaKoodari
kaynak
1

Bloklar , 51 bayt 52 62 82 87 (yarışma dışı)

::`+`1|U;{`*`1}|A;`+`1,0+`1={`1^2}|;0+`,`1+`={`^2}|

Ungolfed:

::
  ` + `1                    | Expand;
  {` * `1}                  | SetAll;
  ` + `1, 0 + `1 = {`1 ^ 2} | Set;
  0 + `, `1 + `  = {` ^ 2}  | Set

Dene

— Downgoat
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.