चक्करदार पूर्णांक

25

आपकी चुनौती आज पूर्णांक के सभी को समाहित करते हुए दिए गए एक पद का आउटपुट देना है। अनुक्रम इस प्रकार है: अगर हम 0-अनुक्रमित समारोह अनुक्रम पैदा करने के लिए है f(n)और ceil(x)छत समारोह है, तो है f(0) = 0; abs(f(n)) = ceil(n/2); sign(f(n))सकारात्मक जब है nऔर ceil(n/2)या तो दोनों भी या दोनों अजीब हैं।

इस क्रम को समझने में मदद करने के लिए, पहले कुछ शब्द इस प्रकार हैं: 0 1 -1 -2 2 3 -3 -4 4 5 -5 -6 6 7 -7...

आपका कार्य एक प्रोग्राम लिखना है जो पूर्णांक लेता है nऔर nअनुक्रम के वें शब्द को आउटपुट करता है। इनपुट केवल 0 या 1-अनुक्रमित हो सकता है।

परीक्षण के मामले (0-अनुक्रमित):

0  =>  0
1  =>  1
2  => -1
3  => -2
4  =>  2
5  =>  3

यह कोड-गोल्फ , सबसे कम बाइट्स जीतता है!

code-golf  sequence  integer 
— पावेल
स्रोत
— सर्गियोल
ऐसा लगता है कि एक फोल्डिंग फ़ंक्शन
— सर्गियोल

जवाबों:

8

SOGL V0.12 , 8 6 बाइट्स

I».»⌡±

यह कोशिश करो! या पहले दो नंबरों की कोशिश करें (थोड़ा बदल गया तो यह काम करेगा)
0-अनुक्रमित।

स्पष्टीकरण:

I       increment the input
 »      floor divide by 2
  .     push the original input
   »    floor divide by 2
    ⌡   that many times
     ±    negate

या सरल:

(input + 1) // 2 negated input // 2 times
        I     »     ±      .     »    ⌡
— dzaima
स्रोत
3
यह एक छोटी सी बात नहीं है!
— NieDzejkob
6
मैं ».»फोन पर हूं I».»⌡±।
— जोनाथन एलन
@JonathanAllan मुझे नहीं मिला ।_
— पावेल १
4

सी, 25 बाइट्स

f(n){return~n/2*~-(n&2);}
— orlp
स्रोत
आप कीवर्ड वापसी का उपयोग करने के बजाय पहले रिटर्न को अपना रिटर्न मान बताकर 4 बाइट बचा सकते हैं। f(n){n=~n/2*~-(n&2);}
— क्लेब्लांक
5
@cleblanc यह नहीं है कि C कैसे काम करता है।
— 20
2
gcc -O0x86-64 के लिए @ क्लैबलैंस के संस्करण को उन निर्देशों को संकलित करने के लिए होता है, जो बहु परिणाम को छोड़ने के लिए होते हैं eax( Godbolt.org/g/dztKPV ), लेकिन तब यह एक x86-64 gcc -O0उत्तर होगा, सी उत्तर नहीं। मैं सी-वोट का जवाब नहीं देता हूं जो अनुकूलन के साथ टूटते हैं, विशेष रूप से रिटर्न-वैल्यू बकवास के रूप में बेवकूफ अंतिम अभिव्यक्ति नहीं है। भले ही यह कैसे काम करने के लिए होता है, यह नहीं है कि सी कैसे काम करता है।
— पीटर कॉर्ड्स
ना पॉइंटर बनाओ। यदि मूल और अंतिम मान स्टैक पर नहीं हैं, तो आपको अनुकूलन की आवश्यकता नहीं है।
— mreff555
1
@ mreff555 यह एक गैर-मानक (हालांकि स्वीकार्य) IO विधि होगी, और कोई भी छोटा नहीं होगा।
— orlp
3

Pyke , 6 बाइट्स

heQeV_

यहाँ यह कोशिश करो!

डेज़ीमा के दृष्टिकोण का उपयोग करता है ... बीट्स टाई जेली!

व्याख्या

h      - Increment the input, which is implicit at the beginning.
 e     - Floor halve.
  Q    - Push the input.
   e   - Floor halve.
    V_ - Apply repeatedly (V), ^ times, using negation (_).
       - Output implicitly.

हेक्स-एन्कोडेड बाइट्स समतुल्य होंगे 68 65 51 65 56 5F:।

— श्री Xcoder
स्रोत
3

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

HµĊN⁸¡

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

डीज़िमा के एल्गोरिथ्म का उपयोग करता है।

-1 जोनाथन एलन को धन्यवाद ।

— आउटगोल्फर को एरिक करें
स्रोत
SOGL जेली की पिटाई नहीं कर सकता ...? गोल्फ में देखेंगे।
— आउटगॉल्फ
@JonathanAllan duh> _ <
— आउटगॉल्फ
3

गणितज्ञ, 24 बाइट्स

(s=⌈#/2⌉)(-1)^(#+s)&

-14 बाइट्स @ मिशा लावरोव से

— J42161217
स्रोत
1
का उपयोग करना Booleऔर OddQविषम संख्याओं को 1 और यहां तक ​​कि संख्याओं को 0 में परिवर्तित करने का प्रभाव है, लेकिन आपको यहां इसकी आवश्यकता नहीं है: -1 की शक्तियां आपको वैसे भी सभी विषम संख्याओं के लिए सही उत्तर देती हैं। तो आप उस कदम को (-1)^Tr@{#,s}या सिर्फ नीचे काट सकते हैं (-1)^(#+s)।
— मीशा लावरोव
3

हास्केल , 25 43 42 बाइट्स

((do a<-[0..];[[-a,a],[a,-a]]!!mod a 2)!!)

इसे ऑनलाइन आज़माएं! 1 अनुक्रमित।

संपादित करें: पिछले संस्करण में गलत क्रम में संकेत थे, @ Potato44 को इंगित करने के लिए धन्यवाद। 18 बाइट्स के लिए निश्चित ...

संपादित 2: बीएमओ -1 बाइट के लिए धन्यवाद!

— Laikoni
स्रोत
आप do-notation का उपयोग करके 1 बाइट बचा सकते हैं, इसे ऑनलाइन आज़माएं!
— ।
@ बीएमओ धन्यवाद! ...
— लैकोनी
2

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

n=>~n/2*~-(n&2)^0

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

यह एक 0 अनुक्रमित है। यह पूरी तरह से बिटकॉइन ट्रिक है।

— पुनरावर्ती
स्रोत
2

Cubically , 23 बाइट्स

(1 अनुक्रमित)

FDF'$:7+8/0_0*0-8*7/0%6

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

क्यूबिकली में कोड लिखते समय मुख्य कठिनाई होती है:

  • केवल 1 लिखने योग्य चर है, और
  • स्थिरांक प्राप्त करना कठिन है।

तो, यह समाधान गणना करता है

((((n+1)/2)%2)*2-1)*n/2

जहां /पूर्णांक विभाजन को दर्शाता है। कि केवल 1 अस्थायी चर और स्थिरांक 1 और 2 की जरूरत है।

स्पष्टीकरण:

FDF'$:7+8/0_0*0-8*7/0%6
FDF'                      Set face value of face 0 to 2, and value of memory index 8 (cube is unsolved) to 1 (true = unsolved)
    $                     Read input
     :7                                 input
       +8                                + 1
         /0                        (        ) /2
           _0                     (             ) %2
             *0                  (                  ) *2
               -8                                        -1
                 *7             (                          ) *n
                   /0                                          /2
                     %6   Print
— user202729
स्रोत
2

TI-Basic (TI-84 Plus CE), 20 बाइट्स

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2

एक पूर्ण कार्यक्रम जिसे कहा जाता है 5:prgmNAME।

टीआई-बेसिक एक टोकन लैनुज है , यहां इस्तेमाल किए जाने वाले सभी टोकन एक बाइट हैं, remainder(जिसके अलावा दो हैं। ‾रीजेनिक टोकन का प्रतिनिधित्व करता है, जो (-)कुंजी के साथ टाइप किया जाता है ।

उदाहरण:

0:prgmNAME
 => 0
1:prgmNAME
 => 1
2:prgmNAME
 => -1
#etc

स्पष्टीकरण:

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2
‾int(‾Ans/2)                           # -int(-X) is ciel(X), so ciel(Ans/2)
                          int(Ans/2)   # int(X) is floor(X), so floor(Ans/2)
                remainder(int(Ans/2),2 # 1 if floor(Ans/2) is odd else 0
            (1-2remainder(int(Ans/2),2 # -1 if floor(Ans/2) is odd, else 1
_int(_Ans/2)(1-2remainder(int(Ans/2),2 # -ciel(Ans/2) if floor(Ans/2) is odd, else ciel(Ans/2)

Y-var फ़ंक्शन के रूप में समान सूत्र:

Y1= ‾int(‾X/2)(1-2remainder(int(X/2),2
— pizzapants184
स्रोत
2

जावा 8, 15 बाइट्स

n->~n/2*~-(n&2)

संपादित करें: क्या जावा वास्तव में गैर-गोल्फ भाषाओं में सबसे छोटा है ?! o.o

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

मैं नीचे दी गई तालिका का उपयोग करूंगा कि क्या हो रहा है।

  1. ~nके बराबर है -n-1।
  2. चूंकि जावा में पूर्णांक विभाजन स्वचालित रूप से सकारात्मक पूर्णांकों पर फर्श करता है और नकारात्मक पूर्णांकों पर छत, ~n/2अनुक्रम में परिणाम देगा0,-1,-1,-2,-2,-3,-3,-4,-4,-5,-5,...
  3. n&20या तो 2अनुक्रम में परिणाम होगा0,0,2,2,0,0,2,2,0,0,2,...
  4. ~-xके बराबर है (x-1), इसलिए ~-(n&2)( ((n&2)-1)) अनुक्रम में परिणाम-1,-1,1,1,-1,-1,1,1,-1,-1,1,...
  5. के दो दृश्यों को गुणा करने ~n/2और ~-(n&2)देता है सही चुनौती में पूछा अनुक्रम है:0,1,-1,-2,2,3,-3,-4,4,5,-5,...

अवलोकन तालिका:

n       ~n      ~n/2    n&2     ~-(n&2)     ~n/2*~-(n&2)
0       -1      0       0       -1          0
1       -2      -1      0       -1          1
2       -3      -1      2       1           -1
3       -4      -2      2       1           -2
4       -5      -2      0       -1          2
5       -6      -3      0       -1          3
6       -7      -3      2       1           -3
7       -8      -4      2       1           -4
8       -9      -4      0       -1          4
9       -10     -5      0       -1          5
10      -11     -5      2       1           -5
— केविन क्रूज़सेन
स्रोत
2

ब्रेन-फ्लैक , 86 74 72 70 बाइट्स

{({}[()]<({}<>([({})]{(<{}([{}]())>)}{}())<>)>)}{}<>{}{<>([{}])(<>)}<>

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

व्याख्या

इस कोड के दो भाग हैं। पहला भाग

({}[()]<({}<>([({})]{(<{}([{}]())>)}{}())<>)>)}{}

की गणना करता है। यह निर्धारित करता है ceil(n/2)और आउटपुट को नकारना है या नहीं।

यह समझने के लिए कि यह कैसे काम करता है मैं पहले बताऊंगा कि कोई कैसे गणना करेगा ceil(n/2)। यह निम्नलिखित कोड के साथ किया जा सकता है

{({}[()]<({}([{}]()))>)}{}

यह प्रत्येक बार n से नीचे गिना जाता है जब यह ([{}]())एक काउंटर पर एक नहीं ( ) करता है और परिणाम में काउंटर जोड़ता है। चूंकि काउंटर शून्य आधा समय है इसलिए हम केवल पहले वाले के साथ शुरू होने वाले हर दूसरे रन को बढ़ाते हैं।

अब मैं अपने परिणामों के संकेत की भी गणना करना चाहता हूं। ऐसा करने के लिए हम एक और काउंटर शुरू करते हैं। यह काउंटर केवल स्थिति बदलता है यदि पहला काउंटर बंद है। इस तरह हमें वांछित पैटर्न मिलता है। हम इन दो काउंटरों को समय आने पर उन्हें इधर-उधर ले जाने में आसानी के लिए ऑफ स्टैक पर रख देते हैं।

अब एक बार हमने यह गणना पूरी कर ली है कि हमारा स्टैक इस तरह दिखता है

          parity(n)
ceil(n/2) sign

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

<>{}{<>([{}])(<>)}<>
— गेहूं का जादूगर
स्रोत
1

प्रोटॉन , 23 बाइट्स

n=>-~n//2//(-1)**(n//2)

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

पोर्ट ऑफ़ हलवर्ड के समाधान ।

प्रोटॉन , 23 बाइट्स

n=>-~n//2*(-1)**(n%4>1)

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

पोर्ट ऑफ़ लीकी के समाधान ।

थोड़ा और प्रोटोनिक, 24 बाइट्स: 

n=>-~n//2*(**)(-1,n%4>1)
— श्री Xcoder
स्रोत
1

QBIC , 27 26 बाइट्स

g=(:+1)'\2`~(a-g)%2|?-g\?g

व्याख्या

g=          set worker var 'g' to
(:+1)           our index (plus one for the ceil() bit)
'\2`            integer divided by 2 (the int div needs a code literal: '..`
~(a-g)%2    IF index - temp result is odd (index 2 minus result 1 = 1)
|?-g        THEN PRINT g negated
\?g         ELSE PRINT g
— steenbergh
स्रोत
1

क्लोजर 122 बाइट्स

Verbose, यहां तक ​​कि जब गोल्फ। मैं यहाँ सहानुभूति वोट के लिए जा रहा हूँ ... :-)

golfed:

(defn d[n](let[x(int(Math/ceil(/ n 2)))y(cond(or(and(even? n)(even? x))(and(odd? n)(odd? x)))(Math/abs x):else(- 0 x))]y))

Ungolfed:

(defn dizzy-integer [n]
  (let [x   (int (Math/ceil (/ n 2)))
        y   (cond
                (or (and (even? n) (even? x))
                    (and (odd? n)  (odd? x))) (Math/abs x)
                :else (- 0 x)) ]
    y))
— बॉब जार्विस - मोनिका को बहाल करें
स्रोत
1

एक्सेल VBA 32-बिट, 39 37 बाइट्स

बेनामी VBE तत्काल विंडो फ़ंक्शन जो सेल से इनपुट लेता है A1और VBE तत्काल विंडो में आउटपुट करता है

?[Sign((-1)^Int(A1/2))*Int((A1+1)/2)]

32-बिट के लिए प्रतिबंधित A^B64-बिट में मान्य नहीं है ( A ^Bजो जितना प्राप्त किया जा सकता है उतना ही करीब है)

— टेलर स्कॉट
स्रोत
के बीच की जगह (-1)और ^[Intजरूरत है?
— पावेल
@ कम से कम एक्सेल VBA के 64-बिट संस्करण के लिए, हाँ; लेकिन कहा कि मैं कसम खाता हूं कि यह 32-बिट संस्करण के लिए नहीं है, लेकिन अफसोस कि मैं परीक्षण नहीं कर सकता कि मेरे पास किसी भी हार्डवेयर पर है
— टेलर स्कॉट
@ पावेल - मैंने इसे 32-बिट सिस्टम (डिफ़ॉल्ट इंस्टॉल युक्ति) के तहत देखा है और उस प्रणाली के तहत स्थान की आवश्यकता नहीं है - मैंने इसका लाभ उठाने के लिए 32-बिट के समाधान को प्रतिबंधित कर दिया है
— टेलर स्कॉट
1
ठंडा! यद्यपि आप सही बाइट गिनती में जोड़ना भूल गए।
— पावेल
व्हाट्स, थैंक्स @ पावेल - इसका अब तय है
— टेलर स्कॉट
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.