Поширене візуальне пояснення теореми Піфагора є таким:

Квадрати призначені для відображення сторони довжини квадрата, а площі a + b = c, так, як говорить теорема Піфагора.

Ця частина - те, що ви маєте показати.

Ваше завдання

• Ви отримаєте два цілих числа як вхідні дані, призначені для відображення сторін aі bпрямого трикутника (наприклад 3, 4).
• Ви будете тоді робити квадрати з довжин a, bі cз #характеру. Наприклад ось 3:

###
###
###

• Потім ви відформатуєте їх у математичне рівняння, яке пояснює конкретний піфагорейський триплет:

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

• Зауважте, як знаки =та +знаки мають пробіли з обох боків та як усе знаходиться внизу.
• Ви ніколи не будете отримувати значення aі bщо роблять cНе вбудована.
• Це код-гольф, тому найкоротший код у байтах виграє!

Випробування

(більше приходить, коли я встигну, це справді важко зробити вручну)

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

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

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

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

Pyth, 35 32 31 30 байт

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

Спробуйте в Інтернеті.

CJam, 49 байт

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

Спробуйте його в Інтернеті в інтерпретаторі CJam .

Як це працює

" +   = "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 байт

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

Спробуйте в Інтернеті.

Програма приймає введення як цілі числа, розділені комами, обчислює гіпотенузу за допомогою вбудованих комплексних чисел Python, потім циклічно знижує цю величину, обчислюючи та друкуючи кожен рядок, як вона йде. Основний трюк з гольфу - використання індексації рядків замість умов для вибору місця #/ +/ =проти місця.

Редагувати: Перша версія стала жертвою серйозної надмірної інженерії - ця версія є і простішою, і значно коротшою.

Джулія, 121 114 112 байт

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

Безголівки:

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

Виправлена ​​проблема та збережено 2 байти завдяки Глен О.

JavaScript ES6, 155 134 140 129 байт

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

Я переписав це з for. Ще багато гольфу ...

Якщо щось не працює, дайте мені знати. Я виправлю це вранці.

Тестується на Safari Nightly

Безголівки:

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

Пояснення:

(Не оновлюється), але все ще досить точна.

(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

Версія ES5 Введення має бути дійсним набором чисел :

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 байт

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

Очікує введення форми [3,4].

Спробуйте тут

AQ - призначає вхід до G, H

Js.a,GH - обчислює гіпотенузу як J

Lj*b]*b\#;- визначає y(b)як створення квадрата розміру b(в іншому місці коду bозначає новий рядок)

j_MCm_.[d\ Jcj[yJb\=byHb\+byG))b - Створює квадрати, майданчики з пробілами та переміщує

Збережено два байти завдяки Малтісену.

Рубі, 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}}

простий підхід за лінією.

Нижче в тестовій програмі символ із зміною на @, щоб уникнути переплутування з синтаксисом #{....}("рядкова інтерполяція"), що використовується для вставки виразів у рядок. Кожен вхід повинен бути вказаний в іншому рядку.

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 байт

C не збирається цього виграти, але веселощі того варті.

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

Досить надруковано:

#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 дозволяє нам передавати третій параметр main (масив змінних середовища), тому ми використовуємо його, щоб використовувати його для наших цілей.

The

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

було б рівнозначно

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

тому що scanfповертає кількість успішно відсканованих параметрів.

PHP, 178 170 168 байт

Вхід - параметри GET xі y. На жаль, я не можу здатись на гольф тих повторюваних струн.

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

• Збережено 8 байт, перевернувши всі мої рядки та відкинувши лапки.
• Збережено 2 байти, замінивши умову $i>0на$i

Не впевнений, чому PHP не подобається, @echoтому мені довелося пожертвувати 1 байтом @print.

Якщо SE прикручує кодування, це має бути закодовано в Windows-1252 (не UTF8).

APL (Dyalog Extended) , 33 29 байт ^SBCS

-3 через мої розширення Dyalog APL.

Анонімний префікс лямбда:

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

Спробуйте в Інтернеті!

{… } "Dfn"; ⍵є аргументом (бічні довжини)

 ⍵*2 Майдан

 +/ сума

 √ квадратний корінь

 ⍵, аргумент подання

 {… }¨ Застосувати наступні анонімні лямбда до кожного

  # простір імен кореня

  ⍕ формат у вигляді тексту

  ⍵ ⍵⍴ використовуйте аргумент двічі, щоб r сформувати матрицю з цими розмірами.

 ⍪ внести в стовпчик

 ' ++=', додайте ці три символи до трьох рядків

 , ravel (поєднувати рядки в список)

 ⍕ формат у вигляді тексту

 ⊖ перевернути догори дном

CJam, 78 байт

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

Спочатку обчислює гіпотенузу (Н), потім для кожної сторони (S) будує масив S ліній, що складається з: H-Sпробілів +S тире. Нарешті, він транспонує матрицю.

Демо

Lua5.2, 257 241 227 222 байти

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: спрощене читання
• Edit2: видалено більше пробілів
• Edit3: псевдонім абстрагування ioфункцій, натхнених іншою відповіддю

Вугілля деревне , 24 байти

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Приймає вхід як масив з двох елементів. Пояснення:

⊞θ₂ΣＸθ²

Додайте гіпотенузу до входів.

Ｆ =+«

Проведіть петлю над символами, які з’являються праворуч від кожного квадрата у зворотному порядку.

←←←ι←

Роздрукуйте цей символ вліво з пробілом.

Ｇ↑←↓⊟θ#

Поставте останнє число з масиву та надрукуйте квадрат #s такого розміру.

PowerShell , 139 137 135 байт

^{-2 завдяки ASCII лише
-2 завдяки Mazzy}

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

Спробуйте в Інтернеті!

Розрахунок $ c болить, і, ймовірно, є кращий спосіб умовно поміняти місцями на #та . Складає список шматочків і з'єднує їх разом, умовно додаючи знаки.

Japt, 28 байт

Вводить введення як масив цілих чисел.

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

Спробуй це

                    :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 байт

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

Приймає вхід як список двох чисел (тобто [3,4]).

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

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 байт

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

Спробуйте в Інтернеті!

Блок анонімного коду, який займає два числа, і повертає повний рядок із провідним новим рядком та трьома провідними пробілами та одним заднім рядком у кожному рядку.

Якщо ми можемо використовувати інші символи замість #, тоді я можу зберегти байт, замінивши '#'на \*.

C # (.NET Core) , 221 , 194 байт

Це відчувається занадто довго. Ця версія просто циклічно побудує рядок.

EDIT: Ascii-Тільки з приємним гольфом -27 байт, використовуючи конструктор струн для доповнення серійних символів! Крім того, для вказівки я використовував Math.Sqrt, а не System.Math.Sqrt. Це було скориговано!

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

Спробуйте в Інтернеті!