Spiega visivamente il teorema di Pitagora


36

Una spiegazione visiva comune del teorema di Pitagora è come tale:

3 boxes

I quadrati hanno lo scopo di rappresentare il quadrato della lunghezza laterale e le aree di a + b = c , proprio come dice il teorema di Pitagora.

Questa parte è ciò che devi mostrare.

Il tuo compito

  • Otterrai due numeri interi come input, intesi a rappresentare i lati ae bdi un triangolo rettangolo (es. 3, 4).
  • Sarà quindi rendere piazze fuori delle lunghezze a, be cfuori dal #personaggio. Ad esempio qui è 3:
###
###
###
  • Quindi li formatterai in un'equazione matematica che spiega la particolare tripletta di Pitagora:
             #####
      ####   #####
###   ####   #####
###   ####   #####
### + #### = #####
  • Notare come i segni =e +hanno spazi su entrambi i lati e come tutto è sul fondo.
  • Non otterrai mai valori per ae bche renderanno cnon integrali.
  • Questo è quindi vince il codice più breve in byte !

Casi test

(altri in arrivo una volta che ho tempo, questi sono davvero difficili da fare a mano)

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

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

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

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

3
@bmarks "Non otterrai mai valori per aeb che rendono c non integrale."
Maltysen,

2
@RetoKoradi bene le aree delle piazze a+b=c
Maltysen

1
Se a, be csono definite come le aree dei quadrati, quindi gli esempi non sono corretti.
Reto Koradi,

2
Dovresti aggiungere un altro bel test case, come 5 + 12 = 13.
mbomb007

7
Nota: questa non è "una spiegazione visiva del teorema di Pitagora". Questo è il teorema di Pitagora. Originariamente era stato formulato esattamente in questo modo: geometricamente. Non sapevano nemmeno delle radici quadrate, ancor più interessanti, lo stesso Pitagora non credeva nell'esistenza di numeri irrazionali. Questo significa che Pitagora pensava che sqrt (2) potesse essere rappresentato esattamente dalla divisione di due numeri interi finiti. Il teorema originale è ciò che ora chiamiamo "rappresentazione visiva"
vsz

Risposte:


17

Pyth, 35 32 31 30 byte

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

Provalo online.


È possibile salvare un byte utilizzando invece .iper aggiungere le righe vuote:j_.ts.i.imm*d\#d+Qs.aQ"+="mk4d
isaacg

12

CJam, 49 byte

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

Provalo online nell'interprete CJam .

Come funziona

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

11

Python 2, 134 100 byte

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

Provalo online.

Il programma accetta input come numeri interi separati da virgola, calcola l'ipotenusa utilizzando i numeri complessi incorporati di Python, quindi scorre da quel valore calcolando e stampando ogni riga mentre procede. Il trucco principale del golf sta usando l'indicizzazione delle stringhe al posto dei condizionali per selezionare #/ +/ =vs spazio.

Modifica: la prima versione è stata vittima di un grave eccesso di ingegneria: questa è sia più semplice che molto più breve.


Ho appena ottenuto la stessa cosa, dopo aver impiegato un po 'di tempo per rendermi conto che è più breve ripetere solo "# "[i>a]*ainvece di farlo per ogni variabile.
xnor

11

Julia, 121 114 112 byte

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

Risolto problema e salvato 2 byte grazie a Glen O.


11

JavaScript ES6, 155 134 140 129 byte

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

L'ho riscritto con for . Un sacco di golf ancora ...

Se qualcosa non funziona, fammi sapere. Lo riparerò domani mattina.

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

Spiegazione:

(Non aggiornato) ma comunque abbastanza 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
  `

DEMO

Versione ES5 L' ingresso deve essere un set di numeri valido :

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>


2
+1, ma c'è un piccolo problema come dice l'OP: "Nota come i segni = e + hanno spazi su entrambi i lati e come tutto è in fondo."
Léo Lam,

1
Lo snippet non funziona su Firefox 40.0.3 (Windows 7x64 SP1).
Ismael Miguel,

1
Lo snippet non funziona in Chromium 44 Linux x64
Nenotlep

2
@IsmaelMiguel Questi ultimi casi non sono necessari per gestire correttamente, tuttavia: "Non otterrai mai valori per ae bche renderanno cnon integrali."
DLosc,

2
+1 buon uso di eval. Suggerimento: (z<b?'#':' ')->' #'[z<b|0]
edc65,

7

Pyth, 51 49 byte

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

Prevede input nel modulo [3,4].

Provalo qui

AQ - assegna l'ingresso a G, H

Js.a,GH - calcola l'ipotenusa come J

Lj*b]*b\#;- definisce y(b)come fare un quadrato di dimensioni b(altrove nel codice, bsignifica newline)

j_MCm_.[d\ Jcj[yJb\=byHb\+byG))b - Crea i quadrati, i pad con spazi e traspone

Salvati due byte grazie a Maltysen.


Non so esattamente cosa faccia il tuo codice, ma sono abbastanza sicuro che possa trarre vantaggio da .interlace invece di tutte quelle liste.
Maltysen,

@Maltysen Al tuo ultimo commento, in realtà non posso, perché la prima apparizione Jè all'interno di una lambda, che viene valutata dopo che J viene utilizzata per la prima volta.
Ypnypn,

ah, non l'ho visto. Un'altra cosa: *]può essere sostituito conm
Maltysen,

3

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

approccio semplice linea per linea.

Di seguito nel programma di test, con il simbolo modificato in @ per evitare di confondere con la sintassi #{....}("interpolazione di stringhe") utilizzata per inserire espressioni in una stringa. Ogni input dovrebbe essere dato su una riga diversa.

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)

Non conosco Ruby, ma immagino che questo possa essere più breve, poiché le soluzioni Ruby spesso battono le soluzioni Python (nella mia esperienza aneddotica). Per i principianti, a*a+b*bdovrebbe tagliare due byte dal calcolo di c.
DLosc,

3

C, 176 byte

C non lo vincerà, ma ne vale la pena.

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

Abbastanza stampato:

#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 ci consente di passare il terzo parametro a main (una matrice di variabili d'ambiente), quindi ne approfittiamo per usarlo per il nostro scopo.

Il

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

sarebbe equivalente a

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

perché scanfrestituisce il numero di parametri scansionati correttamente.


2

PHP, 178 170 168 byte

L'input è parametri GET xe y. Sfortunatamente non riesco a giocare a golf con quelle corde che si ripetono.

<?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).~õ;
  • Ho salvato 8 byte invertendo tutte le mie stringhe e rilasciando le virgolette.
  • Salvato 2 byte sostituendo la condizione $i>0con$i

Non sono sicuro del motivo per cui a PHP non piace, @echoquindi ho dovuto sacrificare 1 byte con@print .

Nel caso in cui SE rovini la codifica, questo dovrebbe essere codificato in Windows-1252 (non UTF8).



Ah, ha senso. Grazie!
DankMemes,

2

APL (Dyalog Extended) , 33 29 byte SBCS

-3 a causa delle mie estensioni di Dyalog APL.

Prefisso anonimo lambda:

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

Provalo online!

{... } "dfn"; è l'argomento (lunghezze laterali)

⍵*2 piazza

+/ somma

 radice quadrata

⍵, anteporre argomento

{...  applica la seguente lambda anonima a ciascuno

  # spazio dei nomi di root

   formatta come testo

  ⍵ ⍵⍴ utilizzare l'argomento due volte per r eshape in matrice con quelle dimensioni.

 trasformarsi in colonna

' ++=', anteporre questi tre caratteri alle tre righe

, ravel (combina le righe in elenco)

 formatta come testo

 capovolgere


1

CJam, 78 byte

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

Calcola prima l'ipotenusa (H), quindi, per ogni lato (S), crea una matrice di linee S formate da: H-Sspazi + Strattini. Infine, traspone la matrice.

dimostrazione


1

Lua5.2, 257 241 227 222 byte

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: lettura semplificata
  • Modifica2: rimossi più spazi bianchi
  • Edit3: alias astrazione di iofunzioni ispirate a un'altra risposta

1

Carbone , 24 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Accetta input come una matrice di due elementi. Spiegazione:

⊞θ₂ΣXθ²

Aggiungi l'ipotenusa agli input.

F =+«

Scorri i personaggi che appaiono a destra di ogni quadrato in ordine inverso.

←←←ι←

Stampa quel personaggio a sinistra con spaziatura.

G↑←↓⊟θ#

Pop l'ultimo numero dall'array e stampare un quadrato di #s di quella dimensione.


1
@KevinCruijssen Whoa, che svista! Ora dovrebbe essere risolto.
Neil

1

PowerShell , 139 137 135 byte

-2 grazie alla sola ASCII
-2 grazie 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" "}

Provalo online!

Calcolare $ c ferito e probabilmente c'è un modo migliore per scambiare condizionalmente tra #e . Crea un elenco di blocchi e li unisce, aggiungendo condizionalmente i segni.


1
c'è una parentesi ridondante in $m=(" ","#"): provala online!
mazzy

@mazzy Ah ah, whoops
Veskah

0

Japt, 28 byte

Accetta l'input come una matrice di numeri interi.

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

Provalo

                    :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

0

05AB1E , 38 byte

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

Prende l'input come un elenco di due numeri (es [3,4].).

Provalo online o verifica tutti i casi di test .

Spiegazione:

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)

DnOt©)˜ε'#×y.Dðy×®y-.D)R}ø»è stato il mio tentativo fino a quando ho notato il +e =.
Magic Octopus Urn

@MagicOctopusUrn Sì, quei tre spazi e +e =sono infatti responsabili per la maggior parte del codice. A proposito, puoi golf 2 byte nel tuo approccio sostituendolo DnOt©)˜con nOt©ª, come ho fatto nella mia risposta attuale. :) Mi piace il tuo uso .D, però.
Kevin Cruijssen il

0

Perl 6 , 99 byte

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

Provalo online!

Blocco di codice anonimo che accetta due numeri e restituisce la stringa completa con una nuova riga iniziale e tre spazi iniziali e uno finale su ogni riga.

Se possiamo usare altri caratteri invece di #, allora posso salvare un byte sostituendolo '#'con \*.


0

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

Sembra troppo lungo. Questa versione esegue semplicemente dei loop per costruire la stringa.

EDIT: Ascii-Solo con un bel golf da -27 byte usando il costruttore di stringhe per aggiunte di caratteri seriali! Inoltre, per sottolineare che stavo usando Math.Sqrt non System.Math.Sqrt. Questo è stato modificato!

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

Provalo online!


1
ricorda il punto e virgola finale non è necessario, e anche System.Mathnon Mathse non si sta usando interattivo
ASCII-only



Una cosa, rimuoverei tutto usando le direttive per assicurarmi di non aver fatto un errore
ASCII-only

1
Oh, e dato che non hai più la versione ternaria, non penso che dovresti più menzionarla
ASCII-solo il
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.