Une explication visuelle commune du théorème de Pythagore est la suivante:

Les carrés sont censés représenter le carré de la longueur du côté et les zones de a + b = c, comme le dit le théorème de Pythagore.

Cette partie est ce que vous devez montrer.

Ta tâche

• Vous obtiendrez deux entiers en entrée, censés représenter les côtés aet bun triangle rectangle (ex. 3, 4).
• Vous serez alors faire des carrés sur les longueurs a, bet chors du #caractère. Par exemple, voici 3:

###
###
###

• Vous les formaterez ensuite dans une équation mathématique expliquant le triplet de Pythagore:

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

• Notez que les signes =et +ont des espaces des deux côtés et que tout est en bas.
• Vous n'obtiendrez jamais de valeurs pour aet bqui ne font cpas partie intégrante.
• C'est le code-golf, donc le code le plus court en octets gagne!

Cas de test

(plus à venir une fois que j'ai le temps, ce sont vraiment difficiles à faire à la main)

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

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

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

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

Pyth, 35 32 31 30 octets

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

Essayez-le en ligne.

CJam, 49 octets

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

Essayez-le en ligne dans l' interprète CJam .

Comment ça marche

" +   = "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 octets

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

Essayez-le en ligne.

Le programme prend les entrées sous forme d'entiers séparés par des virgules, calcule l'hypoténuse à l'aide des nombres complexes intégrés de Python, puis effectue une boucle à partir de cette valeur en calculant et en imprimant chaque ligne au fur et à mesure. L'astuce principale consiste à utiliser l'indexation des chaînes au lieu de conditions pour sélectionner #/ +/ =vs space.

Edit: La première version a été victime d’une sérieuse sur-ingénierie - celle-ci est à la fois plus simple et beaucoup plus courte.

Julia, 121 114 112 octets

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

Résolution du problème et sauvegarde de 2 octets grâce à Glen O.

JavaScript ES6, 155 134 140 129 octets

(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`")

J'ai réécrit ceci avec for. Beaucoup de golf encore ...

Si quelque chose ne fonctionne pas, faites le moi savoir. Je vais le réparer dans la matinée.

Testé sur Safari Nightly

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

Explication:

(Non mis à jour) mais toujours assez précis.

(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

Version ES5 L' entrée doit être un ensemble valide de nombres :

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 octets

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

Attend une entrée dans le formulaire [3,4].

Essayez-le ici

AQ - assigne une entrée à G, H

Js.a,GH - calcule l'hypoténuse comme J

Lj*b]*b\#;- définit y(b)comme faisant un carré de taille b(ailleurs dans le code, bsignifie nouvelle ligne)

j_MCm_.[d\ Jcj[yJb\=byHb\+byG))b - Crée les carrés, les blocs avec des espaces et les transpose

Sauvé deux octets grâce à Maltysen.

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

approche simple ligne par ligne.

Ci-dessous, dans le programme de test, symbole remplacé par @ pour éviter toute confusion avec la syntaxe #{....}("interpolation de chaîne") utilisée pour insérer des expressions dans une chaîne. Chaque entrée doit être donnée sur une ligne différente.

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 octets

C ne va pas gagner cela, mais le plaisir en vaut la peine.

#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,)}}

Joli imprimé:

#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,)
    }
}

gcc nous permet de passer le troisième paramètre à main (un tableau de variables d’environnement), nous en profitons donc pour l’utiliser à nos fins.

le

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

serait équivalent à

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

car scanfrenvoie le nombre de paramètres analysés avec succès.

PHP, 178 170 168 octets

L'entrée est paramètres GET xet y. Malheureusement, je n'arrive pas à jouer au golf avec ces cordes répétitives.

<?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).~õ;

• J'ai enregistré 8 octets en inversant toutes mes chaînes et en supprimant les guillemets.
• 2 octets sauvegardés en remplaçant la condition $i>0par$i

Vous ne savez pas pourquoi PHP n'aime pas @echo, j'ai donc dû sacrifier un octet avec @print.

Si SE codifie le codage, celui-ci est censé être codé sous Windows-1252 (pas UTF8).

APL (Dyalog Extended) , 33 ^{SBCS sur} 29 octets

-3 en raison de mes extensions de Dyalog APL.

Préfixe anonyme lambda:

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

Essayez-le en ligne!

{… } "Dfn"; ⍵est l'argument (longueur des côtés)

 ⍵*2 carré

 +/ somme

 √ racine carrée

 ⍵, pré-argument

 {… }¨ Appliquer le lambda anonyme suivant à chaque

  # espace de noms racine

  ⍕ formater en texte

  ⍵ ⍵⍴ utiliser l' argument deux fois pour r Eshape dans la matrice avec ces dimensions.

 ⍪ faire en colonne

 ' ++=', ajouter ces trois caractères aux trois rangées

 , ravel (combiner les lignes dans la liste)

 ⍕ formater en texte

 ⊖ retourner à l'envers

CJam, 78 octets

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

Il calcule d'abord l'hypoténuse (H), puis, pour chaque côté (S), il construit un tableau de S lignes composées de: H-Sespaces + Stirets. Enfin, il transpose la matrice.

Démo

Lua5.2, 257 241 227 222 octets

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: Lecture simplifiée
• Edit2: Suppression de plus d'espaces
• Edit3: aliases abstraction de iofonctions inspirées par une autre réponse

Charbon de bois , 24 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Prend les entrées sous forme de tableau de deux éléments. Explication:

⊞θ₂ΣＸθ²

Ajoutez l'hypoténuse aux entrées.

Ｆ =+«

Boucle sur les caractères qui apparaissent à la droite de chaque carré dans l'ordre inverse.

←←←ι←

Imprimez ce caractère à gauche avec un espacement.

Ｇ↑←↓⊟θ#

Pop le dernier nombre du tableau et imprimer un carré de #s de cette taille.

PowerShell , 139 137 135 octets

^{-2 grâce à ASCII uniquement
-2 grâce à Mazzy}

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

Essayez-le en ligne!

Calculer $ c blesse et il existe probablement un meilleur moyen de permuter conditionnellement entre #et . Construit une liste de morceaux et les joint ensemble tout en ajoutant de manière conditionnelle les signes.

Japt, 28 octets

Prend l'entrée comme un tableau d'entiers.

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

L'essayer

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

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

Prend l'entrée sous forme de liste de deux nombres (c. [3,4]-à-d.).

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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 octets

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

Essayez-le en ligne!

Bloc de code anonyme qui prend deux nombres et renvoie la chaîne complète avec une nouvelle ligne et trois espaces et un dernier sur chaque ligne.

Si nous pouvons utiliser d'autres caractères au lieu de #, alors je peux sauvegarder un octet en le remplaçant '#'par \*.

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

Cela semble beaucoup trop long. Cette version boucle juste pour construire la chaîne.

EDIT: Ascii-Only avec un beau golf de -27 octets en utilisant le constructeur de chaînes pour les ajouts de caractères en série! Aussi, ty pour souligner que j'utilisais Math.Sqrt pas System.Math.Sqrt. Cela a été ajusté!

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

Essayez-le en ligne!