Illustrieren Sie das Quadrat eines Binoms

28

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
code-golf  math  arithmetic  array-manipulation  grid 
— Adam
quelle
Was ist der Maximalwert der eingegebenen Zahlen? Vielen Dank.
— Don Bright
1
@donbright Keine künstliche Grenze. Die einzige Grenze ist, was Ihr Computer und Ihre Sprache in Bezug auf Darstellung, Berechnung (mit dem von Ihnen gewählten Algorithmus) und Ergebnis können. Potenziell hätte ein moderner Computer, der mit einem Drucker ausgestattet ist, der Daten zeilenweise akzeptiert, fast keine Begrenzung ... :-)
— Adám
Ist die quadratische Ausrichtung vorgegeben oder können wir sie um 90 Grad drehen?
— John Dvorak
1
Warum der Bonus für 0 Werte? Was wäre die erwartete Ausgabe, wenn nicht nur ein Quadrat?
— März,
@MarchHo Deshalb ist der Bonus so klein. Einige Sprachen sind jedoch möglicherweise nicht in der Lage, leere Arrays zu verarbeiten.
— Adám

Antworten:

14

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
— Zgarb
quelle
Dadurch fühle ich mich wie zu Hause.
— Adám,
3
Diese Lösung sieht aus wie eine undurchsichtige Variante des table flipperASCII-Emoticon ((° □ °）） ╯︵
— Pete TNT
10

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

— Becherglas
quelle
Sie können das entfernen s=. Wir haben die Konvention, dass anonyme Funktionen / Lambdas nicht in einer Variablen gespeichert werden müssen.
— Fehler
6
@flawr aber dann wäre die Antwort nicht 42 ...
— Becher
OK.
— Adám
9

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.

— Adam
quelle
1
Nett! Gleiche Idee in J mit gleicher Punktzahl:(|.*/])@#~
— Zgarb
@Zgarb Aktualisiere deine Antwort und schreibe eine Fußnote wie meine. J hat es verdient!
— Adám,
7

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
— freekvd
quelle
Sie müssen es wahrscheinlich in catoder einwickeln, damit writees eine gültige Antwort ist.
— David Arenburg
@ DavidArenburg Ich verstehe nicht warum? Es heißt "Output (mit allen Mitteln)". Ich brauchte nur einen Mittelwert für die Ausgabe, um die Anforderungen zu erfüllen.
— Freekvd
Ja, vielleicht hast du recht. Ich bin mir nicht sicher, was sie damit meinen.
— David Arenburg
@ DavidArenburg Ja, es ist in Ordnung. Dies ist eine Daten- / Text-Abfrage, keine Eingabe- / Ausgabe-Abfrage.
— Adám,
5

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.

— nimi
quelle
4

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}

ex1

Beispiel 2

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

ex2

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]
— DavidC
quelle
1
Das ist genial. Mit dieser Methode kann ich meine eigene Lösung um 4 Zeichen reduzieren.
— Adám
Vielen Dank. Ich habe gerade festgestellt, dass der gleiche Ansatz mit einer benannten Funktion funktioniert. Siehe Methode 2 oben.
— DavidC
4

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
— Alephalpha
quelle
Wow, ich hatte keine Ahnung, repelemsexistiert. Genial!
— Becher
4

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.
— Martin Ender
quelle
Schön, aber was verursacht so viel Leerraum und was wäre nötig, um ihn zu reduzieren?
— Adám
1
@NBZ Der kürzeste Weg, den ich bisher gefunden habe, um eine zuverlässige Obergrenze für die Zellenbreite zu berechnen, besteht darin, die doppelte Länge der Eingabezeichenfolge zu verwenden (da das Quadrat mit der größeren Zahl nicht mehr als doppelt so viele Stellen hat wie die Zahl) selbst). Natürlich könnte ich den tatsächlich notwendigen Betrag auf der Grundlage der resultierenden Zahlen berechnen, aber das wäre ein bisschen länger.
— Martin Ender
4

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
$
— Digitales Trauma
quelle
Nach meiner Erfahrung ist der Rückgabewert von puts()maschinenabhängig. Es ist zum Beispiel 10 auf meinem. Hier ist auch ein Tipp: Sie können normalerweise zwei Schleifen zu einer komprimieren, wenn Sie den Zähler in der externen Schleife bedingt erhöhen. Meine Lösung zeigt, wie es geht.
— xsot
@xsot Ja, es puts()ist nur garantiert, dass der Rückkehrcode erfolgreich ist. Meine Tests mit glibc scheinen jedoch zu zeigen, dass der Rückgabewert die Anzahl der geschriebenen Bytes ist. Was die Loop-Konsolidierung angeht - ja, ich kenne diese Technik und habe sie hier bereits ausprobiert, in diesem Fall jedoch ohne Verkürzung.
— Digitales Trauma
2

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
— Golgappa
quelle
2
Willkommen bei PPCG! Ich denke nicht, dass Ihre Polsterung für große Zahlen ausreicht. Betrachten Sie eine 1und eine große Anzahl wie 9999. Als swird als herauskommen 4, so dass Sie Polsterung auf eine Breite von s+3 = 7aber 9999^2braucht 8 Ziffern. Vielleicht möchten Sie 2*sstattdessen verwenden.
— Martin Ender
2
Unabhängig davon, hier ein paar Golftipps: Ich verstehe nicht, warum Sie das brauchen, rjustbevor Sie es tun ljust. Sie können verkürzen printzu $><<(und den Raum , nachdem sie loszuwerden). ARGVhat einen Alias $*. Sie können dies möglicherweise vermeiden, flattenindem Sie Ihr Array folgendermaßen erstellen : codegolf.stackexchange.com/a/19493/8478 . Außerdem sind hier auf jeden Fall nur funktionale Antworten zulässig (auch unbenannte Funktionen), sodass für diese Funktion die Ganzzahlen als Eingaben verwendet werden können und Sie keine Eingaben vornehmen müssen .to_i.
— Martin Ender
@ MartinBüttner, danke für die Tipps.
— Harsh Gupta
2

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.

— Don Bright
quelle
Interessante Methode.
— Adám
1

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)]
— Luis Mendo
quelle
1

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.

— xsot
quelle
Ich habe Probleme damit, dies mit gcc (4.8.4) zu kompilieren ...
— don bright
1
Ich habe dies auf golf.shinh.org/check.rb getestet, das das Debian- Paket gcc-4.6.1-2 verwendet. Welche Kompilierungsfehler treten auf?
— Xsot
Entschuldigung, ich habe es noch einmal versucht, da alle eine Zeile und es hat funktioniert, ... aber wenn ich renne, bekomme ich einen Segfault. Ich gab die Zeichenfolge 2 3 und drückte die Eingabetaste und es heißt Segmentierungsfehler (Core Dumped)
— Don Bright
Entschuldigung, aber ich weiß nicht, warum es bei Ihnen nicht funktioniert. Zumindest können Sie den Code noch auf der Seite ausprobieren, die ich bereits verlinkt habe :)
— xsot
1

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.

— PurkkaKoodari
quelle
1

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

— Downgoat
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.