चतुर्भुज एक लाइन से गुजरे

15

कार्य

किसी रेखा के प्रतिनिधित्व को देखते हुए, उस रेखा के चतुष्कोण की संख्या को आउटपुट करें जो उस रेखा से होकर गुजरती है।

एक लाइन के मान्य प्रतिनिधि

आप के रूप में एक पंक्ति का प्रतिनिधित्व कर सकते हैं

  • तीन हस्ताक्षरित पूर्णांक A, Bऔर Cजो कोई सामान्य कारक साझा नहीं करते हैं और जहां Aऔर Bदोनों शून्य नहीं हैं, लाइन का प्रतिनिधित्व करते हैं Ax + By = C,
  • चार पर हस्ताक्षर किए पूर्णांक , , , और , लाइन अंक के माध्यम से गुजर का प्रतिनिधित्व करने और , याX1Y1X2Y2(X1, Y1)(X2, Y2)
  • एक डेटा प्रकार जो एक पंक्ति का वर्णन करता है, यदि आपकी भाषा में एक है (इसे ऊर्ध्वाधर लाइनों का समर्थन करना चाहिए)।

आप किसी भी प्रारूप में इनपुट नहीं ले सकते हैं जो एक ऊर्ध्वाधर रेखा (जैसे ढलान-अवरोधन रूप) की अनुमति नहीं देता है। यदि आप पूर्णांक को इनपुट के रूप में लेना चुनते हैं, तो आप मान सकते हैं कि वे समावेशी सीमा में हैं [-127, 128]।

विशेष विवरण

  • आउटपुट हमेशा 0, 2, या 3 होगा (एक लाइन कभी भी सभी चार क्वाड्रंट से नहीं गुजर सकती है, न ही यह केवल एक एकल से गुजर सकती है)।
  • अक्ष पर एक रेखा को किसी भी चतुर्भुज के माध्यम से पारित नहीं करने के लिए माना जाता है। मूल के माध्यम से एक पंक्ति को केवल 2 चतुर्भुजों के माध्यम से पारित करने के लिए माना जाता है।
  • आपको लौटने की ज़रूरत नहीं है कि किन क्वाडंटेंट्स के माध्यम से पारित किया जा रहा है (हालांकि परीक्षण मामलों में स्पष्टता के लिए उन्हें शामिल किया गया है)।
  • यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर (बाइट्स में मापा गया) जीतता है।

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

आपको उनका उपयोग करने से पहले उन्हें एक उपयुक्त प्रारूप में बदलना होगा।

1x + 1y = 1   ->  3  (quadrants I, II, and IV)
-2x + 3y = 1  ->  3  (quadrants I, II, and III)
2x + -3y = 0  ->  2  (quadrants III and I)
1x + 1y = 0   ->  2  (quadrants II and IV)
3x + 0y = 6   ->  2  (quadrants I and IV)
-3x + 0y = 5  ->  2  (quadrants II and III)
0x + -8y = 4  ->  2  (quadrants III and IV)
0x + 1y = 0   ->  0  (lies on the x-axis)
1x + 0y = 0   ->  0  (lies on the y-axis)
code-golf  number  geometry 
— फल तोड़ना
स्रोत
1
उन्हें स्कूल में लीक नन से उधार ली गई रणनीति सिखानी चाहिए, अगर इसके लिए कोई ज़रूरत थी।
— mbomb007

जवाबों:

22

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

lambda a:3<<a.count(0)&3

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

— लीक नन
स्रोत
3
... वाह। यह मेरे विचार से अधिक तुच्छ है।
— फल
यदि I / O इसे अनुमति देता है तो आप शायद सूची के बजाय एक स्ट्रिंग का उपयोग कर सकते हैं।
— जोनाथन फ्रेच
क्या '320'[a.count(0)]स्ट्रिंग रूप में मूल्य का उपयोग करना और वापस करना स्वीकार्य होगा?
— 21
2
और वाह, लगता है कि सभी उत्तर अब "लीक से हटकर" आधारित होंगे
— FlipTack
3
@FlipTack बिटकॉइन जीतते हैं: पी
— लीक नून
3

जेली , 5 बाइट्स

TL’ȧ$

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

  • चैलेंजर 5 के लिए -1 बाइट धन्यवाद
  • -1 बाइट थैंक्स टू लीकी नन
  • -2 बाइट्स H.PWiz को धन्यवाद

अब लीक के जवाब पर आधारित नहीं है!

— केर्ड सिक्काहिरिंग
स्रोत
ċ0ị2,0,3एक बाइट बचाता है
— फल
@ चैलेंजर 5 हुह, ऐसा करता है। धन्यवाद!
— 21
1
— लीक
1
कैसे के बारे में TL’ȧ$। जेली को नहीं जानते, इसलिए यह गोल्फ हो सकता है
— H.PWiz
@ H.PWiz बहुत अच्छा! मुझे नहीं लगता कि गोल्फ हो सकता है, लेकिन मैं गलत हो सकता हूं।
— 22
3

जावास्क्रिप्ट (ईएस 6), 30 24 22 बाइट्स

यह मेरी पहली बार जावास्क्रिप्ट में गोल्फ की कोशिश कर रहा है। शून्य को गिनने का एक बेहतर तरीका होगा ...

(a,b,c)=>3<<!a+!b+!c&3

-6 बाइट्स के लिए धन्यवाद हर्मन लुआंस्टीन, -2 बाइट्स ऑपरेटर ऑपरेटर याद करने के लिए।

इसके बजाय एक स्ट्रिंग वापस करने के लिए वैकल्पिक 24-बाइट्स समाधान:

(a,b,c)=>"320"[!a+!b+!c]
— स्टीवन एच।
स्रोत
1
यह वास्तव में काफी चालाक है ...
— 22
1
एक सरणी का उपयोग नहीं करके 24 बाइट्स(a,b,c)=>3<<(!a+!b+!c)&3
— हरमन एल
लगता है कि मैं अब किसी सरणी का उपयोग नहीं करने के लिए गोल्फ की खान नहीं कर सकता ...
— ericw31415
2

गोल्फस्क्रिप्ट , 16 14 बाइट्स

~{!!}%{+}*.1>*

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

  • @ चैलेंजर 5 -2 बाइट्स

यह प्रोग्राम समीकरण में गुणांक का प्रतिनिधित्व करने वाले 3 पूर्णांक की एक सरणी लेता है Ax + By = C

उदाहरण इनपुट / आउटपुट

[1 1 1]   -> 3
[-2 3 1]  -> 3

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

~                       - Eval string (input)
  {  }%                 - Map to array
   !!                   - Double not (equivalent to != 0)
        {+}*            - total array (fold addition)
            .           - Duplicate top of stack
             1>         - Greater than 1?
               *        - Multiply

यह गणना करने के लिए गणितीय तरीका निकालने के लिए मेरे लिए पहली बार में थोड़ा मुश्किल था। हालाँकि इस तरह के केवल 8 संभावित विन्यास हैंa != 0 & b != 0 & c != 0

0 0 0 = 0
a 0 0 = 0
0 b 0 = 0
0 0 c = 0
a 0 c = 2
0 b c = 2
a b 0 = 2
a b c = 3

मैं अंततः निम्नलिखित समारोह में आया।

F(a,b,c) {
    var r = sign(a)+sign(b)+sign(c);
    if(r > 1)
        r;
    else
        return 0;
}

और पूरी बात को एक एकल गणित समस्या के लिए संघनित किया जा सकता है

F(a,b,c) {
    return (sign(a)+sign(b)+sign(c)) * (sign(a)+sign(b)+sign(c) > 1);
}
— मार्कोस
स्रोत
मुझे लगता है कि आप {!!}%इसके बजाय उपयोग कर सकते हैं [{!!}/]।
— 2
इस सबमिशन का सीजेम ट्रांसलेशन है {:!:!:+_1>*}।
— 2:02 पर फल
@ चैलेंजर 5 लोल, मुझे इसका एहसास कैसे नहीं हुआ। इसके अलावा अच्छा पोर्ट, मुझे अभी सीखना है कि इसे कैसे पढ़ना है।
— मार्कोस
इस मामले में महत्वपूर्ण अंतर हैं 1) मैपिंग के लिए शॉर्टहैंड ( :!बराबर है {!}%), 2) शॉर्टहैंड को कम करने के लिए ( :+यह बराबर है {+}*), 3) जो कि (क्योंकि सीजेएम में तैरता है) .में बदल जाता है _, और 4) कि सीजेएम के पास इनपुट नहीं है डिफ़ॉल्ट रूप से स्टैक पर, जिसका अर्थ है कि आप {}इसे एक फ़ंक्शन बनाने के लिए कोड को लपेटते हैं ।
— 4
2

रेटिना , 13 बाइट्स

M`\b0
T`d`320

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

इसके अलावा लीक नून के जवाब पर आधारित है ।

— mbomb007
स्रोत
यदि इनपुट में 10उदाहरण के लिए यह काम नहीं करता है । पहले रेगेक्स होने की आवश्यकता होगी \b0।
— मार्टिन एंडर
1

जावास्क्रिप्ट, 25 बाइट्स

_=>3<<!_[0]+!_[1]+!_[2]&3

लीक नून के जवाब के आधार पर।

— ericw31415
स्रोत
1

ABCR , 30 बाइट्स

इनपुट उस रूप में है A,B,Cजहां अल्पविराम किसी गैर-संख्यात्मक, गैर- -चरित्र द्वारा प्रतिस्थापित किया जा सकता है ।

BBi7baxci7baxci7bax@7)A7(xxo

अभी तक कोई ऑनलाइन दुभाषिया नहीं है, लेकिन यहाँ एक स्पष्टीकरण है:

BB                                Add two values to the B queue. (Values are unimportant)
  i7 ax                           Read in a number.  If it's non-zero...
    b                             Dequeue one item from the B queue.
       c                          Read in the delimiter...
        i                         ... And promptly overwrite it with the next number.
         7baxci7bax               Repeat the whole "if 0, dequeue from B" for the
                                     other two input numbers.
                   @              Get the current length of the B queue. [2, 1, or 0]
                    7             If the length isn't 0...
                     )            ... Increment it to our required [3,2,0]
                      A           ... And enqueue it to A.
                                  (We don't need to add to A otherwise, because it defaults
                                    to 0 already if there's no value in it.
                                    I used that to exit the queue with 7_ax earlier.)
                       7(xx       Set the register to 0 to exit from loop.
                           o      Peek A and print as a number.
— स्टीवन एच।
स्रोत
0

डोरस्ट , 12 बाइट्स

l0EN))A:k?Z+

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

कुछ हद तक लीक के जवाब पर आधारित है ; एक ही आधार का उपयोग करता है, लेकिन एक अलग मानचित्रण विधि।

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

डोरस्ट में एक गणना घटित होती है, लेकिन (किसी कारण से) में अनुक्रमणिका कमांड नहीं होती है, इसलिए मुझे निम्नलिखित मानचित्रण बनाना होगा, जहां बाईं a.count(0)ओर दाईं ओर वांछित परिणाम है

0 -> 3
1 -> 2
2 -> 0

कार्यक्रम स्वयं इस तरह काम करता है (उदाहरण इनपुट [1,1,1])

l0           - Push 0;     STACK = [[1 1 1] 0]
  EN         - Count;      STACK = [0]
    ))       - Subtract 2; STACK = [-2]
      A      - Absolute;   STACK = [2]
       :     - Duplicate;  STACK = [2 2]
        k?Z  - Positive?;  STACK = [2 1]
           + - Sum;        STACK = [3]
— केर्ड सिक्काहिरिंग
स्रोत
0

++ , 23 बाइट्स जोड़ें

D,f,@@@,!$!@!s2$_|d0$>+

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

दोनों मेरे डीओर्स्ट उत्तर के आधार पर और लीकी के पायथन उत्तर

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

D,f,@@@,  - Create a triadic function. 
            Example arguments;   [1 1 1]
        ! - Logical NOT; STACK = [1 1 0]
        $ - Swap;        STACK = [1 0 1]
        ! - Logical NOT; STACK = [1 0 0]
        @ - Reverse;     STACK = [0 0 1]
        ! - Logical NOT; STACK = [0 0 0]
        s - Sum;         STACK = [0]
        2 - Push 2;      STACK = [0 2]
        $ - Swap;        STACK = [2 0]
        _ - Subtract;    STACK = [-2]
        | - Absolute;    STACK = [2]
        d - Duplicate;   STACK = [2 2]
        0 - Push 0;      STACK = [2 2 0]
        $ - Swap;        STACK = [2 0 2]
        > - Greater to;  STACK = [2 1]
        + - Sum;         STACK = [3]

हालाँकि, मुझे लगता है कि मैं मुख्य कोड बॉडी के बजाय Add ++ में फ़ंक्शंस का बहुत अधिक उपयोग कर रहा हूं। इसलिए मैंने ऐसा करने के लिए दोनों कार्यों और कोड बॉडी का उपयोग करने का प्रयास किया, और परिणामस्वरूप बहुत से अच्छे 50 बाइट पीस (हाँ, यह यहां का सबसे लंबा जवाब है):

# Example input: 1 1 1;
# x and y are the accumulators

D,f,@@@,!$!@!s # Count the 0s
$f>?>?>?       # Call f with the input.
-2   # Subtract 2;    x: -2;  y: 0
^2   # Square;        x: 4;   y: 0
S    # Square root;   x: 2.0; y: 0
\1   # To integer;    x: 2;   y: 0
y:x  # Assign x to y; x: 2;   y: 2
}    # Switch to y;   x: 2;   y: 2
>0   # Is positive?;  x: 2;   y: 1
}    # Switch to x;   x: 2;   y: 1
+y   # Add y to x;    x: 3;   y: 1
O    # Print x

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

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