मिनी गोल्फ कोड गोल्फ

यह एक मिनी गोल्फ होल है:

बाहरी सीमा त्रिज्या 10 और केंद्र (0,0) के साथ एक चक्र है। आंतरिक सीमा त्रिज्या 3 और केंद्र (0,5) के साथ एक चक्र है। टी है (0, -8) पर। मान लें कि गेंद केवल त्रिज्या 0 के साथ एक बिंदु है।

गेंद की गतिकी निम्नलिखित नियमों द्वारा शासित होती है:

गेंद को शुरू में ऊर्जा 50 के साथ मारा जाता है, और दिए गए कोण के साथ।
- कार्टेसियन समन्वय प्रणाली में कोण नीचे की ओर है, इसलिए 0 ° का अर्थ सीधे दाईं ओर है, 90 ° सीधे ऊपर है, और इसी तरह।
जब गेंद आंतरिक या बाहरी सर्कल के किनारे से टकराती है, तो यह प्रतिबिंब के नियम का उपयोग करके सर्कल से बाहर उछलती है।
- उस बिंदु पर वृत्त के साथ टक्कर का कोण प्रतिबिंब के कोण के बराबर है। (यहाँ कोण टकराव के बिंदु पर वृत्त की स्पर्शरेखा रेखा के सापेक्ष हैं।)
- स्पष्टीकरण के लिए, इसे या इसे देखें (दूसरी कड़ी की सूचना में, इस चुनौती में R_0 = 0।)
गेंद चलते ही ऊर्जा खो देती है।
- जमीन की प्रत्येक इकाई को कवर करने के लिए, यह 1 यूनिट ऊर्जा खो देता है।
- हर बार जब वह दीवार से टकराता है तो वह 5 यूनिट ऊर्जा खो देता है।
गेंद या तो तब रुकती है जब वह ऊर्जा से बाहर निकलती है या जब वह छेद में गिरती है।
- यदि गेंद एक दीवार से टकराती है तो <= 5 यूनिट ऊर्जा मिलती है, यह रुक जाता है।
- यह छेद में गिरता है अगर इसमें ऊर्जा होती है <10 जब यह छेद 1 की दूरी के भीतर होता है, अन्यथा यह चलता रहता है।

चुनौती

एक छेद के xy निर्देशांक को देखते हुए, एक कोण लौटाएं जिस पर आप गेंद को छेद में गिरने के लिए गेंद को मार सकते हैं (यदि ऐसा कोण मौजूद है)।

इनपुट

किसी भी सुविधाजनक रूप में छेद के केंद्र के x- और y- निर्देशांक इनपुट के रूप में लें। इनपुट STDIN (या निकटतम विकल्प), कमांड लाइन पैरामीटर, या फ़ंक्शन तर्क से लिया जा सकता है।

उत्पादन

डिग्री में एक कोण को प्रिंट या वापस लौटाएं जिस पर गेंद को टी से मारा जा सकता है जैसे कि गेंद छेद में गिरेगी। यदि ऐसा कोण मौजूद है, तो उत्पादन सीमा [0, 360) में होना चाहिए, अन्यथा आउटपुट -1 होना चाहिए।

code-golf physics

— एरिक ब्रूक्स
स्रोत

आप यह निर्दिष्ट करना चाह सकते हैं कि x और y मान को कैसे पढ़ा जाना चाहिए (मानक इनपुट, फ़ंक्शन तर्क आदि)।

— लोवोजो

यदि कोई ऐसा कोण मौजूद नहीं है तो क्या लौटाया जाना चाहिए?

— एलेक्स ए।

आइए निर्दिष्ट करें कि यदि कोई समाधान है, तो फ़ंक्शन [0,360) में एक मान लौटाएगा और अन्यथा -1 लौटाएगा।

— एरिक ब्रूक्स

मैंने कुछ संपादन किए। यदि यह आपके इरादे से मेल नहीं खाता है, तो कृपया संपादन वापस करें।

— एलेक्स ए।

इसके अलावा, क्या आप कम से कम एक टेस्ट केस प्रदान कर सकते हैं?

— एलेक्स ए।

C, ~~415~~ 430

EDIT: जैसे @ उल्लेख किया गया है, 255 से ऊपर के निकास मूल्य संभव नहीं हैं, इसलिए मुझे 360 तक के मूल्यों को प्रिंट करने के लिए इस कोड का आकार बढ़ाना पड़ा।

2 (और केवल 2) कमांड-लाइन इनपुट्स (xy) को इन्टस के रूप में मानता है। डिग्री में उत्तर मुद्रित है या -1 यदि कोई डिग्री मौजूद नहीं है।

#include <math.h>
#define E(z) {if((e-=5)<0)break;q=n/sqrt(n*n+pow(m-z,2));w=(m-z)/sqrt(n*n+pow(m-z,2));d=(t=d)*(1-2*q*q)-2*f*q*w;f=f*(1-2*w*w)-2*t*q*w;}
main(a,v)char**v;{float D=.01,e,d,f,n,m,p=.0174,q,t,w;a-=4;while(++a<360){n=0,m=-8,d=D*cos(a*p),f=D*sin(a*p),e=50;while(e>0){if((pow(n-atoi(v[1]),2)+pow(m-atoi(v[2]),2)<1)&(e<10)&&printf("%d",a))return;n+=d,m+=f,e-=D;if(n*n+m*m>100)E(0)if(n*n+pow(m-5,2)<9)E(5)}}puts("-1");}

पूर्व।

>./golfed 0 2; echo $?
90
>./golfed 0 10; echo $?
0
>./golfed -2 -7; echo $?
12

पहली बार गोल्फर; शायद काफी सुधार किया जा सकता है। अगर हमें और अधिक सटीक होने की आवश्यकता है, तो मेरे पास एक संस्करण है जो xy में लेता है और कोण को 449 चार्ट पर .01 डिग्री परिशुद्धता के साथ काम करने वाले कोण के साथ लौटाता है।

पठनीय संस्करण:

#include <math.h>
int main(int argc, char** argv)
{
    // p is roughly pi/180 and q, t, and w are temp vars
    float Delta=.01, energy, delta_x, f(delta_y), n(cur_x), m(cur_y), p=.0174, q, t, w;
    argc -= 4; /*using argc as int for angle*/
    // iterate through each degree
    while (++argc < 360)
    {
        n=0, m=-8, d=D*cos(a*p), f=D*sin(a*p), e=50;
        // then move in discrete .01 steps
        while (e > 0)
        {
            // check to see if we're inside the hole
            if ((pow(n-atoi(v[1]),2) + pow(m-atoi(v[2]),2) < 1) 
                & (e<10) && printf("%d",a)) return;
            // move forward
            n += d, m += f, e -= D;
            // check if we've hit the outer wall
            if (n * n + m * m > 100)
            {
                // if too slow, finish this iteration
                // if not, find reflection vector
                if ((e -= 5) < 0) break;
                q = n / sqrt(n * n + pow(m,2));
                w = (m) / sqrt(n * n + pow(m,2));
                d = (t = d) * (1 - 2 * q * q) - 2 * f * q * w;
                f = f * (1 - 2 * w * w) - 2 * t * q * w;
            }
            // check inner wall collision
            if (n * n + pow(m - 5,2) < 9)
            {
                // if too slow, finish this iteration
                // if not, find reflection vector
                if ((e -= 5) < 0) break;
                q = n / sqrt(n * n + pow(m - 5,2));
                w = (m - 5) / sqrt(n * n + pow(m - 5,2));
                d = (t = d) * (1 - 2 * q * q) - 2 * f * q * w;
                f = f * (1 - 2 * w * w) - 2 * t * q * w;
            }
        }
    }
    // if an angle not found, return -1
    puts("-1");
}

— somesortofguy203
स्रोत

मुझे नहीं लगता कि आप 255 से बड़े मूल्यों को वापस कर सकते हैं exit(code)। लिनक्स और FreeBSD के माध्यम से परीक्षण किया गया echo 'int main(){return 300;}' > test.c && cc test.c && ./a.out; echo $?।

— विनी