पायथागॉरियन प्रमेय की एक सामान्य दृश्य व्याख्या इस प्रकार है:

वर्ग साइड लंबाई के वर्ग का प्रतिनिधित्व करने के लिए होते हैं, और a + b = cजैसे पाइथागोरस प्रमेय कहते हैं।

यह हिस्सा आपको दिखाना है।

आपका कार्य

आपको इनपुट के रूप में दो पूर्णांक मिलेंगे, जिसका अर्थ पक्षों का प्रतिनिधित्व करना है a और bएक समकोण त्रिभुज (पूर्व 3, 4) ।
इसके बाद आप लंबाई के बाहर वर्गों कर देगा a, bऔर cसे बाहर #चरित्र। उदाहरण के लिए यहाँ 3 है:

###
###
###

फिर आप उन्हें एक गणित समीकरण में प्रारूपित करेंगे जो विशेष पाइथागोरस ट्रिपलेट की व्याख्या करता है:

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

ध्यान दें कि कैसे = और +संकेतों के दोनों तरफ रिक्त स्थान हैं और नीचे सब कुछ कैसे है।
आपको कभी भी मान नहीं मिलेगा aऔरb यह cगैर-अभिन्न बनाता है ।
यह बाइट्स में कोड-गोल्फ इतना छोटा कोड है जीत !

परीक्षण के मामलों

(मेरे पास एक बार आने के बाद, ये वास्तव में हाथ से बनाना मुश्किल है)

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

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

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

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

code-golf ascii-art geometry

— Maltysen
स्रोत

3

@ चिह्न "आपको कभी भी ए और बी के लिए मान नहीं मिलेगा जो कि गैर-अभिन्न बनाते हैं।"

— माल्टीसेन

2

@RetoKoradi अच्छी तरह से चौकों के क्षेत्रोंa+b=c

— माल्टीसेन

1

यदि a, bऔर cवर्गों के क्षेत्रों के रूप में परिभाषित किया गया है, तो उदाहरण गलत हैं।

— रेटो कोराडी

2

आपको एक और अच्छा टेस्ट केस जोड़ना चाहिए, जैसे 5 + 12 = 13.

— mbomb007

7

नोट: यह "पाइथागोरस प्रमेय का एक दृश्य विवरण" नहीं है। यह वह जगह है पाइथागोरस प्रमेय। यह मूल रूप से इस तरह से तैयार किया गया था: ज्यामितीय रूप से। वे वर्गमूलों के बारे में भी नहीं जानते थे, और भी दिलचस्प है, पाइथागोरस खुद तर्कहीन संख्याओं के अस्तित्व में विश्वास नहीं करता था। इसका मतलब यह है कि पाइथागोरस ने सोचा था कि sqrt (2) को दो परिमित पूर्णांकों के विभाजन द्वारा दर्शाया जा सकता है। मूल प्रमेय वह है जिसे अब हम "दृश्य प्रतिनिधित्व" कहते हैं

— vsz

17

पायथ, 35 32 31 30 बाइट्स

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

इसे ऑनलाइन आज़माएं।

— orlp
स्रोत

आप .iइसके बजाय रिक्त लाइनों को जोड़ने के लिए एक बाइट का उपयोग करके बचा सकते हैं :j_.ts.i.imm*d\#d+Qs.aQ"+="mk4d

— isaacg

12

सीजेएम, 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.

— डेनिस
स्रोत

11

अजगर 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

इसे ऑनलाइन आज़माएं।

कार्यक्रम इनपुट को अल्पविराम से अलग किए गए पूर्णांक के रूप में लेता है, पायथन के अंतर्निहित जटिल संख्याओं का उपयोग करके कर्ण की गणना करता है, फिर उस मूल्य से नीचे झुकता है और प्रत्येक पंक्ति को प्रिंट करता है जैसा कि यह जाता है। मुख्य गोल्फिंग ट्रिक को चयन करने के लिए सशर्त के स्थान पर स्ट्रिंग इंडेक्सिंग का उपयोग किया जाता है #/+ /= बनाम स्थान का उपयोग कर रही है।

संपादित करें: पहला संस्करण कुछ गंभीर ओवर-इंजीनियरिंग का शिकार था - यह सरल और बहुत कम दोनों है।

— DLosc
स्रोत

मुझे बस एक ही चीज मिली, यह महसूस करने में थोड़ा समय लगा कि यह "# "[i>a]*aप्रत्येक चर के लिए करने के बजाय सिर्फ दोहराने के लिए कम है ।

— xnor

11

जूलिया, 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

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

फिक्स्ड मुद्दा और ग्लेन ओ के लिए 2 बाइट्स को बचाया।

— एलेक्स ए।
स्रोत

11

जावास्क्रिप्ट ईएस 6, 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। अभी भी बहुत सारे गोल्फ ...

अगर कुछ काम नहीं कर रहा है, तो मुझे बताएं। मैं इसे सुबह ठीक कर दूंगा।

सफारी नाइटली पर परीक्षण किया गया

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

स्पष्टीकरण:

(अद्यतन नहीं) लेकिन फिर भी पर्याप्त सटीक।

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

डेमो

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>

स्निपेट का विस्तार करें

— Downgoat
स्रोत

2

+1, लेकिन ओपी का कहना है कि एक छोटा मुद्दा है: "ध्यान दें कि कैसे = और + संकेतों के दोनों तरफ रिक्त स्थान हैं और नीचे की तरफ सब कुछ कैसे है।"

— लीओ लैम

1

स्निपेट फ़ायरफ़ॉक्स 40.0.3 (विंडोज 7x64 SP1) पर काम नहीं कर रहा है।

— इस्माईल मिगुएल

1

स्निपेट क्रोमियम 44 लिनक्स x64 में काम नहीं कर रहा है

— नेनोटलेप

2

@IsmaelMiguel उन उत्तरवर्ती मामलों को सही ढंग से संभालना आवश्यक नहीं है, हालांकि: "आपको कभी भी मूल्य नहीं मिलेंगे aऔर bयह cगैर-अभिन्न बनाते हैं ।"

— DLosc

2

Eval का +1 अच्छा उपयोग। संकेत: (z<b?'#':' ')->' #'[z<b|0]

— edc65

7

पायथ, 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 - स्थानों के साथ वर्ग, पैड बनाता है, और स्थानांतरित करता है

माल्टीसेन को धन्यवाद दो बाइट्स बचाए।

— Ypnypn
स्रोत

मुझे नहीं पता कि आपका कोड वास्तव में क्या करता है, लेकिन मुझे पूरा यकीन है कि यह .iउन सभी सूचियों के बजाय nterlace से लाभ उठा सकता है ।

— माल्टसेन

@ मैल्टेनसेन आपकी अंतिम टिप्पणी के लिए, वास्तव में मैं नहीं कर सकता, क्योंकि पहली उपस्थिति Jएक मेमने के अंदर है, जिसे पहले इस्तेमाल किए जाने के बाद मूल्यांकन Jकिया जाता है।

— यपनिप

आह, यह नहीं देखा। एक और बात: *]साथ बदला जा सकताm

— Maltysen

3

रूबी, 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)

— स्तर नदी सेंट
स्रोत

मैं रूबी को नहीं जानता, लेकिन मुझे लगता है कि यह कम हो सकता है, क्योंकि रूबी समाधान अक्सर पायथन समाधान (मेरे वास्तविक अनुभव में) को हरा देता है। शुरुआत के लिए, a*a+b*bकी गणना से दो बाइट्स में कटौती करनी चाहिए c।

— 23

3

सी, 176 बाइट्स

सी यह जीतने नहीं जा रहा है, लेकिन मज़ा इसके लायक है।

#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 हमें तीसरे पैरामीटर को मुख्य (पर्यावरण चर की एक सरणी) पास करने में सक्षम बनाता है, इसलिए हम इसका लाभ उठाकर अपने उद्देश्य के लिए इसका उपयोग करते हैं।

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सफलतापूर्वक स्कैन किए गए मापदंडों की संख्या देता है।

— pawel.boczarski
स्रोत

2

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

मेरे सभी तार inverting और उद्धरण छोड़ने से 8 बाइट्स बचाता है।
के $i>0साथ स्थिति को बदलकर 2 बाइट्स सहेजे गए$i

निश्चित नहीं है कि PHP को पसंद क्यों नहीं है @echoइसलिए मुझे 1 बाइट के साथ बलिदान करना पड़ा@print ।

यदि एसई एन्कोडिंग को खराब कर देता है, तो इसका मतलब विंडोज -1252 (यूटीएफ 8 नहीं) में एनकोड किया जाना है।

— DankMemes
स्रोत

1

echoबनाम print। देखें: stackoverflow.com/questions/7094118/…

— MarcDefiant

आह कि समझ में आता है। धन्यवाद!

— DankMemes

2

APL (Dyalog Extended) , 33 29 बाइट्स ^SBCS

-3 Dyalog APL के मेरे एक्सटेंशन के कारण।

अनाम उपसर्ग लंबोदर:

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

इसे ऑनलाइन आज़माएं!

{... } "dfn"; ⍵तर्क है (साइड लंबाई)

⍵*2 वर्ग

+/ योग

√ वर्गमूल

⍵, तर्क देना

{...}¨ प्रत्येक के लिए निम्नलिखित अनाम लंबोदर लागू करें

# रूट नेमस्पेस

⍕ पाठ के रूप में प्रारूपित करें

⍵ ⍵⍴ तर्क का उपयोग दो बार r उन आयामों के साथ मैट्रिक्स में eshape।

⍪ स्तंभ में बनाओ

' ++=', इन तीनों वर्णों को तीन पंक्तियों में प्रस्तुत करें

, ravel (सूची में पंक्तियों को संयोजित करें)

⍕ पाठ के रूप में प्रारूपित करें

⊖ उलटा पलटना

— एडम
स्रोत

1

सीजेएम, 78 बाइट्स

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

यह पहले कर्ण (H) की गणना करता है, फिर प्रत्येक पक्ष (S) के लिए, यह S: रेखाओं से बना एक सरणी बनाता है: H-Sरिक्त स्थान +S डैश। अंत में, यह मैट्रिक्स को स्थानांतरित करता है।

डेमो

— राज़्वान
स्रोत

1

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 से प्रेरित कार्यों के अमूर्त

— Jakuje
स्रोत

1

चारकोल , 24 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। दो तत्वों की एक सरणी के रूप में इनपुट लेता है। स्पष्टीकरण:

⊞θ₂ΣＸθ²

इनपुट के लिए कर्ण को संलग्न करें।

Ｆ =+«

वर्णों पर लूप करें जो प्रत्येक वर्ग के दाईं ओर रिवर्स ऑर्डर में दिखाई देते हैं।

←←←ι←

उस वर्ण को स्पेसिंग के साथ बाईं ओर प्रिंट करें।

Ｇ↑←↓⊟θ#

सरणी से अंतिम संख्या पॉप करें और #उस आकार के वर्ग का प्रिंट लें ।

— नील
स्रोत

1

@KevinCruijssen वाह, क्या एक निरीक्षण! अब तय होना चाहिए।

— नील

1

पॉवरशेल , 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" "}

इसे ऑनलाइन आज़माएं!

$ ग चोट गिना जा रहा है और वहाँ शायद के बीच सशर्त स्वैप करने के लिए एक बेहतर तरीका है #और । चंक्स की एक सूची बनाता है और सशर्त रूप से संकेत जोड़ते हुए उन्हें एक साथ जोड़ देता है।

— Veskah
स्रोत

1

इसमें एक निरर्थक कोष्ठक है $m=(" ","#"): इसे ऑनलाइन आज़माएं!

— माज़ी

@ माज़ी हा हा,

— हूप्स

0

जाप, 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

— झबरा
स्रोत

0

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)

— केविन क्रूज़सेन
स्रोत

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn हाँ, उन तीन रिक्त स्थान और +और =वास्तव में कोड के अधिकांश भाग के लिए जिम्मेदार हैं। Btw, आप कर सकते हैं गोल्फ 2 बदलकर अपना दृष्टिकोण में बाइट्स DnOt©)˜के साथ nOt©ª, के रूप में मैं अपने वर्तमान जवाब में किया था। :) मुझे आपका उपयोग पसंद है .D, यद्यपि।

— केविन क्रूज़सेन

0

पर्ल 6 , 99 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बेनामी कोड ब्लॉक जो दो नंबर लेता है और एक प्रमुख नई लाइन और तीन प्रमुख रिक्त स्थान और प्रत्येक पंक्ति पर एक अनुगामी के साथ पूर्ण स्ट्रिंग लौटाता है।

हम बजाय अन्य वर्णों का उपयोग कर सकते हैं #, तो मैं बदल कर एक बाइट बचा सकता है '#'के साथ \*।

— मजाक कर रहा है
स्रोत

0

C # (.NET कोर) , 221 , 194 बाइट्स

यह बहुत लंबा लगता है। यह संस्करण केवल स्ट्रिंग का निर्माण करने के लिए लूप करता है।

संपादित करें: सीरियल चर परिवर्धन के लिए स्ट्रिंग कंस्ट्रक्टर का उपयोग करते हुए Ascii-only एक अच्छा -27 बाइट गोल्फ के साथ! इसके अलावा, मैं बाहर इशारा करने के लिए ty गणित का उपयोग कर रहा था। यह समायोजित किया गया है!

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

इसे ऑनलाइन आज़माएं!

— Destroigo
स्रोत

1

याद रखें कि अंतिम अर्धविराम की जरूरत नहीं है, और यह भी System.MathनहींMath यदि आप इंटरैक्टिव का उपयोग नहीं कर रहे हैं

— ASCII-only

211?

— एएससीआईआई-केवल

1

187?

— ASCII- केवल

एक बात, मैं यह सुनिश्चित करने के लिए सभी निर्देशों का उपयोग करूँगा कि मैंने कोई गलती नहीं की है

— ASCII-only

1

ओह और चूंकि अब आपके पास टर्नरी संस्करण नहीं है, मुझे नहीं लगता कि आपको इसका अब और उल्लेख करना चाहिए

— एएससीआईआई-केवल

नेत्रहीन पाइथागोरस प्रमेय की व्याख्या करें

आपका कार्य

परीक्षण के मामलों

पायथ, 35 32 31 30 बाइट्स

सीजेएम, 49 बाइट्स

यह काम किस प्रकार करता है

अजगर 2, 134 100 बाइट्स

जूलिया, 121 114 112 बाइट्स

जावास्क्रिप्ट ईएस 6, 155 134 140 129 बाइट्स

Ungolfed:

स्पष्टीकरण:

डेमो

पायथ, 51 49 बाइट्स

रूबी, 134

सी, 176 बाइट्स

PHP, 178 170 168 बाइट्स

APL (Dyalog Extended) , 33 29 बाइट्स SBCS

सीजेएम, 78 बाइट्स

Lua5.2, 257 241 227 222 बाइट्स

चारकोल , 24 बाइट्स

पॉवरशेल , 139 137 135 बाइट्स

जाप, 28 बाइट्स

05AB1E , 38 बाइट्स

पर्ल 6 , 99 बाइट्स

C # (.NET कोर) , 221 , 194 बाइट्स

APL (Dyalog Extended) , 33 29 बाइट्स ^SBCS