Una explicación visual común del teorema de Pitágoras es como tal:

Los cuadrados están destinados a representar el cuadrado de la longitud del lado y las áreas de a + b = c, tal como dice el teorema de Pitágoras.

Esta parte es lo que tienes que mostrar.

Tu tarea

• Obtendrá dos enteros como entrada, destinados a representar lados ay bde un triángulo rectángulo (ej. 3, 4).
• A continuación, hacer cuadrados de las longitudes a, by cfuera del #personaje. Por ejemplo, aquí hay 3:

###
###
###

• Luego los formateará en una ecuación matemática que explica el triplete pitagórico particular:

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

• Observe cómo los signos =y +tienen espacios en ambos lados y cómo todo está en la parte inferior.
• Nunca obtendrá valores para ay beso hace que cno sea integral.
• Este es el código de golf, ¡el código más corto en bytes gana!

Casos de prueba

(vendrán más una vez que tenga tiempo, son realmente difíciles de hacer a mano)

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

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

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

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

Pyth, 35 32 31 30 bytes

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

Pruébalo en línea.

CJam, 49 bytes

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

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

" +   = "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, 134100 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

Pruébalo en línea.

El programa toma la entrada como números enteros separados por comas, calcula la hipotenusa utilizando los números complejos incorporados de Python, luego desciende desde ese valor calculando e imprimiendo cada línea a medida que avanza. El principal truco de golf es utilizar la indexación de cadenas en lugar de condicionales para seleccionar #/ +/ =vs espacio.

Editar: La primera versión fue víctima de una ingeniería excesiva seria, esta es a la vez más simple y mucho más corta.

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

Sin golf:

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

Problema solucionado y ahorró 2 bytes gracias a Glen O.

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

He reescrito esto con for. Mucho golf todavía ...

Si algo no funciona, avíseme. Lo arreglaré en la mañana.

Probado en Safari Nightly

Sin golf:

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

Explicación:

(No actualizado) pero aún lo suficientemente preciso.

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

MANIFESTACIÓN

La entrada de la versión ES5 debe ser un conjunto de números válido :

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

Espera entrada en el formulario [3,4].

Pruébalo aquí

AQ - asigna entrada a G, H

Js.a,GH - calcula la hipotenusa como J

Lj*b]*b\#;- se define y(b)como hacer un cuadrado de tamaño b(en otra parte del código, bsignifica nueva línea)

j_MCm_.[d\ Jcj[yJb\=byHb\+byG))b - Crea los cuadrados, almohadillas con espacios y transpone

Guardado dos bytes gracias a Maltysen.

Rubí, 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}}

enfoque simple línea por línea.

A continuación, en el programa de prueba, con el símbolo cambiado a @ para ayudar a evitar la confusión con la sintaxis #{....}("interpolación de cadenas") utilizada para insertar expresiones en una cadena. Cada entrada debe darse en una línea diferente.

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 no va a ganar esto, pero la diversión lo vale.

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

Bastante impreso:

#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 nos permite pasar el tercer parámetro a main (una matriz de variables de entorno), por lo que lo aprovechamos para usarlo para nuestro propósito.

los

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

sería equivalente a

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

porque scanfdevuelve el número de parámetros escaneados con éxito.

PHP, 178 170 168 bytes

La entrada es OBTENER parámetros xy y. Desafortunadamente, parece que no puedo jugar golf esas cuerdas repetitivas.

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

• Ahorré 8 bytes invirtiendo todas mis cadenas y quitando las comillas.
• Se guardaron 2 bytes al reemplazar la condición $i>0con$i

No estoy seguro de por qué a PHP no le gusta, @echoasí que tuve que sacrificar 1 byte con @print.

En caso de que SE arruine la codificación, está destinado a codificarse en Windows-1252 (no UTF8).

APL (Dyalog Extended) , 33 29 bytes ^SBCS

-3 debido a mis extensiones de Dyalog APL.

Prefijo anónimo lambda:

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

Pruébalo en línea!

{... } "dfn"; ⍵es el argumento (longitudes laterales)

 ⍵*2 cuadrado

 +/ suma

 √ raíz cuadrada

 ⍵, argumento anterior

 {... }¨ aplique la siguiente lambda anónima a cada

  # espacio de nombres raíz

  ⍕ formatear como texto

  ⍵ ⍵⍴ utilizar argumento dos veces para r eshape en matriz con esas dimensiones.

 ⍪ convertir en columna

 ' ++=', anteponer estos tres caracteres a las tres filas

 , ravel (combinar filas en la lista)

 ⍕ formatear como texto

 ⊖ voltear al revés

CJam, 78 bytes

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

Primero calcula la hipotenusa (H), luego, para cada lado (S), construye una matriz de líneas S hechas de: H-Sespacios + Sguiones. Finalmente, transpone la matriz.

Manifestación

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: lectura simplificada
• Edit2: se eliminaron más espacios en blanco
• Edit3: abstracción de alias de iofunciones inspiradas en otra respuesta

Carbón de leña , 24 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Toma datos como una matriz de dos elementos. Explicación:

⊞θ₂ΣＸθ²

Agregue la hipotenusa a las entradas.

Ｆ =+«

Pase el cursor sobre los caracteres que aparecen a la derecha de cada cuadrado en orden inverso.

←←←ι←

Imprime ese personaje a la izquierda con espaciado.

Ｇ↑←↓⊟θ#

Haga estallar el último número de la matriz e imprima un cuadrado de #s de ese tamaño.

PowerShell , 139 137 135 bytes

^{-2 gracias a ASCII-only
-2 gracias a Mazzy}

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

Pruébalo en línea!

Calcular $ c duele y probablemente haya una mejor manera de cambiar condicionalmente entre #y . Crea una lista de fragmentos y los une mientras agrega los signos condicionalmente.

Japt, 28 bytes

Toma datos como una matriz de enteros.

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

Intentalo

                    :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„=+`.;

Toma la entrada como una lista de dos números (es decir [3,4]).

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Pruébalo en línea!

Bloque de código anónimo que toma dos números y devuelve la cadena completa con una nueva línea inicial y tres espacios iniciales y uno final en cada línea.

Si podemos usar otros caracteres en lugar de #, entonces puedo guardar un byte reemplazándolo '#'con \*.

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

Esto se siente demasiado tiempo. Esta versión solo se repite para construir la cadena.

EDITAR: ¡Ascii-Only con un bonito golf de -27 bytes usando el constructor de cadenas para adiciones de caracteres en serie! Además, escriba para señalar que estaba usando Math.Sqrt no System.Math.Sqrt. Esto ha sido ajustado!

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

Pruébalo en línea!