Biorąc pod uwagę (w jakikolwiek sposób) dwie różne liczby naturalne (o dowolnym rozsądnym rozmiarze), wyprowadzaj (w dowolny sposób) kwadrat ich sumy, jak w poniższych przykładach:

Biorąc pod uwagę 4 i 3, wynik:

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

Biorąc pod uwagę 1 i 3, wynik:

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

Białe spacje mogą się różnić w zależności od przyczyny, ale kolumny muszą być wyrównane do lewej, wyrównane do prawej lub (pseudo) wyśrodkowane.

Końcowy znak nowej linii jest w porządku, ale standardowe luki nie.

To jest kodowanie w golfa, więc dołącz nagłówek jak # LanguageName, 123w swojej odpowiedzi, gdzie liczba to znaki (bajty dla języków, które nie są oparte na tekście). Pakowanie kodu do dużych znaków Unicode jest niedozwolone.

Premia: -3, jeśli kod generuje tylko jeden kwadrat, gdy jedna z cyfr to 0; np. podane 0 i 3, wyjście:

9 9 9
9 9 9
9 9 9

J, 9 bajtów - 3 = 6

#~@|.*/#~

Zainspirowany odpowiedzią APL @ NBZ, grał w golfa przez @randomra. Definiuje to czasownik, który przyjmuje tablicę liczb. Używa się go w następujący sposób:

   (#~@|.*/#~) 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

Twierdzę także o 3-bajtowej premii, ponieważ wejście 0 tworzy podmacierze o rozmiarze zero:

   (#~@|.*/#~) 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

Wyjaśnienie

J ma wyraźną przewagę w tym wyzwaniu. Oprócz problemów z manipulowaniem tablicą na śniadanie, domyślnie drukuje matryce 2D we właściwym formacie.

       #~  Replicate each number n in input n times
#~@|.      The same for reversed input
     */    Compute their multiplication table

Oktawa, 45 bajtów - 3 = 42

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

Wyjaśnienie

Konstruuje to dwa wektory (załóżmy m = 4i n = 3):

ones(n, 1)konstruuje tablicę jednowymiarowych n x 1, więc mnożąc je n, otrzymujemy:

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

Następnie wektory są mnożone w sposób elementarny, z automatycznym rozszerzaniem transmisji, tak że wektory 7-elementowe wytwarzają macierz 7x7-elementową:

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

Na przykład, pomnożenie pierwszego wiersza aprzez bdaje:

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

I podobnie dla pozostałych wierszy a.

Wydajność:

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

Możesz spróbować tutaj na ideone

Dyalog APL , 10-3 = 7

Zainspirowany * tą odpowiedzią, w której argumenty są replikowane, a następnie wykorzystywane w tablicy mnożenia:

⊖∘.×⍨(/⍨⎕)

⎕Wydaje monit ( ⎕:) i ocenia każde wprowadzone wyrażenie. (Ze względów bezpieczeństwa nie działa to na TryAPL, ale działa na NGN / APL ).
/⍨Sam czas replikacji argumentu ( /⍨4 3⇔ 3 3 3 4 4 4 4)
∘.×⍨Tworzy tabliczkę mnożenia.
⊖Odwraca się do góry nogami.

Zdarza się to na wejściu dowolnej długości (wejście jest wcięte 6 spacjami, wyjście ma lewy margines):

      ⊖∘.×⍨(/⍨⎕)
⎕:
      ⍬      ⍝ 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

* Początkowo miałem na myśli inne rozwiązanie: każdy prostokąt jest tworzony osobno, tworząc tabelę mnożenia dla każdej kombinacji dwóch argumentów. Następnie cztery kwadraty są łączone w pionie i poziomie. To wygląda tak:

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

⎕Podpowiedź, jak wyżej.
,⍴×<Połącz ( ,) argumenty i użyj go do ukształtowania ( ⍴) prostokąta wypełnionego ich produktem ( ×).
∘.(… )⍨Utwórz tabelę, w której każda komórka jest taka, jak określono w (… )
⊖Odwróć w pionie.
⍪⌿Łącz komórki pionowo.
,/Połącz komórki poziomo.

R, 31–3 = 28

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

Wyjaśnienie:

           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

Działa to również dla więcej niż dwóch liczb. Na przykład dane wyjściowe dla (5,3,2) wygląda następująco:

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

Haskell, 153 125 bajtów - 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))

Połowa kodu służy do formatowania wyjściowego. Działa dla dowolnych dużych liczb całkowitych. Przykładowe dane wyjściowe:

> 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

Czasami między liczbami występuje dodatkowa spacja, ponieważ obliczam potrzebną przestrzeń na podstawie x*x+y*yzamiast max (x*x) (y*y), np

> 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

Ale to co najwyżej jedna biała spacja.

Mathematica 56-3 = 53

Aktualizacja : Dodałem drugą metodę, dokładnie tego samego rozmiaru kodu, która używa nazwanej funkcji. Wykorzystuje Arrayraczej niż, Tableale postępuje zgodnie z tą samą logiką. (Patrz poniżej.)

Metoda 1

To tworzy tabelę produktów, których czynniki zależą od wartości wiersza i kolumny. Para liczb jest wprowadzana jako lista liczb całkowitych. Anonimowe funkcje, takie jak poniżej, są najbardziej przydatne, jeśli są używane tylko raz w programie. W przeciwnym razie bardziej sensowne jest użycie nazwanej funkcji.

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

Każdy czynnik jest instrukcją If-then:

• If[r>#2,#,#2] oznacza: „Jeśli numer wiersza jest większy niż drugie wejście, użyj pierwszego wejścia jako współczynnika, w przeciwnym razie użyj drugiego wejścia.
• If[c>#,#2,#] oznacza: „Jeśli numer kolumny jest większy niż pierwsze wejście, użyj drugiego wejścia jako współczynnika, w przeciwnym razie użyj pierwszego wejścia.

Przykład 1

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

Przykład 2

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

Metoda 2 (również 56-3 = 53)

Działa to podobnie do metody 1. Ale wymaga mniej kodu po wywołaniu. I komórki są adresowalne, w przeciwieństwie do komórek w tabeli. Ta metoda jest lepsza w użyciu, jeśli funkcja będzie używana więcej niż jeden raz.

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

Przykłady z powyższego są tworzone przez:

Ex 1:

f[4,3]

Ex 2:

f[0,3]

Oktawa, 34-3 = 31

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

Przykłady:

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

CJam, 27 bajtów - 3 = 24

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

Pobiera dane wejściowe jako tablicę stylu CJam. Wykorzystuje nieco więcej odstępów niż to konieczne, ale myślę, że jest „w granicach rozsądku” i zawsze jest właściwie wyrównany do prawej.

Sprawdź to tutaj.

Wyjaśnienie

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.

Funkcja C (przy użyciu glibc), 122 bajty - 3 = 119

Przeważnie prosta implementacja z 2 pętlami. Spodziewam się, że przegapiłem tutaj kilka okazji do gry w golfa:

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

Dane wejściowe są przekazywane w pierwszych dwóch parametrach funkcji, pozostałe dwa są manekinami. Kolumny są wyrównane do prawej.

Uwaga glibc puts()zawsze wydaje się zwracać liczbę zapisanych bajtów, w tym niejawny końcowy znak nowej linii, czego potrzebujemy tutaj. Nie ma gwarancji, że będzie działać z innymi bibliotekami libc.

W pełnym programie:

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]));
    }
}

Skompiluj jako gcc sqrbin.c -o sqrbin(lub make sqrbin). Ostrzeżenia można bezpiecznie zignorować.

Przykładowe dane wyjściowe:

$ ./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
$ 

Rubin, (133 - 3) = 130 bajtów

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}

dla 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

dla 1,3

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

dla 0,3

9   9   9   
9   9   9   
9   9   9

Python 2, 176 bajtów - 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,

Używa funkcji ciągów Python do utworzenia siatki znaków, a następnie zastępuje znaki liczbami całkowitymi i drukuje sformatowane dane wyjściowe.

Matlab, 58–3 = 55

Korzystanie z anonimowej funkcji:

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

Przykład:

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

(Stare rozwiązanie) 59-3 = 56

Korzystanie z anonimowej funkcji:

@(a,b)[b*a*ones(b,a) b^2*ones(b);a^2*ones(a) a*b*ones(a,b)]

C, (125 - 3) bajtów

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

Dane wejściowe są traktowane jako dwie liczby całkowite oddzielone spacją w tym samym wierszu. Każda komórka jest wypełniona spacjami do dwukrotnej długości ciągu wejściowego.

Pyth, 39-3 = 36

Pyth nie ma wbudowanego formatowania macierzy, co znacznie zwiększa rozmiar, ponieważ trzeba ręcznie uzupełniać liczby wyjściowe. Oto co wymyśliłem.

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

Wypróbuj online.

Bloki , 51 bajtów 52 62 82 87 (niekonkurujące)

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

Nie golfowany:

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

Spróbuj