Geben Sie (mit allen Mitteln) zwei verschiedene natürliche Zahlen (von jeder vernünftigen Größe) aus, und geben Sie (mit allen Mitteln) das Quadrat ihrer Summe wie in den folgenden Beispielen aus:

Bei 4 und 3 wird ausgegeben:

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

Bei 1 und 3 wird ausgegeben:

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

Leerzeichen können innerhalb des Grundes variieren, aber die Spalten müssen linksbündig, rechtsbündig oder (pseudo-) zentriert sein.

Ein abschließender Zeilenumbruch ist in Ordnung, Standardlücken jedoch nicht.

Dies ist Codegolf. Fügen Sie daher einen Header wie # LanguageName, 123in Ihrer Antwort ein, in dem die Zahl aus Zeichen besteht (Bytes für Sprachen, die nicht textbasiert sind). Das Packen von Code in große Unicode-Zeichen ist nicht zulässig.

Bonus: -3, wenn Ihr Code nur ein Quadrat ausgibt, wenn eine der Zahlen 0 ist; zB mit 0 und 3, Ausgabe:

9 9 9
9 9 9
9 9 9

J, 9 Bytes - 3 = 6

#~@|.*/#~

Inspiriert von der APL-Antwort von @ NBZ , aufgenommen von @randomra. Dies definiert ein Verb, das ein Array von Zahlen aufnimmt. Es wird wie folgt verwendet:

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

Ich beanspruche auch den 3-Byte-Bonus, da eine Eingabe von 0 Submatrizen der Größe Null erzeugt:

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

Erläuterung

J hat einen klaren Vorteil in dieser Herausforderung. Zusätzlich zum Verzehr von Array-Manipulationsproblemen beim Frühstück werden standardmäßig 2D-Matrizen im richtigen Format gedruckt.

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

Oktave, 45 Bytes - 3 = 42

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

Erläuterung

Dies konstruiert zwei Vektoren (nehmen wir an m = 4und n = 3):

ones(n, 1)Konstruiert ein Array von Größen n x 1, also multiplizieren nwir diese mit:

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

Dann werden die Vektoren mit automatischer Broadcast-Erweiterung elementweise multipliziert, so dass die 7-Element-Vektoren eine 7x7-Element-Matrix ergeben:

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

Zum Beispiel ergibt die Multiplikation der ersten Zeile amit b:

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

Ähnliches gilt für die verbleibenden Reihen von a.

Ausgabe:

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

Du kannst es hier auf ideone versuchen

Dyalog APL , 10-3 = 7

Inspiriert * von dieser Antwort, bei der die Argumente repliziert und dann in einer Multiplikationstabelle verwendet werden:

⊖∘.×⍨(/⍨⎕)

⎕Setzt eine Eingabeaufforderung ( ⎕:) ab und wertet jeden dann eingegebenen Ausdruck aus. (Aus Sicherheitsgründen funktioniert dies nicht mit TryAPL, aber mit NGN / APL .)
/⍨Repliziert das Argument selbst mal ( /⍨4 3⇔ 3 3 3 4 4 4 4)
∘.×⍨Erstellt eine Multiplikationstabelle.
⊖Dreht sich um

Dies funktioniert bei Eingaben beliebiger Länge (die Eingabe wird um 6 Leerzeichen eingerückt, die Ausgabe erfolgt am linken Rand):

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

* Ursprünglich hatte ich eine andere Lösung im Sinn: Jedes Rechteck wird separat erstellt, indem für jede Kombination der beiden Argumente eine Multiplikationstabelle erstellt wird. Dann werden die vier Quadrate vertikal und horizontal zusammengefügt. Es sieht aus wie das:

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

⎕Eingabeaufforderung wie oben.
,⍴×<Kombiniere ( ,) die Args und benutze sie, um ⍴ein Rechteck zu formen ( ), das mit ihrem Produkt gefüllt ist ( ×).
∘.(… )⍨Erstellen Sie eine Tabelle, in der jede Zelle das ist, was in (… )
⊖Vertikal spiegeln angegeben ist .
⍪⌿Zellen vertikal kombinieren.
,/Kombinieren Sie die Zellen horizontal.

R 31-3 = 28

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

Erläuterung:

           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

Dies funktioniert auch für mehr als zwei Nummern. Die Ausgabe für (5,3,2) sieht beispielsweise so aus:

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

Die Hälfte des Codes dient der Ausgabeformatierung. Es funktioniert für beliebige große ganze Zahlen. Beispielausgabe:

> 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

Manchmal gibt es ein zusätzliches Leerzeichen zwischen den Zahlen, weil ich den benötigten Speicherplatz berechnet habe, x*x+y*yanstatt max (x*x) (y*y)z

> 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

Aber es ist höchstens ein Leerzeichen.

Mathematica 56-3 = 53

Update : Ich habe eine zweite Methode mit genau derselben Codegröße hinzugefügt, die eine benannte Funktion verwendet. Es verwendet Arrayeher ein als ein Table, folgt aber der gleichen Logik. (Siehe unten.)

Methode 1

Dadurch wird eine Tabelle mit Produkten erstellt, deren Faktoren von den Zeilen- und Spaltenwerten abhängen. Das Zahlenpaar wird als Liste von ganzen Zahlen eingegeben. Anonyme Funktionen wie die folgenden sind am nützlichsten, wenn sie in einem Programm nur einmal verwendet werden. Andernfalls ist die Verwendung einer benannten Funktion sinnvoller.

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

Jeder Faktor ist eine Wenn-Dann-Aussage:

• If[r>#2,#,#2] bedeutet: "Wenn die Zeilennummer größer als die zweite Eingabe ist, verwenden Sie die erste Eingabe als Faktor, andernfalls verwenden Sie die zweite Eingabe.
• If[c>#,#2,#] bedeutet: "Wenn die Spaltennummer größer als die erste Eingabe ist, verwenden Sie die zweite Eingabe als Faktor, andernfalls verwenden Sie die erste Eingabe.

Beispiel 1

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

Beispiel 2

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

Methode 2 (auch 56-3 = 53)

Dies funktioniert ähnlich wie Methode 1. Beim Aufrufen wird jedoch weniger Code benötigt. Und die Zellen sind im Gegensatz zu Zellen in einer Tabelle adressierbar. Diese Methode ist besser anzuwenden, wenn die Funktion mehrmals verwendet wird.

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

Die obigen Beispiele werden wie folgt hergestellt:

Ex 1:

f[4,3]

Ex 2:

f[0,3]

Oktave, 34-3 = 31

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

Beispiele:

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 Bytes - 3 = 24

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

Übernimmt die Eingabe als Array im CJam-Stil. Es braucht etwas mehr Abstand als nötig, aber ich denke, es ist "in Ordnung" und es ist immer richtig ausgerichtet.

Teste es hier.

Erläuterung

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.

C-Funktion (unter Verwendung von glibc), 122 Bytes - 3 = 119

Meist einfache Implementierung mit 2 Schleifen. Ich gehe davon aus, dass es einige Golfmöglichkeiten gibt, die ich hier verpasst habe:

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

Eingaben werden in den ersten beiden Parametern der Funktion übergeben, die anderen beiden sind Dummies. Spalten sind rechtsbündig.

Beachten Sie, dass glibc puts()immer die Anzahl der geschriebenen Bytes einschließlich der impliziten Zeilenumbrüche zurückgibt, was wir hier brauchen. Keine Garantie, dass dies mit jeder anderen libc funktioniert.

In einem vollen Programm:

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

Kompilieren Sie als gcc sqrbin.c -o sqrbin(oder make sqrbin). Warnungen können ignoriert werden.

Beispielausgabe:

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

Ruby, (133-3) = 130 Bytes

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}

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

für 1,3

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

für 0,3

9   9   9   
9   9   9   
9   9   9

Python 2, 176 Bytes - 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,

Hierbei werden Python-Zeichenfolgenfunktionen verwendet, um ein Zeichenraster zu erstellen. Anschließend werden die Zeichen durch Ganzzahlen ersetzt und die formatierte Ausgabe gedruckt.

Matlab, 58-3 = 55

Verwenden einer anonymen Funktion:

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

Beispiel:

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

(Alte Lösung) 59-3 = 56

Verwenden einer anonymen Funktion:

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

C, (125-3) Bytes

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

Die Eingabe erfolgt als zwei durch Leerzeichen getrennte Ganzzahlen in derselben Zeile. Jede Zelle wird bis zur doppelten Länge der Eingabezeichenfolge mit Leerzeichen aufgefüllt.

Pyth, 39-3 = 36

In Pyth ist keine Matrixformatierung integriert, wodurch die Größe erheblich erhöht wird, da die Ausgabenummern manuell aufgefüllt werden müssen. Folgendes habe ich mir ausgedacht.

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

Probieren Sie es online aus.

Blöcke , 51 Bytes 52 62 82 87 (nicht konkurrierend)

::`+`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

Versuch es