Explicar visualmente el teorema de Pitágoras

36

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

3 cajas

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 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
                       #############
        ############   #############
        ############   #############
        ############   #############
        ############   #############
        ############   #############
        ############   #############
        ############   #############
#####   ############   #############
#####   ############   #############
#####   ############   #############
#####   ############   #############
##### + ############ = #############
Maltysen
fuente
3
@bmarks "Nunca obtendrá valores para ayb que hagan que c no sea integral".
Maltysen
2
@RetoKoradi bien las áreas de las plazas a+b=c
Maltysen
1
Si a, by cse definen como las áreas de los cuadrados, entonces los ejemplos son incorrectos.
Reto Koradi
2
Debería agregar otro buen caso de prueba, como 5 + 12 = 13.
mbomb007
77
Nota: esto no es "una explicación visual del teorema de Pitágoras". Este es el teorema de Pitágoras. Originalmente fue formulado exactamente de esta manera: geométricamente. Ni siquiera sabían sobre raíces cuadradas, aún más interesante, el mismo Pitágoras no creía en la existencia de números irracionales. Esto significa que Pitágoras pensó que sqrt (2) puede representarse exactamente mediante la división de dos enteros finitos. El teorema original es lo que ahora llamamos la "representación visual"
vsz

Respuestas:

17

Pyth, 35 32 31 30 bytes

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

Pruébalo en línea.

orlp
fuente
Puede guardar un byte usando .ipara agregar las líneas en blanco en su lugar:j_.ts.i.imm*d\#d+Qs.aQ"+="mk4d
isaacg
12

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.
Dennis
fuente
11

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.

DLosc
fuente
Acabo de recibir lo mismo, me tomé un tiempo para darme cuenta de que es más corto repetirlo en "# "[i>a]*alugar de hacerlo para cada variable.
xnor
11

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.

Alex A.
fuente
11

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>

Downgoat
fuente
2
+1, pero hay un pequeño problema ya que el OP dice: "Observe cómo los signos = y + tienen espacios en ambos lados y cómo todo está en la parte inferior".
Léo Lam
1
El fragmento no funciona en Firefox 40.0.3 (Windows 7x64 SP1).
Ismael Miguel
1
El fragmento no funciona en Chromium 44 Linux x64
Nenotlep
2
@IsmaelMiguel Esos últimos casos no son necesarios para manejar correctamente, sin embargo: "Nunca obtendrá valores para ay beso hace que cno sea integral".
DLosc
2
+1 buen uso de eval. Sugerencia: (z<b?'#':' ')->' #'[z<b|0]
edc65
7

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.

Ypnypn
fuente
No sé exactamente qué hace su código, pero estoy bastante seguro de que puede beneficiarse de .interlace en lugar de todas esas listas.
Maltysen
@Maltysen Para tu último comentario, en realidad no puedo, porque la primera aparición Jes dentro de una lambda, que se evalúa después de que J se usa por primera vez.
Ypnypn
Ah, no vi eso. Otra cosa: *]puede ser reemplazado conm
Maltysen
3

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)
Level River St
fuente
No conozco a Ruby, pero supongo que esto puede acortarse, ya que las soluciones de Ruby a menudo superan a las soluciones de Python (en mi experiencia anecdótica). Para empezar, a*a+b*bdebe cortar dos bytes del cálculo de c.
DLosc
3

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.

pawel.boczarski
fuente
2

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

DankMemes
fuente
1
echovs print. ver: stackoverflow.com/questions/7094118/…
MarcDefiant
Ah eso tiene sentido. ¡Gracias!
DankMemes
2

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

Adán
fuente
1

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

Razvan
fuente
1

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
Jakuje
fuente
1

Carbón de leña , 24 bytes

⊞θ₂ΣXθ²F =+«←←←ι←G↑←↓⊟θ#

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:

⊞θ₂ΣXθ²

Agregue la hipotenusa a las entradas.

F =+«

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.

G↑←↓⊟θ#

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

Neil
fuente
1
@KevinCruijssen Whoa, ¡qué descuido! Debería arreglarse ahora.
Neil
1

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.

Veskah
fuente
1
hay paréntesis redundantes en $m=(" ","#"): ¡ Pruébelo en línea!
mazzy
@mazzy Ja ja,
whoops
0

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
Lanudo
fuente
0

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)
Kevin Cruijssen
fuente
DnOt©)˜ε'#×y.Dðy×®y-.D)R}ø»fue mi intento hasta que noté el +y =.
Urna de pulpo mágico
@MagicOctopusUrn Sí, esos tres espacios y +y =son de hecho responsable de la mayor parte del código. Por cierto, puedes jugar 2 bytes en tu enfoque reemplazando DnOt©)˜con nOt©ª, como hice en mi respuesta actual. :) Sin .Dembargo, me gusta tu uso de .
Kevin Cruijssen
0

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 \*.

Jo King
fuente
0

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!

Destroigo
fuente
1
recuerde que el punto y coma final no es necesario, y System.Mathtampoco Mathsi no está usando interactivo
solo ASCII
211?
Solo ASCII
1
187?
Solo ASCII
Una cosa, eliminaría todo el uso de directivas para asegurarme de no cometer un error
ASCII solo el
1
Ah, y ya que ya no tiene la versión ternaria no creo que debería mencionar nunca más
ASCII de sólo