कोणों का लाभ

15

कहानी, या हम ऐसा क्यों कर रहे हैं।

कोई नहीं। यह अभ्यास पूरी तरह से व्यर्थ है ... जब तक आप स्टीफन हॉकिंग नहीं हैं ।

चुनौती

कोणों की सूची को देखते हुए, उन कोणों का औसत ज्ञात करें। उदाहरण के लिए 91 डिग्री और -91 डिग्री का औसत 180 डिग्री है। आप ऐसा करने के लिए किसी प्रोग्राम या फ़ंक्शन का उपयोग कर सकते हैं।

इनपुट

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

उत्पादन

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

यहां छवि विवरण दर्ज करें

कम से कम किया जाता है। आउटपुट (-180, 180) की सीमा के भीतर होना चाहिए और दशमलव बिंदु के पीछे कम से कम दो स्थानों पर सटीक होना चाहिए।

उदाहरण:

> 1 3
2
> 90 -90
0 or 180
> 0 -120 120
0 or -120 or 120
> 0 810
45
> 1 3 3
2.33
> 180 60 -60
180 or 60 or -60
> 0 15 45 460
40
> 91 -91
180
> -89 89
0

कोडगोल्फ के साथ हमेशा की तरह , कम से कम बाइट्स के साथ सबमिशन जीत जाता है।

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

कोड स्निपेट दिखाएं

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई दे रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप अलग से झंडा लगाने वाले दंड को सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक स्कोर अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

यहाँ समस्या के बारे में किसी भी सवाल के लिए एक chatroom है: http://chat.stackexchange.com/rooms/30175/room-for-average-of-angles

code-golf  number  arithmetic 
— नंबर एक
स्रोत
क्या ९ ०,-९ ०, १ ?० नहीं देता है तो ९ ०, ९९ -१90० देना चाहिए?
— ब्लू
2
सहज रूप से -91 और 91 का औसत 0 है, 180 नहीं। आपकी परिभाषा का उपयोग करना हमारे पास है: (180-91) ^ 2 + (180-91) ^ 2 => 81362, जबकि (0-91) ^ 2 + ( 0- -91) ^ 2 => 16562. तो 180 निश्चित रूप से औसत नहीं हो सकता है। मुझे यहां क्या समझ नहीं आ रहा है?
— edc65
91% 360 = 91; -91% 360 = 269; (269 + 91) / 2 = 180। कभी बुरा मत मानना, गलत। शायद? मुझे अब यकीन नहीं हो रहा है।
— ब्लू
ठीक है धन्यवाद। फिर भी इस बारे में कोई विचार नहीं है कि इसे कैसे खोजें
— edc65
3
आपके अब तक के किसी भी परीक्षण के मामले में सभी कोणों को 360 ° तक ले जाने के गलत एल्गोरिदम को तोड़ना, उनका औसत लेना और फिर परिणाम के 180 ° से अधिक होने पर 360 ° घटाना है। आपको [89 °, ]89 °] जैसा एक मामला जोड़ना चाहिए, जिसे 0 ° वापस करना चाहिए।
— एंडर्स केसरग

जवाबों:

7

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

lambda l:min([sum(((b-a)%360)**2for b in l)*len(l)-s*s,180-(180-a-s/len(l))%360]for a in l for s in[sum((b-a)%360for b in l)])[1]

यह समस्या काफी भ्रम पैदा करती है। सहज रूप से, विचार यह है कि किसी बिंदु पर कोणों के सर्कल को काट दिया जाए, सर्कल को एक लाइन पर अनप्रेड करें, उस लाइन पर अंकगणितीय माध्य की गणना करें, और फिर परिणाम को सर्कल में वापस लपेटें। लेकिन कई अलग-अलग बिंदु हैं जहां आप सर्कल में कटौती करना चुन सकते हैं। यह मनमाने ढंग से लेने के लिए पर्याप्त नहीं है, जैसे 0 ° या 180 °। आपको उन सभी को आज़माने और देखने की ज़रूरत है कि कौन सा परिणाम छोटी दूरी की छोटी राशि में है। यदि आपका समाधान इससे कम जटिल है, तो शायद गलत है।

— एंडर्स कसीर्ग
स्रोत
1
@AndreasKaseorg मुझे लगता है कि आप को बदलने के द्वारा एक बाइट बचा सकते हैं s**2करने के लिएs*s
— Ioannes
सवाल पर मेरी टिप्पणी देखें।
— msh210
@ msh210 मुझे यकीन नहीं है कि आप इस टिप्पणी को विशेष रूप से मुझे क्यों निर्देशित कर रहे हैं। मेरा समाधान पहले से ही इस तरह से काम करता है।
— एंडर्स कासोर्ग
यह आंशिक रूप से इस उत्तर पद के अंतिम वाक्य के उत्तर में था।
— msh210
4

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

lambda l:180-min(range(72000),key=lambda x:sum((180-(x/200+i)%360)**2for i in l))/200

1/200एक डिग्री की वृद्धि के साथ सभी संभव कोणों की कोशिश करके केवल दो दशमलव बिंदुओं के सटीक होने की आवश्यकता वाले उत्तर का लाभ उठाता है । मेरी मशीन पर यह एक सेकंड से भी कम समय लगता है।

क्योंकि पायथन हमें आसानी से तैरने की अंकगणितीय प्रगति की सूची नहीं देता है, हम पूरे कोण के रूप में संभव कोणों का प्रतिनिधित्व करते हैं [0,72000), जो कि कोण के रूप (-180,180]में परिवर्तित होते हैं x -> 180 - x/200। हम इनमें से एक को खोजते हैं जो वर्गीय कोणीय अंतर का न्यूनतम योग देता है।

के कोणीय विस्थापन के साथ दो कोणों के लिए d, वर्ग कोण कोणीय दूरी को बराबर कोण में बदलकर पाया (-180,180]जाता है 180-(d+180)%360, फिर चुकता । आसानी से, द्वारा दिया गया कोण x/200पहले से ही 180डिग्री से ऑफसेट है ।

— XNOR
स्रोत
की वेतन वृद्धि का उपयोग करना 1/200वास्तव में समस्याग्रस्त है। परीक्षण के मामले के लिए [1, 3, 3], यह समाधान वापस आ जाता है 2.335और गोल होता है 2.34जबकि सही उत्तर होना चाहिए 2.33।
— जोएल
@ जॉयल मुझे यकीन नहीं है कि आप कहां से गोल कर रहे हैं, ऐसा लगता है कि दशमलव अंक 2.33उस उदाहरण में सही हैं। किसी भी मामले में, बदल रहा होगा 200करने के लिए 400या करने के लिए 2000(और 72000तदनुसार) यह काम कर गोलाई के बावजूद? इसके अलावा, इस पुरानी समस्या को फिर से देखते हुए, मुझे लगता है कि मैं एक बेहतर तरीका देख सकता हूं।
— xnor
0.01m=argminxf(x)[s,s+0.01]f(s)<f(s+0.01)|m−s|<|m−s+0.01|round(m)=sff(s)>f(s+0.01)f(s)=f(s+0.01)round(m)=s+0.01f
यहाँ आप परीक्षण करने के लिए एक TIO लिंक है ।
— जोएल
ओह, मुझे सिर्फ एहसास हुआ कि आप सही हैं। यदि सही उत्तर है 2.333...और आपका प्रोग्राम वापस आ जाता है 2.335, तो यह बिना गोलाई के दो दशमलव स्थानों तक सही है। उसके लिए खेद है।
— जोएल
3

ऑक्टेव, 97 95 बाइट्स

p=pi;x=p:-1e-5:-p;z=@(L)sum((p-abs(abs(x-mod(L,360)*p/180)-p)).^2);@(L)x(z(L)==min(z(L)))*180/p

यह एक अनाम फ़ंक्शन का उत्पादन करता है, जो ग्रिड पर दिए गए फ़ंक्शन के न्यूनतम को खोजता है जो कि अभी पर्याप्त ठीक है। इनपुट के रूप में फ़ंक्शन कॉलम वैक्टर को स्वीकार करता है, जैसे [180; 60; -60]। परीक्षण के लिए आपको फ़ंक्शन को एक नाम देना होगा। इसलिए आप उदाहरण के लिए ऊपर दिए गए कोड को चला सकते हैं और फिर उपयोग कर सकते हैं ans([180, 60; -60])।

— flawr
स्रोत
हाँ, यह 180 पर लौटा।
— दोष
2

जावास्क्रिप्ट ईएस 6, 87 बाइट्स

with(Math)f=(...n)=>(t=>180/PI*atan(t(sin)/t(cos)))(f=>n.reduce((p,c)=>p+=f(c*PI/180)))

उदाहरण रन (फ़ायरफ़ॉक्स में परीक्षण):

f(-91,91)     // -0
f(-90,90)     // 0
f(0,-120,120) // 0
f(0,810)      // 44.999999999999936

कार्य प्रगति पर है

यह संस्करण औसत-सब-ए-डू-मॉड्यूलर-गणित की तुलना में थोड़ा अलग दृष्टिकोण लेता है। बल्कि, कोणों को वैक्टर में बदल दिया जाता है, वैक्टर को जोड़ दिया जाता है और परिणामस्वरूप वेक्टर के कोण की गणना की जाती है। दुर्भाग्य से, यह संस्करण है ट्रिगर के साथ बहुत अस्थिर है और मैं एक मॉड्यूलर-गणित संस्करण पर काम कर रहा हूं।

— Dendrobium
स्रोत
1
f(-91,91)180 लौटाना चाहिए।
— TheNumberOne
1
भले ही इसे सही तरीके से लागू किया गया हो, एक वेक्टर जोड़ दृष्टिकोण निर्दिष्ट परिणाम की गणना नहीं कर सकता है। वेक्टर जोड़ कोणीय अंतर के वर्ग के योग को अधिकतम करता है, बजाय कोणीय अंतर के वर्गों के योग को कम करता है।
— एंडर्स केसरग
2

CJam,  44  40 बाइट्स

Ie3_2*,f-:e-2{ea:~f{-P*180/mcmC2#}:+}$0=

इसमें ऑनलाइन कोशिश करें CJam दुभाषिया ।

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

$ for i in 1\ 3 90\ -90 0\ -120\ 120 0\ 810 1\ 3\ 3 180\ 60\ -60 0\ 15\ 45\ 460 91\ -91 -89\ 89
> do cjam <(echo 'Ie3_2*,f-:e-2{ea:~f{-P*180/mcmC2#}:+}$0=') $i
> echo
> done
2.0
180.0
0.0
45.0
2.33
60.0
40.0
180.0
0.0

विचार

हम आकार के चरणों के साथ -179.99 से 180.00 तक सभी संभावित औसत के लिए विचलन की गणना करते हैं 0.01 के , और सबसे कम विचलन के साथ एक का चयन करें।

इस उद्देश्य के लिए, यह कोई फर्क नहीं पड़ता कि हम कोणीय दूरी की डिग्री या रेडियन लेते हैं। मतभेद मानचित्रण के बजाय δ में इनपुट से कोण और संभावित औसत की [0360 °) और सशर्त से परिणाम को घटाकर 180 ° , हम कर सकते हैं बस calculate ARccOS (cos (πδ ÷ 180 °)) , के बाद से क्योंकि दोनों समय-समय पर और यहां तक कि है, और arccos हमेशा में एक मूल्य देता है [0, y) ।

कोड

Ie3        e# Push 18e3 = 18,000.
_2*        e# Copy and multiply by 2. Pushes 36,000.
,          e# Push the range [0 ... 35,999].
f-         e# Subtract each element from 18,000. Pushes [18,000 ... -17,999].
:e-2       e# Divide each element by 100. Pushes [180.00 ... -179.99].
{          e# Sort; for each element A of that array:
  ea:~     e#   Push and evaluate the array of command-line arguments.
  f{       e#   For each input angle, push A and the angle; then:
    -      e#     Subtract the angle from A.
    P*180/ e#     Convert from degrees to radians.
    mcmC   e#     Apply cos, then arccos to the result.
    2#     e#     Square.
  }        e#
  :+       e#   Add the squares. This calculates the deviation.
}$         e# A's with lower deviations come first.
0=         e# Select the first element of the sorted array.
— डेनिस
स्रोत
1

MATLAB, 151

p=360;n=mod(input(''),p);a=0:0.01:p;m=[];for b=a e=b-n;f=mod([e;-e],p);c=min(f);d=c.^2;m=[m sum(d)];end;[~,i]=min(m);a=a(i);if a>180 a=a-p;end;disp(a);

ठीक है, इसलिए जब तक मैं वास्तव में समझ सकता हूं कि कार्यप्रणाली क्या है, यह वही है जो मैं लेकर आया हूं। यह एक छोटा सा हैक है, लेकिन जैसा कि सवाल बताता है कि इसका जवाब सही होना चाहिए 2.dp यह काम करना चाहिए।

मैं मूल रूप से 0 और 360 (0.01 वेतन वृद्धि) के बीच हर कोण की जांच करता हूं और फिर उन प्रत्येक कोण के लिए प्रश्न में सूत्र को हल करता हूं। फिर सबसे छोटी राशि वाले कोण को उठाया जाता है और -180 से 180 सीमा में परिवर्तित किया जाता है।

कोड ऑक्टेव के साथ होना चाहिए । आप इसे ऑनलाइन दुभाषिया के साथ आजमा सकते हैं

— टॉम बढ़ई
स्रोत
1 °, 183 ° का परिणाम ,88 ° होना चाहिए, न कि 92 °।
— एंडर्स केसरग
@AndersKaseorg अब पुन: प्रयास करें।
— टॉम कारपेंटर
नहीं, कोई बात नहीं। ड्रॉइंग बोर्ड पर फिर से ...
— टॉम बढ़ई
1

जावास्क्रिप्ट (ईएस 6) 138

एक एल्गोरिथ्म के बेहोश विचार नहीं होने से, यह 2 अंकों के सटीक (-179.99 से 180.00) के साथ सभी कब्जे के मूल्यों की कोशिश करता है। वैसे भी परीक्षण मामलों के साथ काफी तेज।

EcmaScript 6 अनुरूप ब्राउज़र (एरो फ़ंक्शंस और डिफ़ॉल्ट मापदंडों को लागू करते हुए - AFAIK फ़ायरफ़ॉक्स) में नीचे दिए गए स्निपेट का परीक्षण करें

A=l=>(D=(a,b,z=a>b?a-b:b-a)=>z>180?360-z:z,m=>{for(i=-18000;i++<18000;)l.some(v=>(t+=(d=D(v%360,i/100))*d)>m,t=0)||(m=t,r=i)})(1/0)||r/100

// Test
console.log=x=>O.innerHTML+=x+'\n'

;[[1,3],[89,-89],[90,-90],[91,-91],[0,120,-120],[0,810],[1,3,3],[180,60,-60],[0,15,45,460],[1,183]]
.forEach(t=>console.log(t+' -> '+A(t)))

// Less golfed

A=l=>{
  D=(a,b,z=a>b?a-b:b-a) => z>180?360-z:z; // angular distance
  m=1/0;
  for(i=-18000;i++<18000;) // try all from -179.99 to 180
  {
    t = 0;
    if (!l.some(v => (t+=(d=D(v%360,i/100))*d) > m))
    {
      m = t;
      r = i;
    }  
  }  
  return r/100;
}
<pre id=O></pre>
स्निपेट का विस्तार करें

— edc65
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.