स्क्वायर साइड पिनपॉइंटिंग

Question

मेरी पहली कोड-गोल्फ चुनौती में आपका स्वागत है! :) चलो सही में हॉप।

चुनौती:

दो फ़्लोटिंग पॉइंट वैक्टर, ओ (उत्पत्ति) और टी (लक्ष्य) को देखते हुए , आपको एल और आर को एसटीडीयूएस के मानों को प्रिंट करने के लिए एक प्रोग्राम बनाना होगा ।

1. O वर्ग का एक कोना है
2. T वर्ग का एक कोना है जो O के विपरीत स्थित है
3. एल 2 डी बिंदु (कोने) है जो अपूर्ण वर्ग के अन्य बिंदु को चिह्नित करता है
4. R , 2D बिंदु (कोना) है जो L के विपरीत है

नियम

5. O और T के मूल्यों को STDIN से पढ़ा जाना चाहिए (उदाहरण इनपुट देखें)।
6. फिर, L और R के मानों को STDOUT पर प्रिंट करना होगा।

स्कोरिंग और बोनस

7. अपने कार्यक्रम के बाइट्स की गणना करें।
8. यदि आपका प्रोग्राम ऐसी रेखाएँ खींचता है जो O से L से T से R के बीच जुड़ती हैं , तो बाइट काउंट से 15 बाइट घटाएँ।

उदाहरण

पहली पंक्ति में इनपुट शामिल हैं ( O के लिए पहला वर्ग ब्रैकेट और T के लिए अगला ब्रैकेट ) और अन्य पंक्ति अपेक्षित आउटपुट का प्रतिनिधित्व करती है।

• [०, ०] [३, ३] अपेक्षित: [०, ३] [३, ०]
• [0, 0] [-2, -2] अपेक्षित: [-2, 0] [0, -2]
• [1, -1] [4, 2] अपेक्षित: [1, 2] [4, -1]
• [0, -1] [0, 1] अपेक्षित: [-1, 0] [1, 0]

सूचना : इनपुट और आउटपुट फ्लोटिंग पॉइंट हो सकते हैं!

महत्वपूर्ण जानकारी!

• मान ओ और टी को किसी भी प्रारूप में लिया जा सकता है, जब तक वे एसटीडीआईएन से आते हैं (उदाहरण के अंदर [] या () ...), जो भी प्रारूप आप चाहते हैं उसका उपयोग करें।
• एल और आर किसी भी क्रम में मुद्रित किया जा सकता है।
• याद रखें: जब (O-> L-> T-> R-> O) जुड़े होते हैं, तो प्रत्येक पक्ष की लंबाई समान होनी चाहिए!

जीतना

• यह कोड-गोल्फ तो सबसे कम बाइट उत्तर जीत है!
• विजेता उत्तर रविवार 15.11.2015 20: 00-22: 00 (फिनलैंड समय) में स्वीकार किया जाएगा (यदि मैं गलत नहीं हूं, तो यह तारीख अमेरिका में 11.15.2015 की तरह लिखी गई है, भ्रमित मत हो)।

हैप्पी गोल्फिंग!

Comments

यदि आप इसके बारे में नहीं जानते हैं, तो मुझे भविष्य की चुनौतियों के लिए सैंडबॉक्स की सिफारिश करने दें , जहां आप प्रतिक्रिया प्राप्त कर सकते हैं और अपनी चुनौती को पॉलिश कर सकते हैं इससे पहले कि वह लाइव हो (और परिवर्तनों से पहले मौजूदा उत्तरों को अमान्य कर सकता है)।

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

क्या हम दो जटिल संख्याओं की सूची के रूप में इनपुट ले सकते हैं?

— lirtosiast

@ThomasKwa सुनिश्चित करें कि आप इसे एक सूची के रूप में ले सकते हैं। जब यह दिया जाता है तो क्या इनपुट एक जटिल संख्या नहीं है ...? मेरा मतलब है कि आपको व्यक्तिगत रूप से कंप्यूटर के लिए खुद की गणना करने की आवश्यकता नहीं है, ठीक है?

— यति

जब आप "स्क्वायर का बिंदु" कहते हैं, तो ऐसा लगता है कि आप एक कोने का मतलब है? एक वर्ग में बहुत सारे अन्य बिंदु हैं।

— रेटो कोरदी

@RetoKoradi तुम सही हो। मेरा मतलब उस कोने से है।

— यति

Answer 1

गंभीरता से , 11 बाइट्स

मेरे TI-BASIC उत्तर का एक बंदरगाह। गणना करता है mean(X)+i*(X-mean(X))।

,;Σ½;)±+ï*+

स्पष्टीकरण:

,           Read input
;           Duplicate
Σ½          Half the sum (the mean) of the top copy
;           Copy the mean
)           Rotate stack to the left
            Now there's a copy of the mean on the bottom
±+          Negate mean and add to input list
ï*          Multiply by i
+           Add to mean

दो जटिल संख्याओं की सूची के रूप में इनपुट: [1-1j,4+2j]और एक ही प्रारूप में आउटपुट [(4-1j), (1+2j)]:।

Comments

मुझे बहुत गर्व है ...

— मेगो

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

— lirtosiast

एक "गंभीरता से" अच्छी भाषा। @ThomasKwa

— Addison Crump

Σ2 बाइट्स नहीं है ?

— ऐश बर्लाज़ेंको

@AshBurlaczenko गंभीरता से CP437 एन्कोडिंग का उपयोग करने के लिए लगता है , जहां Σकोड बिंदु 0xF4 है।

— डेनिस

Answer 2

गंभीरता से , 25 बाइट्स

,i││-++½)+-+½)++-½)±+++½)

सूची के रूप में इनपुट लेता है: [x1,y1,x2,y2]

मेरे अजगर जवाब के रूप में एक ही रणनीति, लेकिन गंभीरता से!

स्पष्टीकरण:

,      get input
i      flatten list
││     duplicate stack twice, so that we have 4 copies of the input total
-++½)  calculate the first x-value using the formula (x1-y1+x2+y2)/2, and shove it to the end of the stack
+-+½)  calculate the first y-value using (x1+y1-x2+y2)/2, and shove it to the end of the stack
++-½)  calculate the second x-value using (x1+y2+x2-y2)/2, and shove it to the end of the stack
±+++½) calculate the second y-value using (-x1+y1+x2+y2)/2, and shove it to the end of the stack

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

Comments

यह गंभीर रूप से अच्छा है! (

— पुं

Answer 3

टीआई-बेसिक, 16 बाइट्स

एक TI-83 + या 84+ श्रृंखला कैलकुलेटर के लिए।

Input X
i∟X+.5sum(∟X-i∟X

जब तक मैं गलत नहीं समझा, ओपी ने कहा कि वे जटिल संख्याओं के रूप में इनपुट और आउटपुट लेने के साथ ठीक थे। iयहाँ काल्पनिक इकाई, नहीं आँकड़े चर रहा है।

TI-BASIC का एक mean(फंक्शन है, लेकिन नाराजगी से यह कॉम्प्लेक्स लिस्ट के साथ काम नहीं करता है ERR:DATA TYPE।

के रूप में इनपुट {1-i,4+2i}के लिए [[1,-1],[4,2]]। आउटपुट के रूप में {4-i 1+2i}है [[1,2][4,-1]]।

Comments

यह मुझे याद दिलाता है कि कैसे TI-BASIC स्ट्रिंग्स की सूचियों का समर्थन नहीं करता है। यह शायद एक चीज है जो मैं TI-BASIC में जोड़ूंगा: P

— कॉनर ओ'ब्रायन

Answer 4

मतलाब, 51 45 46 45 42 बाइट्स

अब एक कॉलम वेक्टर में इनपुट की उम्मीद की जाती है: [x0;y0;x1;y1](एक ही प्रारूप में ouput) मैंने इसे केवल एक पूर्ण कार्यक्रम होने के लिए संशोधित किया है।

z=eye(4);disp((.5-z([2:4,1],:))*input(''))

या वैकल्पिक रूप से

z=[1,1;-1,1];disp([z',z;z,z']*input('')/2)

पुराना समाधान:

इनपुट कॉलम वैक्टर की अपेक्षा करता है, जैसे f([0;0],[3;3])

@(a,b)[0,1;-1,0]*(b-a)*[.5,-.5]+(b+a)*[.5,.5]

यह दो कॉलम वैक्टर (2x2 मैट्रिक्स के रूप में) भी लौटाता है।

Answer 5

जप, 29 28 बाइट्स

Japt , Ja vaScri pt का छोटा संस्करण है । दुभाषिया

1o5 mZ=>$eval$(Uq'+)/2-UgZ%4

ध्यान दें कि एरो फ़ंक्शंस में ES6- अनुरूप ब्राउज़र की आवश्यकता होती है, जैसे फ़ायरफ़ॉक्स के नए संस्करण। इनपुट 4-आइटम सरणी के रूप में जाता है, उदाहरण के लिए [1,-1,4,2]।

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

         // Implicit: U = input array
1o5      // Create a range of integers from 1 to 5. Returns [1,2,3,4]
mZ=>     // Map each item Z in this range to:
$eval$(  //  evaluate:
 Uq'+    //   U joined with "+" (equivalent to summing U)
)/2      //  divided by 2,
-UgZ%4   //  minus the item at Z%4 in the input. This translates to [y₁,x₂,y₂,x₁],
         //  which in turn tranlsates to:
         //   [(x₁-y₁+x₂+y₂)/2, (x₁+y₁-x₂+y₂)/2, (x₁+y₁+x₂-y₂)/2, (-x₁+y₁+x₂+y₂)/2]
         //  which is [Lx,Ly,Rx,Ry], or [Rx,Ry,Lx,Ly], depending on the situation.
         // Implicit: Output last expression

यह कैसे गोल्फ था

मैंने पहली बार @ Mego के पाइथन दृष्टिकोण की नकल करने की कोशिश की। इसने मुझे इस 48-बाइट राक्षस के साथ छोड़ दिया:
(नोट: इनपुट को वर्तमान में किसी सरणी में नहीं लपेटना चाहिए।)

[U-V+W+X /2,(U+V-W+X /2,(U+V+W-X /2,(V+W+X-U /2]

चूंकि इनमें से प्रत्येक आइटम को 2 से विभाजित करने की आवश्यकता है, इसलिए यह पूरे सरणी को मैप करने के लिए छोटा है mY=>Y/2:

[U-V+W+X,U+V-W+X,U+V+W-X,V+W+X-U]mY=>Y/2

अब क्या? खैर, सरणी अब केवल तीन इनपुट जोड़ रही है और पैटर्न का अनुसरण करते हुए चौथे को घटा रही है 1,2,3,0। इसलिए, हम इनपुट को एक सरणी में पैक कर सकते हैं, फिर उन्हें एक साथ जोड़ सकते हैं, 2 से विभाजित कर सकते हैं, और आवश्यक वस्तु को घटा सकते हैं:

[1,2,3,0]mZ=>(Ug0 +Ug1 +Ug2 +Ug3)/2-UgZ

अच्छा, एक बाइट बचाई! लेकिन क्या शुरुआत में सरणी को सिकोड़ना संभव है? आइए इसे एक स्ट्रिंग में पैक करने का प्रयास करें, फिर इसे एक सरणी में वापस विभाजित करें a:

"1230"a mZ=>(Ug0 +Ug1 +Ug2 +Ug3)/2-UgZ

वह देखो, एक और बाइट बच गई। लेकिन क्या इससे भी बेहतर तरीका है? खैर, हम इस तथ्य का उपयोग कर सकते हैं कि [1,2,3,0] ≡ [1,2,3,4] mod 4:

1o5 mZ=>(Ug0 +Ug1 +Ug2 +Ug3)/2-UgZ%4

एक और दो बाइट्स! अब हम कहीं जा रहे हैं। लेकिन वह Ug0 +Ug1 +Ug2 +Ug3बहुत सारे स्थान पर घूम रहा है। यदि हम जोड़ को कम कर दें तो क्या होगा?

1o5 mZ=>Ur(X,Y =>X+Y /2-UgZ%4

वाह, यह वास्तव में मदद की! अब हम नीचे 29 बाइट पर हैं। और @ ɟ nɟuɐɯɹɐ to o I के लिए धन्यवाद, मैं भी कमी को दूर करने के लिए एक और बाइट करने में सक्षम था। लेकिन अगर हम सरणी का योग करने के लिए बिल्ट-इन का उपयोग कर सकते हैं, तो यह छोटा होगा:

1o5 mZ=>Uu /2-UgZ%4

19 बाइट्स! गजब का! दुर्भाग्य से, जाप में अभी तक कोई ऐसा बिल्ट-इन नहीं है। मौका मिलने पर मैं इसे जोड़ूंगा। सुझावों का स्वागत है, या तो कार्यक्रम या भाषा के लिए!

---

अच्छी तरह से, v1.4.4 के रूप में, मैंने जितने मूल रूप से योजना बनाई थी, उसके मुकाबले जाप में कुछ और विशेषताएं लागू की हैं। छोटे संस्करण के लिए मूल योजना के साथ शुरू:

1o5 mZ=>Uu /2-UgZ%4

पहले हमें कुछ चीजों को बदलने की जरूरत है: कार्यों के साथ परिभाषित किया गया है {, और योग फ़ंक्शन है x। यह संस्करण निम्नानुसार काम करता है:

1o5 mZ{Ux /2-UgZ%4

अब, के @लिए XYZ{स्विचन द्वारा हमें एक बाइट को बचाने के लिए अनुमति देता है, एक आशुलिपि Zहै X। इसके अलावा, £एक m@और बाइट को बचाने के लिए एक शॉर्टकट है :

1o5 £Ux /2-UgX%4

हाल ही में मैंने एक फीचर लागू किया, जहां Uकार्यक्रम की शुरुआत में आमतौर पर इसे छोड़ा जा सकता है। कार्यान्वयन की गलती के कारण, हालांकि, यह कार्यों के साथ भी काम करता है:

1o5 £x /2-UgX%4

अंत में, gफ़ंक्शन अब लपेटता है यदि सूचकांक स्ट्रिंग के अंत में है, तो हमें %4कुल 13 बाइट्स के लिए निकालने की अनुमति देता है :

1o5 £x /2-UgX

और मैंने सोचा कि 19 अद्भुत था ;-) यह ऑनलाइन परीक्षण!

Comments

आप संभवत: Japt समकक्ष का उपयोग करके कुछ बाइट्स बचा सकते हैं eval(U.join`+`)।

— मामा फन रोल

मुझे यह भाषा बहुत पसंद है: डी

— चरण

@, N evenuɐɯɹɐ ɯ oɯ धन्यवाद, भले ही मैंने evalअभी तक एक समकक्ष नहीं जोड़ा है, जो वास्तव में एक बाइट बचाता है!

— 14

Answer 6

जावास्क्रिप्ट (Node.js / ES6), 154 बाइट्स

process.stdin.on('data',s=>(s=s.toString().split(','),a=s[0]-0,b=s[1]-0,x=s[2]-0,y=s[3]-0,console.log([a+(c=(a+x)/2-a)+(d=(b+y)/2-b),b+d-c,a+c-d,b+d+c])))

स्टडी करना कोड का लंबा हिस्सा है। इनपुट को अल्पविराम से अलग किया जाना चाहिए:

echo "0,0,3,3" | node square.js

Comments

क्या यह पूरा कार्यक्रम है ...? कौन सा अंक STDOUT को आउटपुट करता है ...? ऐसा नहीं लगता।

— य्य्तशी ११'१५ को १y

आप सही हे। लानत है, यह बहुत सारे बाइट्स जोड़ देगा,

— नाओक

Voilà, नियत। अब से लगभग 3 गुना अधिक समय :(

— नाऊक

हम्म: / मुझे अभी भी लगता है कि बिंदु सुंदर कोड कला बनाने के लिए है जो अच्छी तरह से कार्य करता है। और आपके द्वारा प्रदान किया गया कोड बहुत ही जटिल और सुंदर कला है। :) भाग लेने के लिए धन्यवाद!

— यति

Answer 7

ngn APL, 21 बाइट्स

⎕←F.5 0J.5×(F←+/,-/)⎕

यह इनपुट को जटिल संख्याओं (जैसे 1J¯1 4J2) की एक जोड़ी के रूप में लेता है और आउटपुट को उसी तरह प्रिंट करता है (जैसे, 4J¯1 1J2)। इसे ngn / apl डेमो में ऑनलाइन आज़माएँ ।

Comments

सभी सकारात्मक इनपुट के लिए काम करता है, हालांकि, जब मैं नकारात्मक संख्या दर्ज करता हूं तो यह कुछ भी आउटपुट नहीं करता है। क्या मैं उन्हें एक गलत प्रारूप में दर्ज कर रहा हूं? 1J1 3J3 काम करता है। 0J-1 0J1 नहीं करता है। मैंने नंबर नकारात्मकता की घोषणा करने के लिए ऊपरी माइनस प्रतीक का उपयोग करने की भी कोशिश की।

— यति

@TuukkaX जाने के रास्ते में उच्च माइनस। मुझे 1 ¯1इनपुट के लिए आउटपुट मिलता है 0J¯1 0J1, जो सही उत्तर है। आपको क्या मिल रहा है?

— डेनिस

ओह, अब मुझे यह काम कर गया। मुझे सिर्फ उच्च माइनस साइन से पहले छोटे व्हाट्सएप को हटाना था। यह काम करता है और योग्य है।

— यति

Answer 8

पायथ, 12 बाइट्स

.jL.OQ-R.OQQ

यह इनपुट को जटिल संख्याओं (जैसे 1-1j, 4+2j) की एक जोड़ी के रूप में लेता है और आउटपुट को एक सरणी (जैसे [(4-1j), (1+2j)]) के रूप में प्रिंट करता है । इसे ऑनलाइन आज़माएं।

Answer 9

S, 29 चार्ट / 43 बाइट्स

ô(ѨŃ(1,5)ć⇀ë(ïø`+`⸩/2-ï[$%4]⸩

Try it here (Firefox only).

Answer 10

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

q~_:.+\:.-(W*+_2$.+@@.-].5ff*`

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

यह सूची की सूची के रूप में इनपुट लेता है, उदाहरण के लिए अंतिम उदाहरण के लिए:

[[0 -1] [0 1]]

स्पष्टीकरण:

q~      Get and interpret input.
_       Make a copy.
:.+     Reduce the list of two points with vector sum operator.
\       Swap copy of input to top.
:.-     Reduce the list of two points with vector difference operator.
(W*+    Turn (x, y) into orthogonal (y, -x) by popping off first element, inverting
        its sign, and concatenating again. We now have center and offset vector.
_2$     Create a copy of both...
.+      ... and add them.
@@      Rotate original values to top...
.-      ... and subtract them.
]       Wrap the two results...
.5ff*   ... and multiply all values by 0.5.
`       Convert list to string.

Answer 11

प्रोलॉग, 118 बाइट्स

p([A,B],[C,D]):-read([E,F,G,H]),I is(E+G)/2,J is(F+H)/2,K is(G-E)/2,L is(H-F)/2,A is I-L,B is J+K, C is I+L, D is J-K.

थोड़ा अधिक पठनीय:

p([A,B],[C,D]):-read([E,F,G,H]),
                        I is(E+G)/2,
                        J is(F+H)/2,
                        K is(G-E)/2,
                        L is(H-F)/2,
                        A is I-L,
                        B is J+K, 
                        C is I+L, 
                        D is J-K.

कार्यक्रम शुरू करने के लिए:

p(X,Y).

उदाहरण इनपुट जब ज्ञात कोने हैं [1, -1] [4, 2]:
[1, -1,4,2]

उदाहरण आउटपुट, जहां X और Y में अज्ञात कोने होंगे:
X = [1.0, 2.0],
Y = [4.0, -1.0]

इसे यहाँ ऑनलाइन आज़माएँ

संपादित करें: STDIN से इनपुट पढ़ने के लिए परिवर्तित

Comments

क्या यह STDIN से पढ़ा जाता है और STDOUT में प्रिंट होता है ...?

— यति

@TuukkaX: शायद नहीं। यह एक क्वेरी के रूप में इनपुट लेता है। मैंने उस भाग को पढ़ा, जिसमें कहा गया था कि इनपुट जो भी प्रारूप हम चाहते हैं, हो सकता है। मुझे STDIN के बारे में याद आया। यह भी सुनिश्चित नहीं है कि प्रोलॉग में एसटीडीआईएन क्या है। क्या उपयोगकर्ता से इनपुट पढ़ना ठीक होगा?

— एमिगा

एसटीडीआईएन मानक इनपुट के लिए है। इसलिए उपयोगकर्ता से पढ़ना :) जाने का तरीका है और प्रारूप से मेरा मतलब है कि उपयोगकर्ता जिस तरह से मूल्यों का आदान-प्रदान करता है। Ex [x, y] [x, y] या {x, y} ...

— Yytsi

Answer 12

पायथन 3, 102 बाइट्स

g=lambda a,b,c,d:((a-b+c+d)/2,(a+b-c+d)/2,(a+b+c-d)/2,(d+b-a+c)/2)
print(g(*map(float,input().split())))

इनपुट x1 y1 x2 y2एक लाइन पर, फॉर्म में लिया जाता है ।

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

Comments

आप कुछ गलत करते हैं, आपकी बाइट की गिनती प्रत्येक संपादन के साथ होती है, लेकिन मैं प्रत्येक संपादन के साथ बायटेकाउंट को नीचे लाने की कोशिश करता हूं = P

— त्रुटी

@flawr मैं

— Mego

मेरा मानना ​​है कि सभी उत्तरों को पूर्ण कार्यक्रम होने की जरूरत है, एसटीडीआईएन (या निकटतम विकल्प) से इनपुट लेना। क्या यह योग्यता है?

— ETHproductions

Answer 13

पायथन 2, 56 बाइट्स

i=input()
s=sum(i)/2.0
print s-i[1],s-i[2],s-i[3],s-i[0]

इनपुट हो सकता है x1,y1,x2,y2या(x1,y1,x2,y2)