Eine übliche visuelle Erklärung des Satzes von Pythagoras ist:

Die Quadrate sollen das Quadrat der Seitenlänge darstellen und die Flächen von a + b = c, genau wie der Satz von Pythagoras sagt.

Dieser Teil ist das, was Sie zeigen müssen.

Deine Aufgabe

• Sie erhalten zwei Ganzzahlen als Eingabe, die Seiten aund bein rechtwinkliges Dreieck darstellen sollen (z.3, 4 ).
• Sie werden dann Quadrate machen aus den Längen a, bund caus dem #Charakter. Zum Beispiel ist hier 3:

###
###
###

• Anschließend formatieren Sie diese in eine mathematische Gleichung, die das jeweilige pythagoreische Triplett erklärt:

             #####
      ####   #####
###   ####   #####
###   ####   #####
### + #### = #####

• Beachten Sie, wie die =und +Zeichen haben Räume auf beiden Seiten und wie alles ist auf der Unterseite.
• Sie erhalten nie Werte für aund bdie machen cnicht ganzzahlig.
• Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes !

Testfälle

(Weitere kommen, sobald ich Zeit habe, diese sind wirklich schwer von Hand zu machen)

3, 4
             #####
      ####   #####
###   ####   #####
###   ####   #####
### + #### = #####

6, 8
                    ##########
                    ##########
         ########   ##########
         ########   ##########
######   ########   ##########
######   ########   ##########
######   ########   ##########
######   ########   ##########
######   ########   ##########
###### + ######## = ##########

4, 3
             #####
####         #####
####   ###   #####
####   ###   #####
#### + ### = #####

5, 12
                       #############
        ############   #############
        ############   #############
        ############   #############
        ############   #############
        ############   #############
        ############   #############
        ############   #############
#####   ############   #############
#####   ############   #############
#####   ############   #############
#####   ############   #############
##### + ############ = #############

Pyth, 35 32 31 30 Bytes

j_.ts.i.imm*d\#d+Qs.aQ"+="mk4d

Probieren Sie es online aus.

CJam, 49 Bytes

" +   = "S/3/[q~_2$mh:H]_'#f*:a.*.\:+SH*f.e|zW%N*

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

" +   = "S/3/ e# Split at spaces, the into chunks of length 3.
              e# This pushes [["" "+" ""] ["" "=" ""]].
[             e#
  q~          e# Read and interpret all input from STDIN.
  _2$         e# Copy both integers.
  mh          e# Calculate the hypotenuse of the triangle with those catheti.
  :H          e# Save the result in H.
]             e# Collect catheti and hypotenuse in an array.
_'#f*         e# Copy and replace each length with a string of that many hashes.
:a            e# Wrap each string in an array.
.*            e# Vectorized repetition. Turns strings into square arrays.
.\            e# Interleave with the string of operators.
:+            e# Concatenate to form an array of strings.
SH*           e# Push a string of spaces of length H.
f.e|          e# Mapped vectorized logical OR; pads all strings with spaces to
              e# length H.
zW%           e# Zip and reverse; rotates the array.
N*            e# Join the strings, separating by linefeeds.

Python 2, 134 100 Bytes

a,b=input()
i=c=int(abs(a+b*1j))
while i:print"# "[i>a]*a," +"[i<2],"# "[i>b]*b," ="[i<2],"#"*c;i-=1

Probieren Sie es online aus.

Das Programm nimmt Eingaben als durch Kommas getrennte Ganzzahlen entgegen, berechnet die Hypotenuse mit den in Python integrierten komplexen Zahlen und geht dann von diesem Wert aus, wobei jede Zeile berechnet und gedruckt wird. Der wichtigste Trick beim Golfen ist die Verwendung der String-Indizierung anstelle der zu wählenden Bedingungen# / +/ =vs Raum.

Bearbeiten: Die erste Version war ein Opfer von schwerwiegenden Überentwicklungen - diese ist sowohl einfacher als auch viel kürzer.

Julia, 121 114 112 Bytes

f(a,b)=for i=1:(c=isqrt(a^2+b^2)) g(x,t)=(i>c-x?"#":" ")^x*(i<c?"  ":t)" ";println(g(a," +")g(b," =")g(c,""))end

Ungolfed:

function f(a,b)
    # Compute the hypotenuse length
    c = isqrt(a^2 + b^2)

    # Write the lines in a loop
    for i = 1:c
        # Make a function for constructing the blocks
        g(x,t) = (i <= c - x ? " " : "#")^x * (i < c ? "  " : t) " "

        println(g(a," +") g(b," =") g(c,""))
    end
end

Problem behoben und 2 Bytes dank Glen O gespeichert.

JavaScript ES6, 155 134 140 129 Bytes

(n,m)=>eval("for(o='',q=(b,s)=>' #'[z<b|0].repeat(b)+(z?'   ':s),z=i=Math.hypot(n,m);z--;)o+=q(n,' + ')+q(m,' = ')+q(i,'')+`\n`")

Ich habe das mit umgeschrieben for . Es wird noch viel golfen ...

Wenn etwas nicht funktioniert, lass es mich wissen. Ich werde es morgen früh reparieren.

Auf Safari Nightly getestet

Ungolfed:

(n,m)=>
   Array(
     z=Math.hypot(n,m)
   ).fill()
   .map((l,i)=>
      (q=(j,s)=>
        (z-i<=j?'#':' ')
        .repeat(j)+
         (z-i-1?' ':s)
      )
      (n,`+`)+
      q(m,`=`)+
      q(z,'')
   ).join`
   `

Erläuterung:

(Nicht aktualisiert) aber immer noch genau genug.

(n,m)=> // Function with two arguments n,m
   Array( // Create array of length...
    z=Math.hypot(n,m) // Get sqrt(n^2+m^2) and store in z
   ).fill() // Fill array so we can loop
   .map((l,i) => // Loop z times, take l, and i (index)
     (q=j=>( // Create function q with argument j
      z-i<=j? // If z-i is less than or equal to j...
        '#' // Use '#'
      : // OR
        ' ' // Use space
      ).repeat(j) // Repeat the character j times
     )(n) // Run with n
   + // Add to string
   ` ${ // Space
      (b=z-i-1)? // If this isn't the last line...
       ' ' // Return ' '
      : // Otherwise
       '+' // Plus
    } ${ // Space
      q(m) // run function q with arg m
    } ${ // Space
      b? // If b
       ' ' // Return space
      : // Otherwise
        '=' // '='
    }` + // Add to...
    '#'.repeat(z) // Repeat hashtag, z times
  ).join` // Join the new array with new lines
  `

DEMO

ES5-Version Bei der Eingabe muss es sich um gültige Zahlenmengen handeln :

function _taggedTemplateLiteral(e,t){return Object.freeze(Object.defineProperties(e,{raw:{value:Object.freeze(t)}}))}var _templateObject=_taggedTemplateLiteral(["\n"],["\n"]),t=function(e,t){return Array(z=Math.sqrt(e*e+t*t)).fill().map(function(r,n){return(q=function(e,t){return(z-n<=e?"#":" ").repeat(e)+(z-n-1?" ":t)})(e,"+")+q(t,"=")+q(z,"")}).join(_templateObject)};
// Demo
document.getElementById('go').onclick=function(){
  document.getElementById('output').innerHTML = t(+document.getElementById('input').value,
                                                 +document.getElementById('input2').value)
};

<div style="padding-left:5px;padding-right:5px;"><h2 style="font-family:sans-serif">Visually Explaining the Pythagorean Theorem</h2><div><div  style="background-color:#EFEFEF;border-radius:4px;padding:10px;"><input placeholder="Number 1" style="resize:none;border:1px solid #DDD;" id="input"><input placeholder="Number 2" style="resize:none;border:1px solid #DDD;" id="input2"><button id='go'>Run!</button></div><br><div style="background-color:#EFEFEF;border-radius:4px;padding:10px;"><span style="font-family:sans-serif;">Output:</span><br><pre id="output" style="background-color:#DEDEDE;padding:1em;border-radius:2px;overflow-x:auto;"></pre></div></div></div>

Pyth, 51 49 Bytes

AQJs.aQLj*b]*b\#;j_MCm_.[d\ Jcj[yJb\=byHb\+byG))b

Erwartet Eingaben in das Formular [3,4].

Probieren Sie es hier aus

AQ - weist Eingang zu G, H

Js.a,GH - berechnet die Hypotenuse als J

Lj*b]*b\#;- definiert y(b)als ein Quadrat der Größe b(an anderer Stelle im Code bbedeutet Zeilenumbruch)

j_MCm_.[d\ Jcj[yJb\=byHb\+byG))b - Erstellt die Quadrate, Pads mit Leerzeichen und transponiert

Zwei Bytes dank Maltysen gespart.

Ruby, 134

->a,b{c=((a**2+b**2)**0.5).round
c.times{|i|
d=i<c-1?'  ':'+='
puts (c-i>a ?' ':?#)*a+" #{d[0]}  #{(c-i>b ?' ':?#)*b} #{d[1]} "+?#*c}}

einfache Linie für Linie Annäherung.

Unten im Testprogramm, wobei das Symbol in @ geändert wurde, um Verwechslungen mit der Syntax #{....}("String-Interpolation") zu vermeiden, die zum Einfügen von Ausdrücken in einen String verwendet wird. Jede Eingabe sollte in einer anderen Zeile erfolgen.

f=->a,b{c=((a**2+b**2)**0.5).round
c.times{|i|
d=i<c-1?'  ':'+='
puts (c-i>a ?' ':?@)*a+" #{d[0]}  #{(c-i>b ?' ':?@)*b} #{d[1]} "+?@*c}}

A=gets.to_i
B=gets.to_i
f.call(A,B)

C 176 Bytes

C wird das nicht gewinnen, aber der Spaß ist es wert.

#define A(x,y)for(j=x;j--;)putchar("# "[i+1>x]);printf(i?"   ":" "#y" ");
i;j;main(a,b,c){for(c=scanf("%d %d",&a,&b);a*a+b*b>c*c;c++);for(i=c;i--;puts("")){A(a,+)A(b,=)A(c,)}}

Schön gedruckt:

#define A(x,y)for(j=x;j--;)putchar("# "[i+1>x]);printf(i?"   ":" "#y" ");
i;j;
main(a,b,c)
{
    for(c=scanf("%d %d",&a,&b);a*a+b*b>c*c;c++);
    for(i=c;i--;puts(""))
    {
        A(a,+)
        A(b,=)
        A(c,)
    }
}

Mit gcc können wir den dritten Parameter an main übergeben (ein Array von Umgebungsvariablen), damit wir ihn für unseren Zweck nutzen können.

Das

for(c=scanf("%d %d",&a,&b);a*a+b*b>c*c++;);

wäre äquivalent zu

scanf("%d %d",&a,&b);
for(c=2;a*a+b*b>c*c++;);

weil scanfgibt die Anzahl der erfolgreich durchsuchten Parameter zurück.

PHP, 178 170 168 Bytes

Eingabe ist GET Parameter xund y. Leider kann ich diese sich wiederholenden Saiten nicht spielen.

<?php for(@$i=$z=hypot($x=$_GET[x],$y=$_GET[y]),@$s=str_repeat;$i;$i--)@print$s($i<=$x?~Ü:~ß,$x).(($l=$i==1)?~ßÔß:~ßßß).$s($i<=$y?~Ü:~ß,$y).($l?~ßÂß:~ßßß).$s(~Ü,$z).~õ;

• 8 Bytes gespart, indem alle meine Zeichenfolgen invertiert und die Anführungszeichen entfernt wurden.
• 2 Bytes gespeichert , indem die Bedingung ersetzt $i>0mit$i

@echoIch bin nicht sicher, warum PHP nicht mag, also musste ich 1 Byte mit opfern@print .

Falls SE die Codierung vermasselt, soll dies in Windows-1252 (nicht UTF8) codiert werden.

APL (Dyalog Extended) , 33 29 Byte ^SBCS

-3 aufgrund meiner Erweiterungen von Dyalog APL.

Anonymes Präfix Lambda:

{⊖⍕,' +=',⍪{⍵ ⍵⍴⍕#}¨⍵,√+/⍵*2}

Probieren Sie es online!

{... } "dfn"; ⍵ist das Argument (Seitenlängen)

 ⍵*2 Platz

 +/ Summe

 √ Quadratwurzel

 ⍵, Argument voranstellen

 {… }¨ Wenden Sie jeweils das folgende anonyme Lambda an

  # Root-Namespace

  ⍕ Format als Text

  ⍵ ⍵⍴ Verwenden Sie das Argument zweimal, um eine Matrix mit diesen Dimensionen zu erstellen.

 ⍪ in Spalte machen

 ' ++=', Stellen Sie diese drei Zeichen vor die drei Zeilen

 , ravel (Zeilen in Liste zusammenfassen)

 ⍕ Format als Text

 ⊖ umdrehen

CJam, 78 Bytes

q~_2f#~+mQ+ee_2=~e>f{\~@1$-S*\'#*+_'#e=\a*_0=,S*@"+= "=1$,(S*\+1$a\a@a+++~}zN*

Zuerst wird die Hypotenuse (H) berechnet, dann wird für jede Seite (S) ein Array von S-Linien erstellt, bestehend aus: H-SLeerzeichen + SBindestrichen. Schließlich wird die Matrix transponiert.

Demo

Lua5.2, 257 241 227 222 Bytes

r=io.read
a=r"*n"b=r"*n"c=math.sqrt(a^2+b^2)d=a+b
w=io.write
for i=1,c do
for j=0,d+c+5 do
w((j>d+5 or(i>c-b and j>a+2 and j<d+3)or(i>c-a and j<a))and"#"or(i==c and(j==a+1 and"+"or(j==d+4 and"="or" "))or" "))end
w"\n"end

• Edit1: Vereinfachtes Lesen
• Edit2: Weitere Leerzeichen entfernt
• Edit3: Aliase Abstraktion von ioFunktionen von einer anderen Antwort inspiriert

Kohle , 24 Bytes

⊞θ₂ΣＸθ²Ｆ =+«←←←ι←Ｇ↑←↓⊟θ#

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Übernimmt die Eingabe als Array von zwei Elementen. Erläuterung:

⊞θ₂ΣＸθ²

Hängen Sie die Hypotenuse an die Eingaben an.

Ｆ =+«

Bewegen Sie sich in umgekehrter Reihenfolge über die Zeichen, die rechts von jedem Quadrat angezeigt werden.

←←←ι←

Drucken Sie dieses Zeichen mit Abstand nach links.

Ｇ↑←↓⊟θ#

Füge die letzte Zahl aus dem Array ein und drucke ein Quadrat #dieser Größe.

PowerShell , 139 137 135 Byte

^{-2 dank nur ASCII
-2 dank Mazzy}

param($a,$b)($c=[math]::sqrt($a*$a+$b*$b))..1|%{(($m=" ","#")[$_-le$a]*$a)," +"[$_-eq1],($m[$_-le$b]*$b)," ="[$_-eq1],("#"*$c)-join" "}

Probieren Sie es online!

Das Berechnen von $ c tut weh und es gibt wahrscheinlich eine bessere Möglichkeit, bedingt zwischen #und zu wechseln . Erstellt eine Liste von Blöcken, fügt sie zusammen und fügt die Zeichen unter bestimmten Bedingungen hinzu.

Japt, 28 Bytes

Nimmt die Eingabe als Array von Ganzzahlen.

pUx²¬)ËÆDç'#
í"+="¬ûR3)c ·z3

Versuch es

                    :Implicit input of array U=[a,b]
pUx²¬)ËÆDç'#
p                   :Push
 U ²                :  Square each element in U
  x                 :  Reduce by addition
    ¬               :  Square root
     )              :End push
      Ë             :Map each D
       Æ            :  Map the range [0,D)
        Dç'#        :    Repeat "#" D times
í"+="¬ûR3)c ·z3
í                   :Interleave
 "+="¬              :  Split the string "+=" to an array of characters
      û             :  Centre pad each
       R3           :    With newlines to length 3
         )          :End interleave
          c         :Flatten
            ·       :Join with newlines
             z3     :Rotate clockwise 270 degrees

05AB1E , 38 Bytes

nOtª©Å10ζíε„ #yè®Rׄ= NĀèð.øý}»R„=+`.;

Nimmt die Eingabe als Liste mit zwei Zahlen (d. H [3,4] ).

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

n             # Take the square of each value in the (implicit) input-list
              #  i.e. [3,4] → [9,16]
 O            # Take the same of that list
              #  i.e. [9,16] → 25
  t           # Take the square-root of that sum
              #  i.e. 25 → 5.0
   ª          # Append it to the (implicit) input-list
              #  i.e. [3,4] and 5.0 → [3,4,5.0]
    ©         # Store it in the register (without popping)
Å1            # Change each value to an inner list of that amount of 1s
              #  i.e. [3,4,5.0] → [[1,1,1],[1,1,1,1],[1,1,1,1,1]]
  0ζ          # Zip/transpose; swapping rows/columns, with "0" as filler
              #  i.e. [[1,1,1],[1,1,1,1],[1,1,1,1,1]]
              #   → [[1,1,1],[1,1,1],[1,1,1],["0",1,1],["0","0",1]]
    í         # Reverse each inner list
              #  i.e. [[1,1,1],[1,1,1],[1,1,1],["0",1,1],["0","0",1]]
              #   → [[1,1,1],[1,1,1],[1,1,1],[1,1,"0"],[1,"0","0"]]
ε         }   # Map the inner lists to:
 „ #          #  Push string " #"
    yè        #  Index each inner list value into this string
              #   i.e. " #" and [1,1,"0"] → ["#","#"," "]
      ®R      #  Push the list from the register
        ×     #  Repeat the character that many times
              #   i.e. ["#","#"," "] and [5.0,4,3] → ["#####","####","   "]
 „=           #  Push string "= "
   NĀ         #  Push the map-index trutified (0 remains 0; everything else becomes 1)
              #   i.e. 0 → 0
              #   i.e. 3 → 1
     è        #  Use it to index into the string
              #   i.e. "= " and 0 → "="
              #   i.e. "= " and 1 → " "
      ð.ø     #  Surround it with spaces
              #   i.e. "=" → " = "
              #   i.e. " " → "   "
         ý    #  Join the map-list together with this string as delimiter
              #   i.e. ["#####","####","   "] and "   " → "#####   ####      "
»             # After the map, join everything by newlines
              #  i.e. ["##### = #### = ###","#####   ####   ###","#####   ####   ###","#####   ####      ","#####             "]
              #   → "##### = #### = ###\n#####   ####   ###\n#####   ####   ###\n#####   ####      \n#####             "
 R            # Reverse the string
              #  i.e. "##### = #### = ###\n#####   ####   ###\n#####   ####   ###\n#####   ####      \n#####             "
              #   → "             #####\n      ####   #####\n###   ####   #####\n###   ####   #####\n### = #### = #####"
  „=+`.;      # And replace the first "=" with "+"
              #  i.e. "             #####\n      ####   #####\n###   ####   #####\n###   ####   #####\n### = #### = #####"
              #   → "             #####\n      ####   #####\n###   ####   #####\n###   ####   #####\n### + #### = #####"
              # (and output the result implicitly)

Perl 6 , 99 Bytes

{$!=sqrt $^a²+$^b²;flip map({map {[' ','#'][$^d>$_]x$d,' =+ '.comb[!$_*++$ ]},$!,$b,$a},^$!)X"
"}

Probieren Sie es online!

Anonymer Codeblock, der zwei Zahlen akzeptiert und die vollständige Zeichenfolge mit einer führenden neuen Zeile und drei führenden Leerzeichen sowie einem abschließenden Zeichen in jeder Zeile zurückgibt.

Wenn wir andere Zeichen anstelle von verwenden können #, dann kann ich ein Byte speichert durch Ersetzen '#'mit \*.

C # (.NET Core) , 221 , 194 Bytes

Das fühlt sich viel zu lang an. Diese Version führt nur eine Schleife durch, um die Zeichenfolge zu erstellen.

EDIT: Ascii-Only mit einem schönen 27-Byte-Golf mit dem String-Konstruktor für serielle Zeichenadditionen! Außerdem habe ich, um darauf hinzuweisen, Math.Sqrt und nicht System.Math.Sqrt verwendet. Dies wurde angepasst!

(a,b)=>{int c=(int)System.Math.Sqrt(a*a+b*b),j=c;var s="";while(j>0)s+=new string(j>a?' ':'#',a)+(j>1?"   ":" + ")+new string(j>b?' ':'#',b)+(j-->1?"   ":" = ")+new string('#',c)+"\n";return s;}

Probieren Sie es online!