Một lời giải thích trực quan phổ biến của định lý Pythagore là như sau:

Các hình vuông có nghĩa là đại diện cho bình phương chiều dài và các khu vực a + b = c, giống như định lý Pythagore nói.

Phần này là những gì bạn phải thể hiện.

Nhiệm vụ của bạn

• Bạn sẽ nhận được hai số nguyên làm đầu vào, có nghĩa là đại diện cho các cạnh avà bcủa một tam giác vuông (ví dụ 3, 4).
• Sau đó bạn sẽ làm cho hình vuông ra khỏi chiều dài a, bvà cra khỏi #nhân vật. Ví dụ ở đây là 3:

###
###
###

• Sau đó, bạn sẽ định dạng chúng thành một phương trình toán học giải thích bộ ba Pythagore cụ thể:

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

• Lưu ý cách =và +các dấu hiệu có khoảng trắng ở cả hai bên và cách mọi thứ ở phía dưới.
• Bạn sẽ không bao giờ có được giá trị cho avà bđiều đó làm cho ckhông tách rời.
• Đây là mã golf để mã ngắn nhất tính theo byte thắng!

Các trường hợp thử nghiệm

(sắp tới một khi tôi có thời gian, những thứ này thực sự rất khó để làm bằng tay)

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

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

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

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

Pyth, 35 32 31 30 byte

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

Hãy thử trực tuyến.

CJam, 49 byte

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

Hãy thử trực tuyến trong trình thông dịch CJam .

Làm thế nào nó hoạt động

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

Hãy thử trực tuyến.

Chương trình lấy đầu vào dưới dạng các số nguyên được phân tách bằng dấu phẩy, tính toán cạnh huyền bằng cách sử dụng các số phức có sẵn của Python, sau đó lặp lại từ tính toán giá trị đó và in từng dòng khi nó đi. Thủ thuật đánh gôn chính là sử dụng lập chỉ mục chuỗi thay cho các điều kiện để chọn #/ +/ =so với không gian.

Chỉnh sửa: Phiên bản đầu tiên là nạn nhân của một số kỹ thuật quá nghiêm trọng - phiên bản này vừa đơn giản vừa ngắn gọn hơn nhiều.

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

Ung dung:

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

Đã sửa lỗi và lưu 2 byte nhờ Glen O.

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

Tôi đã viết lại điều này với for. Nhiều sân golf vẫn ...

Nếu một cái gì đó không hoạt động, cho tôi biết. Tôi sẽ sửa nó vào buổi sáng.

Đã thử nghiệm trên Safari hàng đêm

Ung dung:

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

Giải trình:

(Không cập nhật) nhưng vẫn đủ chính xác.

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

BẢN GIỚI THIỆU

Phiên bản ES5 Đầu vào phải là bộ số hợp lệ :

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 byte

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

Mong đợi đầu vào trong mẫu [3,4].

Hãy thử nó ở đây

AQ - gán đầu vào cho G, H

Js.a,GH - tính toán cạnh huyền như J

Lj*b]*b\#;- định nghĩa y(b)là tạo một hình vuông có kích thước b(nơi khác trong mã, bcó nghĩa là dòng mới)

j_MCm_.[d\ Jcj[yJb\=byHb\+byG))b - Tạo các hình vuông, miếng đệm có khoảng trắng và chuyển vị

Lưu hai byte nhờ Maltysen.

Hồng ngọc, 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}}

đường đơn giản theo cách tiếp cận dòng.

Dưới đây trong chương trình thử nghiệm, với ký hiệu được thay đổi thành @ để giúp tránh nhầm lẫn với cú pháp #{....}("nội suy chuỗi") được sử dụng để chèn biểu thức vào chuỗi. Mỗi đầu vào nên được đưa ra trên một dòng khác nhau.

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 byte

C sẽ không giành được điều này, nhưng niềm vui là xứng đáng.

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

In đẹp:

#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 cho phép chúng ta truyền tham số thứ ba cho main (một mảng các biến môi trường), vì vậy chúng tôi tận dụng nó để sử dụng nó cho mục đích của chúng tôi.

Các

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

sẽ tương đương với

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

bởi vì scanftrả về số lượng tham số được quét thành công.

PHP, 178 170 168 byte

Đầu vào là các tham số GET xvà y. Thật không may, tôi dường như không thể đánh golf những chuỗi lặp lại.

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

• Đã lưu 8 byte bằng cách đảo ngược tất cả các chuỗi của tôi và bỏ dấu ngoặc kép.
• Đã lưu 2 byte bằng cách thay thế điều kiện $i>0bằng$i

Không chắc tại sao PHP không thích @echonên tôi đã phải hy sinh 1 byte với @print.

Trong trường hợp SE vặn mã hóa, điều này có nghĩa là được mã hóa trong Windows-1252 (không phải UTF8).

APL (Dyalog Extended) , 33 29 byte ^SBCS

-3 do phần mở rộng của tôi về Dyalog APL.

Tiền tố nặc danh lambda:

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

Hãy thử trực tuyến!

{... } "DFN"; ⍵là đối số (độ dài bên)

 ⍵*2 Quảng trường

 +/ tổng

 √ căn bậc hai

 ⍵, tranh luận

 {... }¨ áp dụng lambda ẩn danh sau đây để mỗi

  # không gian tên gốc

  ⍕ định dạng như văn bản

  ⍵ ⍵⍴ sử dụng đối số hai lần để r eshape thành ma trận với các kích thước đó.

 ⍪ làm thành cột

 ' ++=', thêm ba ký tự vào ba hàng

 , ravel (kết hợp các hàng thành danh sách)

 ⍕ định dạng như văn bản

 ⊖ lộn ngược

CJam, 78 byte

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

Đầu tiên, nó tính toán cạnh huyền (H), sau đó, với mỗi bên (S), nó xây dựng một mảng các dòng S được tạo thành từ: H-Sdấu cách + Sdấu gạch ngang. Cuối cùng, nó chuyển đổi ma trận.

Bản giới thiệu

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

• Chỉnh sửa1: Đọc đơn giản
• Edit2: Đã xóa nhiều khoảng trắng hơn
• Edit3: bí danh trừu tượng hóa các iochức năng lấy cảm hứng từ một câu trả lời khác

Than , 24 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Đưa đầu vào là một mảng gồm hai phần tử. Giải trình:

⊞θ₂ΣＸθ²

Nối các cạnh huyền vào các đầu vào.

Ｆ =+«

Lặp lại các ký tự xuất hiện ở bên phải của mỗi hình vuông theo thứ tự ngược lại.

←←←ι←

In ký tự đó sang trái với khoảng cách.

Ｇ↑←↓⊟θ#

Bật số cuối cùng từ mảng và in một hình vuông #có kích thước đó.

PowerShell , 139 137 135 byte

^{-2 chỉ nhờ ASCII
-2 nhờ Mazzy}

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

Hãy thử trực tuyến!

Tính toán $ c bị tổn thương và có lẽ có một cách tốt hơn để trao đổi có điều kiện giữa #và . Xây dựng một danh sách các khối và nối chúng lại với nhau trong khi có điều kiện thêm các dấu hiệu.

Japt, 28 byte

Đưa đầu vào như một mảng các số nguyên.

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

Thử nó

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

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

Lấy đầu vào là một danh sách gồm hai số (nghĩa là [3,4]).

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Khối mã ẩn danh nhận hai số và trả về chuỗi đầy đủ với một dòng mới hàng đầu và ba khoảng trắng hàng đầu và một dấu ở trên mỗi dòng.

Nếu chúng ta có thể sử dụng các ký tự khác thay vì #, thì tôi có thể lưu một byte bằng cách thay thế '#'bằng \*.

C # (Lõi .NET) , 221 , 194 byte

Điều này cảm thấy quá dài. Phiên bản này chỉ là các vòng lặp để xây dựng chuỗi.

EDIT: Ascii-Chỉ với một golf -27 byte đẹp bằng cách sử dụng hàm tạo chuỗi cho các bổ sung char nối tiếp! Ngoài ra, ty đã chỉ ra tôi đang sử dụng Math.Sqrt chứ không phải System.Math.Sqrt. Điều này đã được điều chỉnh!

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

Hãy thử trực tuyến!