मैं वास्तव में एक मकबरा चाहता था, लेकिन मुझे जो भी मिला वह यह बेवकूफी भरा आयत था

Question

केवल एक सीधे और कम्पास को देखते हुए, दो विपरीत बिंदुओं को साझा करते हुए, दिए गए आयत के अंदर एक रोम्बस लिखें।

इनपुट

इनपुट आयत का आयाम है। दिखाए गए उदाहरण में, यह होगा 125, 50। आप सबसे सुविधाजनक (जो दो पूर्णांक, सूची, तार, आदि) के रूप में इनपुट ले सकते हैं।

बड़ा आयाम 100 न्यूनतम होगा, जबकि छोटा 25 न्यूनतम होगा। 200 पर दोनों टोपी।

उत्पादन

आउटपुट एक छवि होगी (स्क्रीन पर प्रदर्शित या फ़ाइल के रूप में सहेजी गई) दिखा रही है

• इनपुट आयत
• सभी "कामकाजी" लाइनें / मंडलियां
• खुदा हुआ मकबरा

अलग-अलग रंगों में। ऊपर की छवि में, आयत काली है, काम करने वाली रेखाएं नीली, और रोम्बस नारंगी हैं। सूची में दिखाए गए क्रम में रेखाएं खींची जानी चाहिए (जैसे कि रोम्बस कार्यशील लाइनों और आयत को ओवरराइट करता है)।

आउटपुट छवि को सब कुछ शामिल करने के लिए पर्याप्त बड़ा होना चाहिए। उदाहरण के लिए, दिखाए गए मंडलियां सीमा से बाहर नहीं जा सकतीं।

तरीका

ऊपर चित्र छवि में उपयोग की गई विधि है:

• केंद्र के रूप में निचले बाएं कोने का उपयोग करके एक सर्कल बनाएं, और परिधि पर एक बिंदु के रूप में ऊपरी दाएं, आयत के विकर्ण के बराबर त्रिज्या दें।
• केंद्र और परिधि बिंदुओं की अदला-बदली समान करें।
• आयत के विकर्ण को लंबवत द्विभाजक देते हुए, दो हलकों के चौराहों के बीच एक रेखा खींचें।
• रोम्बस बनाने के लिए नई लाइन और आयत के चौराहों का उपयोग करें।

यह इसलिए काम करता है क्योंकि एक समचतुर्भुज के आंतरिक विकर्ण हमेशा एक दूसरे से टकराते हैं। मैं इस का एक पूर्ण प्रमाण सहित यहाँ नहीं हूँ, यद्यपि।

यह आपके रोम्बस को प्राप्त करने का एकमात्र तरीका नहीं है , और आप दूसरे का उपयोग कर सकते हैं, यह देखते हुए कि आप समझा रहे हैं कि आप क्या कर रहे हैं। मेरा मानना है कि यह शायद सबसे आसान है, हालांकि।

नियम

आप केवल मंडलियां और रेखाएँ (या बल्कि, रेखाखंड) खींच सकते हैं। एक सर्कल को केंद्र बिंदु और परिधि बिंदु के साथ परिभाषित किया गया है। एक रेखा को किन्हीं दो बिंदुओं द्वारा परिभाषित किया जाता है। लाइनों को कोई निर्दिष्ट लंबाई नहीं होना चाहिए, लेकिन उन्हें कम से कम परिभाषित बिंदुओं को कवर करना होगा (उदाहरण छवि पर ध्यान दें: लाइन सर्कल के चौराहों से थोड़ा पीछे जाती है, लेकिन किनारे पर नहीं)। हलकों के लिए, केंद्र से चयनित परिधि बिंदु तक त्रिज्या को एक कामकाजी रेखा माना जाता है, और दिखाया जाना चाहिए।

लाइनों को व्यवस्थित करने के लिए, आप किसी भी मान्यता प्राप्त एल्गोरिथ्म (जैसे ब्रेसेनहैम) का उपयोग कर सकते हैं, या जो कुछ भी आपकी भाषा हो सकती है, उस पर भरोसा करते हैं। यदि आपका आउटपुट वेक्टर-आधारित है, तो कृपया सुनिश्चित करें कि यह एक रिज़ॉल्यूशन में कम से कम उतना बड़ा है जितना कि पिक्सेल में इनपुट आयत। इसके अलावा, आप एक सादे कैनवास पर ड्राइंग करेंगे, इसलिए कृपया किसी भी ग्रिड के निशान या बाहरी आउटपुट को दबाएं।

बेईमानी नहीं! अब तक आपने जो भी स्थापित किया है, उसका उपयोग करके आप केवल अंकों / रेखाओं / मंडलियों का स्थान निर्धारित कर सकते हैं। यदि आप यह स्पष्ट नहीं कर सकते हैं कि अपनी कार्य रेखाओं / मंडलियों का उपयोग यह दिखाने के लिए कैसे किया जाता है, तो आप इसे गलत कर रहे हैं।

आप जो चाहें विपरीत बिंदुओं की जोड़ी का उपयोग कर सकते हैं, और आयत को अक्ष-संरेखित करने की आवश्यकता नहीं है , इसलिए जब तक आउटपुट सही नहीं हो जाता।

इनपुट हमेशा एक गैर-वर्ग आयत होगा, इसलिए विशेष-आवरण के बारे में चिंता न करें।

अंत में, यह मानक कोड गोल्फ है, इसलिए बाइट्स में सबसे कम आकार जीतता है।

Comments

क्या हम यह तय करने के लिए एक गणितीय सूत्र का उपयोग कर सकते हैं, उदाहरण के लिए, एक बार वे खींचे जाने के बाद मंडलियों के चौराहों के बीच खींची गई रेखा का समापन बिंदु (वास्तव में छवि को पार्स करने के लिए जहां पार्स हैं) को देखने के बिना?

— ETHproductions

@ETHproductions मैं हां कहूंगा, क्योंकि यह दिखाना काफी आसान है कि उनके और त्रिज्या के बीच का कोण प्रत्येक तरफ 60 डिग्री है, और यह कि वे समबाहु त्रिकोण बनाते हैं। अगर किसी को कोई आपत्ति है, तो मैं वह भी सुनने को तैयार हूं।

— Geobits

क्या हम मान सकते हैं कि पहला इनपुट दूसरे (या इसके विपरीत) से अधिक होगा, या क्या उत्तर को लंबवत और क्षैतिज रूप से उन्मुख दोनों आयतों को संभालने में सक्षम होना चाहिए?

— मार्टिन एंडर

आयत के अंदर शॉर्ट लाइन सेगमेंट का उद्देश्य क्या है?

— 12M2121

Answer 1

HTML + जावास्क्रिप्ट (ES6), 34 + 353 = 387 बाइट्स

प्रारूप में इनपुट दिया जाना चाहिए [125,50]।

[w,h]=eval(prompt(c=C.getContext("2d"))).sort();d=q=>(c.strokeStyle=q,b);l=(x,y=Z)=>x?c.lineTo(x,y)||l:c.stroke();b=(x,y=H,r)=>(c.beginPath(),r?c.arc(x,y,Math.sqrt(r),0,2*Math.PI):c.moveTo(x,y),l);b(Z=300,Z)(W=Z+w)(W,H=Z+h)(Z,H)(Z)();d`red`(Z,H,s=w*w+h*h)();b(W,Z,s)();b(Z)(W)();b(Z+w/2-h,Z+h/2-w)(H+w/2,W+h/2)();d`lime`(Z)(W-s/2/w)(W)(Z+s/2/w,H)(Z,H)()

<canvas id=C width=800 height=800>

बस बहुत सारे गणित और ड्राइंग ... आयत बग़ल में खींची गई है यदि ऊंचाई चौड़ाई से अधिक है, जो मुझे लगता है कि अनुमति है।

Comments

ऊह, 10 बाइट्स इससे कम 444: पी

— क्रिति लिथोस

@ क्रिटिसिलेटोस अब मैं 10 बाइट्स से कम; 400;-)

— ETHproductions

The rectangle becomes inscribed in the rhombus when the height is larger than the width.

— Larkeith

@Larkeith Oops, didn't know we had to cover those cases. Fixed at the cost of 42 bytes.

— ETHproductions

आप कुछ बाइट्स को सहेजने के लिए "getContext` 2d` "(रिक्त स्थान के बिना) का उपयोग कर सकते हैं (

— उन्हें`

Answer 2

गणितज्ञ, 157 148 158 बाइट्स

मार्टिन एंडर को उनकी सामान्य उच्च गुणवत्ता वाली टिप्पणियों के लिए धन्यवाद! इस मामले में 9 बाइट बच गईं।

एक बार संपादित करने के बाद यह स्पष्ट किया गया कि तर्क या तो क्रम में आ सकते हैं; क्षतिपूर्ति के लिए 10 बाइट्स जोड़े गए।

Graphics@{(m=Line)@{o=0{,},{#,0},c={##},{0,#2},o},Blue,m[l={o,c}],Circle[#,(c.c)^.5]&/@l,m[{k={#2,-#},-k}+{c,c}/2],Red,m@{o,p={0,c.c/2/#2},c,c-p,o}}&@@Sort@#&

फिर, यह वह जगह है जहां गणितज्ञ चमकता है: गणितीय संगणना से युक्त उच्च-स्तरीय ग्राफिक्स आउटपुट। मानव पठनीयता के लिए रिक्त स्थान और newlines के साथ एक ही कोड:

Graphics@{
  (m=Line)@{o = 0{,}, {#, 0}, c = {##}, {0, #2}, o},
  Blue, m[l = {o, c}], Circle[#, (c.c)^.5] & /@ l, 
  m[{k = {#2, -#}, -k} + {c, c}/2],
  Red, m@{o, p = {c.c/2/#2, 0}, c, c - p, o}
} & @@ Sort@# &

Unnamed function of a single argument which is an ordered pair of positive numbers; the final @@ Sort@# & converts that pair into two numerical arguments where the first number is the smaller. Line produces a polygonal path from point to point, which will turn into a closed polygon if the first and last points are the same; Circle produces a circle with given center and radius. Special points o and c (the lower-left and upper-right rectangle corners), p (a third rhombus corner, given by a mathematical formula), and k (helping to draw the perpendicular bisector) are given names along the way to save bytes when called again, as is the special pair of points l = {o,c}. Mathematica is happy to add points directly, multiply both coordinates by the same factor, take their dot product, etc., all of which simplify the code.

Sample output, with arguments 125 and 50:

Comments

Re unnecessary whitespace. You can use this trick to save a byte on {0,0}. Since there's no requirement to use blue and orange, you can save bytes by using Red instead of Orange. You're using Line four times which is more than enough to save bytes from i=Line; (as a rule of thumb, if the expression has n characters and you use it m times you need (m-1)*(n-1) > 4, less if you can assign the variable during first use without parentheses).

— Martin Ender

That 0{,} trick is fantastic :D

— Greg Martin

I'm afraid this doesn't work if the second side is longer than the first. However, the orientation doesn't need to be consistent, so this can be fixed by appending @@Sort@#& and swapping # and #2 throughout the code or alternatively adapting it to work with portrait-orientation rectangles instead.

— Martin Ender

Yes, that was intentional ... looks like we're awaiting clarification on whether we can assume the dimensions come in the order we want.

— Greg Martin

chat.stackexchange.com/transcript/message/33716642#33716642

— Martin Ender

Answer 3

MetaPost, 473 (with color) 353 (without color)

Colored (473 bytes):

A:=170;B:=100;pair X,Y;path C,D,E,F,G,R,T;X=(0,0);Y=(A,B);R=X--(A,0)--Y--(0,B)--cycle;T=(0,B)--(A,B);draw R;E=X--Y;C=X..Y*2..cycle;D=Y..-Y..cycle;F=(D intersectionpoint C)--(C intersectionpoint D);draw C withcolor green;draw D withcolor green;draw E withcolor red;draw F withcolor red;draw (F intersectionpoint R)--Y withcolor blue;draw X--(F intersectionpoint T) withcolor blue;draw (F intersectionpoint T)--Y withcolor blue;draw (F intersectionpoint R)--X withcolor blue;

Noncolored (353 bytes):

A:=170;B:=100;pair X,Y;path C,D,E,F,G,R,T;X=(0,0);Y=(A,B);R=X--(A,0)--Y--(0,B)--cycle;T=(0,B)--(A,B);draw R;E=X--Y;C=X..Y*2..cycle;D=Y..-Y..cycle;F=(D intersectionpoint C)--(C intersectionpoint D);draw C;draw D;draw E;draw F;draw (F intersectionpoint R)--Y;draw X--(F intersectionpoint T);draw (F intersectionpoint T)--Y;draw (F intersectionpoint R)--X;

Never EVER used this before, and I'm sure I butchered it...
But when you run that on this website:

http://www.tlhiv.org/mppreview/

It uses the intersection of the circles to draw the second axis, and then uses the intersection of the axis and the rectangle to draw the final rhombus. Though I could've cheated and just drawn a line perpendicular to the first axis haha.

To change the dimensions, just alter A and B.

Regardless, you end up with (for L=170, H=100):

Answer 4

Desmos, 375 (or 163) bytes

w=125
h=50
\left(wt,\left[0,h\right]\right)
\left(\left[0,w\right],ht\right)
\left(x-\left[0,w\right]\right)^2+\left(y-\left[0,h\right]\right)^2=w^2+h^2
\frac{h}{w}x\left\{0\le x\le w\right\}
-\frac{w}{h}\left(x-\frac{w}{2}\right)+\frac{h}{2}
a=\frac{h^2}{2w}+\frac{w}{2}
\left(t\left(w-a\right)+\left[0,1\right]a,ht\right)
\left(at-\left[0,a-w\right],\left[0,h\right]\right)

w and h are the inputs. Try it on Desmos!

Alternate 163-byte version:

w=125
h=50
(wt,[0,h])
([0,w],ht)
(x-[0,w])^2+(y-[0,h])^2=w^2+h^2
hx/w\left\{0\le x\le w\right\}
-w(x-w/2)/h+h/2
a=h^2/2/w+w/2
(t(w-a)+[0,1]a,ht)
(at-[0,a-w],[0,h])

This version requires each line to be copy and pasted into each separate line into Desmos. Meta still needs to decide if this is a valid counting method, but the former method is definitely fine.

Comments

This seems to assume that the input rectangle is in landscape orientation, which is not specified in the task.

— Henning Makholm

To me, "the rectangle does not need to be drawn axis-aligned" implies that there's no predetermined orientation on the rectangle, including landscape vs. portrait, that needs to be preserved.

— Greg Martin

Since only size is given (not coordinates), the output may be aligned however you like, assuming size is correct.

— Geobits

First time I'm seeing Desmos being used as a golfing language :)

— Kritixi Lithos

Answer 5

ImageMagick Version 7.0.3 + bash + sed, 496 bytes

M=magick
L=$((400-$(($1))/2)),$((400+$(($2))/2))
R=$((400+$(($1))/2)),$((400-$(($2))/2))
Z=" $L $R" Y=" -1 x";D=' -draw' K=' -stroke'
A=' -strokewidth 3 +antialias -fill'
$M xc:[800x]$A none$K \#000$D "rectangle$Z"$D "line$Z"$K \#00F8$D "circle$Z"$K \#0F08$D "circle $R $L" -depth 8 png:a
$M a txt:-|sed "/38C/!d;s/:.*//">x;P=`head$Y`;Q=`tail$Y`
$M a$A \#F008$K \#F008$D "line $P $Q" b
$M b txt:-|sed "/C70/!d;s/:.*//">x;S=`head$Y`;T=`tail$Y`
$M b$A \#F804$K \#F80$D "polyline $L $S $R $T $L" x:

Result with "rhombus.sh 180 120"

More precise (using 6400x6400 canvas instead of 800x800), 570 bytes

The intersections aren't exact; the "strokewidth" directive makes the lines wide enough to make sure at least one entire pixel gets mixed with just the colors of the two intersecting lines, but in the worst cases (25x200 and 200x25) the crossings are at a small angle so the cloud of mixed pixels is several pixels long, and since we select the first and last mixed pixel, there is a slight error. Using an 8x larger canvas with the same strokewidth and then scaling the result down reduces the error to less than one pixel, but at about a 64x time penalty.

M=magick
L=$((3200-$(($1))*4)),$((3200+$(($2))*4))
R=$((3200+$(($1))*4)),$((3200-$(($2))*4))
K=-stroke;A='-strokewidth 3 +antialias'
$M xc:[6400x] $A -fill none $K \#000 -draw "rectangle $L $R" \
-draw "line $L $R" $K \#00F8 -draw "circle $L $R" \
$K \#0F08 -draw "circle $R $L" -depth 8 png:a 
$M a txt:-|grep 38C077|sed -e "s/:.*//p">x
P=`head -1 x`;Q=`tail -1 x`
$M a $A -fill \#F008 $K \#F008 -draw "line $P $Q" png:b
$M b txt:-|grep C70000|sed -e "s/:.*//p">x
S=`head -1 x`;T=`tail -1 x`
$M b $A -fill \#F804 $K \#F80 -draw "polyline $L $S $R $T $L" -resize 800 x:

Results of normal 800x800 versus precise 6400x6400:

Ungolfed:

# rhombus.sh
# Inscribe a rhombus in the rectangle with dimensions 2*$1, 2*$2

# Run with "rhombus.sh W H"

M=magick

W=${1:-100};H=${2:-40}

# L locates the lower left corner of the rectangle
L=$((400-$((W))/2)),$((400+$((H))/2))

# R locates the upper right corner of the rectangle
R=$((400+$((W))/2)),$((400-$((H))/2))

# We'll need this several times
A='-strokewidth 3 +antialias'

# Establish 800x800 canvas (white) (circles + rectangle will
# always fit in 764x764)
#
# Draw the W x H rectangle (black) in center of canvas
#
# Draw two circles (blue, 50% alpha [#00F8] and green, 50% alpha [#0F08])
#  one centered at point L with peripheral point R
#  the other centered at point R with peripheral point L

$M xc:[800x] $A -fill none \
       -stroke \#000  -draw "rectangle $L $R" \
                      -draw "line      $L $R" \
       -stroke \#00F8 -draw "circle    $L $R" \
       -stroke \#0F08 -draw "circle    $R $L" \
       -depth 8 a.png 

# Find P and Q, the 2 intersections of the circles,
# that have mixed color #38C077 
$M a.png txt:-|grep 38C077|sed -e "s/:.*//p">x
P=`head -1 x`;Q=`tail -1 x`

# Draw line connecting the intersections P and Q
$M a.png $A -fill \#F008 -stroke \#F008 -draw "line $P $Q" b.png

# Find S and T, the 2 intersections of the line with the original rectangle,
# that have mixed color #C70000
$M b.png txt:-|grep C70000|sed -e "s/:.*//p">x
S=`head -1 x`;T=`tail -1 x`

# Draw the rhombus
$M b.png $A -fill \#F804 -stroke \#F80 -draw "polyline $L $S $R $T $L" d.png

Comments

I like the way you detect the intersections, very nice. Is the last mixed color correct? I ask because it looks like the rhombus and rectangle lines are slightly off. I thought maybe the color was being detected in a slightly off spot due to anti-aliasing (possibly stroke width also).

— Geobits

Answer 6

R, 290 bytes

function(A,B,p=polygon){R=A^2+B^2
D=2*A
a=sqrt(R)*cbind(cos(t<-seq(0,2*pi,.01)),sin(t))
b=t(t(a)+c(A,B))
x=range(a,b)
plot(NA,xli=x,yli=x,as=1,ax=F,an=F)
rect(0,0,A,B)
segments(0,0,A,B,c=4)
p(a,b=4)
p(b,b=4)
curve(B/2-A*x/B+A^2/2/B,co=4,a=T)
p(cbind(c((R-2*B^2)/D,A,R/D,0),c(B,B,0,0)),b=3)}

Anonymous function, output is displayed on screen. Slightly ungolfed, with comments:

function(A,B){
    R=A^2+B^2
    D=2*A
    t=seq(0,2*pi,.01)
    a=sqrt(R)*cbind(cos(t),sin(t)) #Circle with (0,0) as center
    b=t(t(a)+c(A,B)) #Second circle transposed to (A,B) center
    x=range(a,b)
    #Empty plot, large enough to fit the 2 circles:
    plot(NA,xlim=x,ylim=x,asp=1,axes=F,ann=F)
    rect(0,0,A,B) #Initial rectangle
    segments(0,0,A,B,col=4) #Rectangle diagonal
    polygon(a,border=4) #Circle 1 (border is b thanks to partial matching)
    polygon(b,border=4) #Circle 2
    curve(B/2-A*x/B+A^2/2/B,col=4,add=T) #Line joining circles intersection
    polygon(cbind(c((R-2*B^2)/D,A,R/D,0),c(B,B,0,0)),border=3) #Rhombus
}

Example output for (120,100):

Answer 7

LibreLogo, 270 bytes

User input is taken as an array: [width, height] or [height, width].

Code:

fc [24]
D=180
R=sorted(eval(input "))
W=R[1]
H=R[0]
L=sqrt W**2+H**2
A=D/π*asin(H/L)
Z=A*2
S=L/2/cos A*π/D rectangle[W,H]pc 255 lt A fd 400 bk 800 fd 400 rt A pu bk H/2 lt 90 fd W/2 pd circle L*2 rt D-A fd L circle L*2 pc [5]lt D-A fd S lt Z fd S rt D+Z fd S lt Z fd S

Result:

Explanation:

fc [24]                        ; Fill Color = Invisible
D = 180                        ; D = 180° (Saved Bytes)
R = sorted( eval( input " ) )  ; R = Sorted Array of Rectangle Width and Height (User Input)
W = R[1]                       ; W = Rectangle Width
H = R[0]                       ; H = Rectangle Height
L = sqrt W**2 + H**2           ; L = Rectangle Diagonal Length
A = D / π * asin( H / L )      ; A = Rectangle Diagonal Angle°
Z = A * 2                      ; Z = Rectangle Diagonal Angle° * 2 (Saved Bytes)
S = L / 2 / cos A * π / D      ; S = Rhombus Side Length
rectangle [W, H]               ; Draw Rectangle
pc 255                         ; Pen Color = Blue
lt A                           ; Left = Rectangle Diagonal Angle°
fd 400                         ; Forward = 400 pt
bk 800                         ; Back = 800 pt
fd 400                         ; Forward = 400 pt
rt A                           ; Right = Rectangle Diagonal Angle°
pu                             ; Pen Up
bk H / 2                       ; Back = Rectangle Height / 2
lt 90                          ; Left = 90°
fd W / 2                       ; Forward = Rectangle Width / 2
pd                             ; Pen Down
circle L * 2                   ; Draw Left Circle (Radius = Rectangle Diagonal Length)
rt D - A                       ; Right = 180° - Rectangle Diagonal Angle°
fd L                           ; Forward = Rectangle Diagonal Length
circle L * 2                   ; Draw Right Circle (Radius = Rectangle Diagonal Length)
pc [5]                         ; Pen Color = Red
lt D - A                       ; Left = 180° - Rectangle Diagonal Angle°
fd S                           ; Forward = Rhombus Side Length
lt Z                           ; Left = Rectangle Diagonal Angle° * 2
fd S                           ; Forward = Rhombus Side Length
rt D + Z                       ; Right = 180° + Rectangle Diagonal Angle° * 2
fd S                           ; Forward = Rhombus Side Length
lt Z                           ; Left = Rectangle Diagonal Angle° * 2
fd S                           ; Forward = Rhombus Side Length

Answer 8

Python 3.5 + Tkinter, 433 or 515 bytes

Non-Colored (433 bytes):

from tkinter import*
def V(a,b):S=500;Y,Z=S+a,S-b;M=(a**2+b**2)**0.5;D=Tk();C=Canvas(D);B=C.create_oval;X=C.create_line;B(S+M,S-M,S-M,S+M);B(Y-M,Z+M,Y+M,Z-M);X(Y,Z,S,S);C.create_rectangle(Y,S,S,Z);Q=-((Z-S)/(Y-S))**-1;U,V=(Y+S)/2,(Z+S)/2;X(U+M,V+M*Q,U-M,V-M*Q);P=[(Y,Q*(Y-U)+V),(((Z-V)/Q)+U,Z)][a>b];L=[(S,Q*(S-U)+V),(((S-V)/Q)+U,S)][a>b];X(S,S,P[0],P[1]);X(Y,Z,P[0],P[1]);X(Y,Z,L[0],L[1]);X(S,S,L[0],L[1]);C.pack(fill=BOTH,expand=1)

Colored (515 bytes):

from tkinter import*
def V(a,b):S=500;t='blue';Y,Z=S+a,S-b;M=(a**2+b**2)**0.5;D=Tk();C=Canvas(D);B=C.create_oval;X=C.create_line;B(S+M,S-M,S-M,S+M,outline=t);B(Y-M,Z+M,Y+M,Z-M,outline=t);X(Y,Z,S,S,fill=t);C.create_rectangle(Y,S,S,Z);Q=-((Z-S)/(Y-S))**-1;U,V=(Y+S)/2,(Z+S)/2;X(U+M,V+M*Q,U-M,V-M*Q,fill=t);P=[(Y,Q*(Y-U)+V),(((Z-V)/Q)+U,Z)][a>b];L=[(S,Q*(S-U)+V),(((S-V)/Q)+U,S)][a>b];o='orange';X(S,S,P[0],P[1],fill=o);X(Y,Z,P[0],P[1],fill=o);X(Y,Z,L[0],L[1],fill=o);X(S,S,L[0],L[1],fill=o);C.pack(fill=BOTH,expand=1)

A named function that takes input as 2 comma-separated numbers. The output is given in a separate window that you may have to resize to see the full output. Here is a sample colored output for V(180,130):

Answer 9

SmileBASIC, 280 bytes

INPUT W,H
W=MAX(W,H)/4H=MIN(W,H)/4D=SQR(W*W+H*H)N=D+W
M+D+H
GBOX D,D,N,M,#RED
GCIRCLE D,M,D
GCIRCLE N,D,D
GLINE D,M,N,D
X=D+W/2Y=D+H/2A=ATAN(W,H)E=D*H/W/2S=E*COS(A)T=E*SIN(A)GLINE X-S*9,Y-T*9,X+S*9,Y+T*9GCOLOR-#L
GLINE D,M,X-S,Y-T
GLINE D,M,X+S,M
GLINE N,D,X+S,Y+T
GLINE N,D,X-S,D

(Screenshot/explanation will be posted soon) Background color is black, rectangle is red, circles and lines are white, and the rhombus is yellow.