संकेत का उत्पादन

67

एक नंबर N को देखते हुए, N का साइन आउटपुट करें :

  • यदि N पॉजिटिव है, तो आउटपुट 1
  • यदि एन नकारात्मक है, तो आउटपुट -1
  • यदि N 0 है, तो आउटपुट 0 है

N आपकी चुनी हुई भाषा में पूर्णांकों की प्रतिनिधित्व योग्य सीमा के भीतर एक पूर्णांक होगा।

code-golf  math  number  integer 
— मेगो
स्रोत
45
यह एक तुच्छ चुनौती है जिसमें बहुत सारे तुच्छ समाधान हैं। हालांकि कुछ गैर-तुच्छ समाधान भी हैं। मतदाताओं को: बिलियन फ़ंक्शन को बढ़ाने से पहले कृपया इस मेटा पोस्ट का पहला वाक्य पढ़ें ।
— स्टीवी ग्रिफिन
8
यह शायद एक लीडरबोर्ड का उपयोग कर सकता है।
— मार्टिन एंडर
2
@Mrister अपवोट करें कि आप कैसे चाहते हैं, लेकिन वास्तव में आपको कोड लंबाई के बजाय रचनात्मकता की तलाश करनी चाहिए।
— FlipTack
3
@FlipTack ओह, मैंने सोचा कि यह कोडगॉल्फ था।
— श्री लिस्टर
3
@Mrister कि उद्देश्य जीतने की कसौटी है। लेकिन क्या यह वास्तव में sएक साइन बिलिन के लिए टाइप करने के लिए अधिक प्रयास करता है , या इसे बाहर काम करने के लिए कुछ चतुर बिटशफ्टिंग / मैथ्स का उपयोग करता है? इस मेटा पोस्ट
— FlipTack

जवाबों:

46

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

[1-9].*
1

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

एक गैर-शून्य अंक और उसके बाद सब कुछ बदल देता है 1। यह एक संभावित अग्रणी -अक्षुण्ण छोड़ देता है और 0पूर्ण मान को छोड़कर सभी संख्याओं को बदल देता है 1।

— मार्टिन एंडर
स्रोत
यह बहुत चालाक है :)
— Mego
क्या यह पूर्णांक संख्याओं के वैज्ञानिक अंकन (जैसे 0.42e2) के साथ काम करता है ?
— ईगोर स्क्रीप्टुनॉफ
@EgorSkriptunoff नहीं, लेकिन यह एक आवश्यकता नहीं है।
— मार्टिन एंडर
9
@EgorSkriptunoff यह या तो रोमन अंकों का समर्थन नहीं करता है। जब तक चुनौती स्पष्ट रूप से एक निश्चित गैर-मानक प्रारूप का उल्लेख नहीं करती है, जिसे समर्थन करने की आवश्यकता होती है, सामान्य धारणा यह है कि अपनी पसंद की भाषा में स्वाभाविक रूप से एकल प्रारूप से निपटना ठीक है।
— मार्टिन एंडर
3
@EgorSkriptunoff रेटिना को संख्याओं की कोई अवधारणा नहीं है। यह पूरी तरह से स्ट्रिंग-आधारित भाषा है।
— मार्टिन एंडर
42

सी (जीसीसी), 24 23 22 18 बाइट्स

एक बाइट को बचाने के लिए @aross और @Steadybox को धन्यवाद!

f(n){n=!!n|n>>31;}

सभी सिस्टम या कंपाइलर पर काम करने की गारंटी नहीं, TIO पर काम करता है ।

— betseg
स्रोत
7
@betseg ऐसा इसलिए है क्योंकि बिल्ट-इन पर अपवोट्स अब आ गए हैं।
— को आउटगॉल्फ को एरिक करें
4
इस के साथ 1 बाइट सहेजा जा रहा हैreturn n>>16|!!n;
— aross
5
@GB का इंट का साइज़ शायद 2 (16, x86) या 4 (32, x86_64) है, लेकिन याद रखें, जिसकी ज़रूरत है वह एक आर्किटेक्चर है , जिस पर यह मान्य है। यह स्टैक ओवरफ्लो नहीं है, पोर्टेबिलिटी महत्वपूर्ण नहीं है।
— बिल्ली
2
f(n){n=n>>31|!!n;}काम भी करता है। लेकिन यह सिर्फ एक कंपाइलर क्विक है, न कि लैंग्वेज फीचर।
— जीबी
2
@ जीबी कंपाइलर क्वर्क्स पूरी तरह से मान्य हैं, इसलिए जब तक यह साबित किया जा सकता है कि एक कंपाइलर है जिसमें क्वर्क काम करता है। सौभाग्य से, जीसीसी में विचित्रता है।
— मेघ
34

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

Clip

बिल्ट-इन Signऔर अभी भी 4 बाइट्स स्कोरिंग का उपयोग नहीं करने के बारे में कैसे ? ;)

Clipएकल तर्क क्लिप (या क्लैम्प) के बीच इनपुट मान -1और 1। चूंकि इनपुट केवल पूर्णांक होंगे, यह उपयोग करने के समान है Sign।

— मार्टिन एंडर
स्रोत
29

गाय, 225 213 201 बाइट्स

oomMOOmoOmoOmoOmoOMoOMoOmOomOomOoMoOMMMmoOMMMMOOMOomOo
mOoMOomoOmoOmoomOomOoMMMmoOmoOmoOMMMMOOOOOmoOMOoMOomOo
mOomOoMoOMMMmoOMMMMOOMOomOomOoMoOmoOmoOmoomoOmoomOomOo
mOomoomoOMOOmoOmoOmoOMOoMMMOOOmooMMMOOM

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

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

-5  - 1  = -6  (current state: 0 + 2 = 2)
-6  + 2  = -4  (current state: 2 - 2 = 0)
-4  - 3  = -7  (current state: 0 + 2 = 2)
-7  + 4  = -3  (current state: 2 - 2 = 0)
-3  - 5  = -8  (current state: 0 + 2 = 2)
-8  + 6  = -2  (current state: 2 - 2 = 0)
-2  - 7  = -9  (current state: 0 + 2 = 2)
-9  + 8  = -1  (current state: 2 - 2 = 0)
-1  - 9  = -10 (current state: 0 + 2 = 2)
-10 + 10 =  0  (current state: 2 - 2 = 0)
value is now at 0.  state - 1 = 0 - 1 = -1
sign of original number is -1

जब आप कर लें, तो अपने राज्य से 1 घटाएं और आपको संकेत मिले, सकारात्मक या नकारात्मक। यदि मूल संख्या 0 है, तो ऐसा करने से परेशान न हों और केवल 0 प्रिंट करें।

विस्तृत विवरण:

oom                                        ;Read an integer into [0]
MOO                                        ;Loop while [0] is non-empty
    moOmoOmoOmoOMoOMoOmOomOomOo            ;    Decrement [4] twice
    MoOMMMmoOMMM                           ;    Increment [1], then copy [1] to [2]
    MOO                                    ;    Loop while [2] is non-empty
        MOomOomOoMOomoOmoO                 ;        Decrement [0] and [2]
    moo                                    ;    End loop now that [2] is empty
    mOomOoMMMmoOmoOmoOMMM                  ;    Navigate to [0], and copy to [3]
    MOO                                    ;    Perform the next steps only if [3] is non-zero
        OOOmoOMOoMOomOomOomOoMoOMMMmoOMMM  ;        Clear [3], increment [4] twice, increment [1], and copy it to [2]
        MOO                                ;        Loop while [2] is non-empty
            MOomOomOoMoOmoOmoO             ;            Decrement [2] and increment [0]
        moo                                ;        End loop now that [2] is empty
    moO                                    ;        Navigate back to [3]
    moo                                    ;    End the condition
    mOomOomOo                              ;    Navigate back to [0]
moo                                        ;End loop once [0] is empty.
moO                                        ;Navigate to [1]. If [1] is 0, then input was 0.  Otherwise, [4] contains (sign of [0] + 1)
MOO                                        ;Perform the next steps only if [1] is non-zero
    moOmoOmoOMOoMMMOOO                     ;    Navigate to [4], copy it to the register, and clear [4].
moo                                        ;End condition
MMMOOM                                     ;If the register contains something (which is true iff the condition ran), paste it and print it.  Otherwise, no-op and print 0.

मैं अभी भी इसे गोल्फिंग के साथ प्रयोग कर रहा हूं (आप को पता चलेगा कि गाय में गोल्फ खेलना मुश्किल है), इसलिए यह भविष्य में कुछ और बाइट्स घटा सकता है।

— गेब्रियल बेनामी
स्रोत
1
और वहाँ एक 'मू' - भाषा है? ...
— मुकुल कुमार
1
@ मूकुलकुमार यह एक दिमागी व्युत्पत्ति है जिसे गाय कहा जाता है जो कुछ चीजों के लिए अनुमति देता है जो
— बीएफ
इसे "खराब माज" भाषा भी कह सकते हैं। OUT OF MANA!!!
— मैजिक ऑक्टोपस Urn
18

क्यूबिक्स , 10 बाइट्स

(W0^I?>O2@

इसे ऑनलाइन टेस्ट करें!

यह कोड निम्नलिखित क्यूब नेट से लिपटा है:

    ( W
    0 ^
I ? > O 2 @ . .
. . . . . . . .
    . .
    . .

कोड को आईपी (अनुदेश सूचक) के साथ चलाया जाता है I, जो पूर्व की ओर मुंह करके शुरू होता है । ISTDIN से एक हस्ताक्षरित पूर्णांक इनपुट करता है, इसे स्टैक पर धकेलता है।

अगला कमांड है ?, जो शीर्ष आइटम के संकेत के आधार पर आईपी की दिशा बदलता है। यदि इनपुट 0 है, तो यह एक ही दिशा में आगे बढ़ता रहता है, निम्नलिखित कोड के माध्यम से चलता है:

  • >- आईपी को पूर्व की ओर इंगित करें। (नहीं, क्योंकि हम पहले से ही पूर्व की ओर जा रहे हैं।)
  • O - एक पूर्णांक के रूप में शीर्ष आइटम का उत्पादन।
  • 2- स्टैक पर 2 पुश करें। यह व्यावहारिक रूप से एक नो-ऑप है, क्योंकि ...
  • @ - कार्यक्रम को निर्देशित करता है।

यदि इनपुट नकारात्मक है, तो आईपी बाईं ओर मुड़ता है ?; क्योंकि यह एक क्यूब है, आईपी 0दूसरी पंक्ति में चलता है , पूर्व की ओर बढ़ रहा है। 0शाब्दिक 0 को धकेलता है, तो यह कोड चलाया जाता है:

  • ^ - आईपी उत्तर की ओर इशारा करें।
  • W - "साइडस्टेप" आईपी एक बाईं ओर स्थित है।
  • ( - शीर्ष मद में कमी।

टीओएस अब है -1, और आईपी क्यूब के चारों ओर नो-ऑप्स के झुंड के माध्यम से लपेटता है .जब तक कि यह हिट न हो जाए >। यह वही आउटपुट कोड चलाता है जो ऊपर उल्लेख किया गया है, आउटपुट -1।

यदि इनपुट सकारात्मक है, तो नकारात्मक अपवादों के साथ भी ऐसा ही होता है, एक अपवाद के साथ: आईपी बाईं ओर दाईं ओर मुड़ता है ?, और क्यूब के चारों ओर लपेटता है 2, जो एक शाब्दिक 2 को धकेलता है। यह तब 1 तक घटाया जाता है। आउटपुट पर भेजा गया।

— ETHproductions
स्रोत
4
कार्यक्रम प्रवाह का एनीमेशन बहुत अच्छा है!
— लुइस मेंडू
अच्छी भाषा है। क्या यह कम हो सकता है? 4 प्रवाह नियंत्रण ज्यादा लगता है। ऑपरेशन-गिनती में यह एक और शुरू करने से 8 बाइट्स हो सकता है?, लेकिन अब यह क्यूब के निचले आधे हिस्से का उपयोग करता है: .. 1 एनआई? ..> ओ @ .........
— ब्लैकशिफ्ट
छह संभव है यदि हम पहले के बाद आउटपुट को अनदेखा करते हैं: / I? NO1 वैसे, यह केवल इसलिए काम करता है क्योंकि मैं कल्पना के अनुसार 0 के बजाय ऑनलाइन दुभाषिया में -1 लौटाता हूं।
— ब्लैकशिफ्ट
@BlackShift आपकी रुचि के लिए धन्यवाद! मुझे आपके सुझाव पसंद हैं, लेकिन मुझे यकीन नहीं है कि उन्हें कैसे सुधारें। कम निर्देशों का उपयोग करना निश्चित रूप से संभव है; मुश्किल हिस्सा घन का कम उपयोग कर रहा है ... ;-) और उस -1 बग को इंगित करने के लिए धन्यवाद, मैं जल्द ही इसे ठीक करवाऊंगा।
— ETHproductions 3
@ETHproductions IMO यह बग नहीं है, यह I-1 रिटर्न के लिए समझ में आता है जब इनपुट लोअरकेस की तरह ही समाप्त हो जाता iहै।
— फ्लिपकैक
16

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

Math.sign

सीधा।

सबसे छोटा गैर निर्मित 13 बाइट्स है:

n=>n>0|-(n<0)

@ निएल के लिए धन्यवाद, यह एक बाइट द्वारा गोल्फ हो सकता है, लेकिन केवल 32-बिट पूर्णांक पर काम करने की कीमत पर:

n=>n>0|n>>31

या आप कर सकते थे

n=>n>0?1:!n-1

जो अधिक गोल्फ लगता है, लेकिन मुझे यकीन नहीं है कि कैसे।

— ETHproductions
स्रोत
2
32-बिट पर हस्ताक्षर किए पूर्णांक के लिए 12 बाइट्स में गैर-निर्मित n: n=>n>>31|!!n।
— नील
@ नील n>>31वास्तव में स्मार्ट है, धन्यवाद!
— ETHproductions 15
मुझे नहीं लगता कि तीसरा समाधान वैध है, क्योंकि जावास्क्रिप्ट में न्यूमेरिक्स के लिए डबल-सटीक फ्लोट्स का उपयोग किया जाता है। लेकिन मुझसे गलती हो सकती है।
— मेघ
@ मेगो आप सही हैं। मैंने इसे पोस्ट में स्पष्ट किया है।
— ETHproductions
1
@Mego क्षमा करें, मैं आपकी टिप्पणी से चूक गया। बिटवाइज़ ऑपरेटरों का उपयोग करते समय, जेएस ने अपने ऑपरेटरों को 32-बिट पूर्णांक पर हस्ताक्षर करने के लिए प्रेरित किया, इसलिए तीसरा समाधान काम करता है, लेकिन केवल संख्या -2147483648 से 2147483647 पर।
— ETHproductions
15

APL (Dyalog APL) , 1 बाइट

जटिल संख्याओं के लिए भी काम करता है, 1∠ लौटने θ :

×

TryAPL ऑनलाइन!

बिना बिल्ट-इन के, पूर्णांक के लिए (ओपी के अनुसार):

¯1⌈1⌊⊢

¯1⌈ सबसे नकारात्मक एक और

1⌊ सबसे छोटा और

⊢ बहस

TryAPL ऑनलाइन!

... और एक सामान्य:

>∘0-<∘0

>∘0 अधिक से अधिक शून्य

- ऋण

<∘0 से कम शून्य

TryAPL ऑनलाइन!

— एडम
स्रोत
1
आपने वास्तव में इसे वन बाइट में किया था ... आप सर, एक किंवदंती हैं। मुझे यकीन है कि जॉन स्कीट को गर्व होगा।
@Mango आप मजाक कर रहे हैं, है ना? इस चुनौती के लिए एक मुट्ठी भर बाइट के जवाब हैं।
— आदम डे
1
मैं व्यंग्यात्मक हो रहा था, मैंने यह भी कहा क्योंकि यह पहला एकल बाइट उत्तर है जिसे मैंने देखा।
14

> <> , ९ < बाइट्स

एक बाइट को बचाने के लिए Sp3000 के लिए धन्यवाद।

'i$-%n/

0x01इससे पहले एक अप्राप्य है /।

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

व्याख्या

यह मेरे चरित्र कोड-आधारित भूलभुलैया उत्तर का एक बंदरगाह है ।

'     Push the entire program (except ' itself) onto the stack, which ends 
      with [... 1 47].
i     Read the first character of the input.
$-    Subtract the 47.
%     Take the 1 modulo this value.
n     Output the result as an integer.
0x01  Unknown command, terminates the program.
— मार्टिन एंडर
स्रोत
मुझे लगता है कि आप प्रोग्राम को सही ढंग से समाप्त करने के लिए ;0x01
— उस अनपेक्षित के
@EriktheOutgolfer मुझे वैसे भी 0x01पुश करने की आवश्यकता 1है।
— मार्टिन एंडर
2
ओह, ऐसा लगता है कि मैंने केवल अपने सुझाव के साथ परीक्षण किया है 123। सबक सीखा: अधिक मामलों के साथ परीक्षण।
— आउटगोल्फ
14

विम, 22 बाइट्स

xVp:s/-/-1^M:s/[1-9]/1^M

@DJMcMayhem को एक बाइट धन्यवाद दिया !

यहाँ, ^Mएक शाब्दिक न्यूलाइन है।

जैसा कि @ nmjcman101 ने टिप्पणियों में बताया है, :s/\v(-)=[^0].*/\11^Mइसके बजाय एक एकल रेगेक्स ( , 20 बाइट्स) का उपयोग किया जा सकता है , लेकिन चूंकि यह मूल रूप से रेटिना के उत्तर के समान है, इसलिए मैं अपनी विधि से चिपका रहा हूं।

स्पष्टीकरण:

xVp                        Delete everything except the first character. If the number is negative, this leaves a -, a positive leaves any number between 1 and 9, and 0 leaves 0.
   :s/-/-1^M               Replace a - with a -1
            :s/[1-9]/1^M   Replace any number between 1 and 9 with 1.

यह एक नकारात्मक संख्या (पुराने संस्करण) के साथ चल रहा है:

नकारात्मक के साथ चल रहा है

यहाँ यह 0 के साथ चल रहा है:

शून्य के साथ चल रहा है

सकारात्मक के साथ चल रहा है:

सकारात्मक के साथ चल रहा है

— Loovjo
स्रोत
1
मैं वास्तव में आपके तरीके को पसंद करता हूं, लेकिन यह एक एकल रेगेक्स में संभव है::s/\v(-)=[^0].*/\11
— nmjcman101
कंसोल कंसोल GIF ... ??
— डेस्टी
12

///, 52 36 बाइट्स

/a/\/1\/\///2a3a4a5a6a7a8a9a10a11/1/

असंबद्ध, स्पष्टीकरण:

/2/1/
/3/1/
/4/1/
/5/1/
/6/1/
/7/1/
/8/1/
/9/1/
/10/1/
/11/1/

यह मूल रूप से एक MapReduce implemenatation है, यानी दो चरण हैं:

  • अंक की सभी घटनाओं की जगह 2- 9द्वारा 1, जैसे 1230405->1110101
  • के जोड़े को कम 11या 10करने के लिए 1बार-बार, जैसे 1110101->1

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

अपडेट: मार्टिन एंडर को धन्यवाद के //1/साथ अलियासिंग करके अतिरिक्त 16 बाइट्स बचाएं a।

परीक्षण मामलों के साथ, इसे ऑनलाइन आज़माएं

— सेड्रिक रीचेनबैक
स्रोत
2
यह अत्यंत चतुर है!
— मेघ
11

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

lambda n:cmp(n,0)

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

— डेनिस
स्रोत
5
ओह, आप मुझे निंजा चाहेंगे।
— जोनाथन एलन
1
ओह। क्षमा करें ...
— डेनिस
5
बहुत बुरा आप नहीं कर सकते (0).__rcmp__...
— Sp3000
1
आप -(0).__cmp__हालांकि कर सकते हैं ।
— nyuszika7h
1
@ nyuszika7h काफी नहीं। एक फ़ंक्शन के रूप में इसका उपयोग करने की कोशिश करना एक TypeError को बढ़ाता है ।
— डेनिस
11

भूलभुलैया , 10 बाइट्स

?:+:)%:(%!

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

व्याख्या

भूलभुलैया का नियंत्रण प्रवाह शब्दार्थ वास्तव में आपको एक नंबर के संकेत को निर्धारित करने के लिए एक "मुक्त" तरीका देता है, क्योंकि 3-तरफ़ा कांटा पर चुना गया रास्ता इस बात पर निर्भर करता है कि संकेत नकारात्मक, शून्य या सकारात्मक है। हालाँकि, मैं अब तक 12 बाइट्स से कम के जंक्शन के साथ एक कार्यक्रम को फिट नहीं कर पाया हूं (हालांकि यह संभव हो सकता है)।

इसके बजाय, यहाँ एक बंद-रूप समाधान है, जिसे किसी भी शाखा की आवश्यकता नहीं है:

Code    Comment             Example -5      Example 0       Example 5
?       Read input.         [-5]            [0]             [5]
:+      Double.             [-10]           [0]             [10]
:)      Copy, increment.    [-10 -9]        [0 1]           [10 11]
%       Modulo.             [-1]            [0]             [10]
:(      Copy, decrement.    [-1 -2]         [0 -1]          [10 9]
%       Modulo.             [-1]            [0]             [1]
!       Print.              []              []              []

इंस्ट्रक्टर पॉइंटर फिर एक मृत अंत को हिट करता है, चारों ओर मुड़ता है और समाप्त होता है जब %अब शून्य से विभाजन का प्रयास करता है।

इनपुट दोहरीकरण आदानों के साथ इस काम करने के लिए आवश्यक है 1और -1, नहीं तो दो सापेक्ष संचालन में से एक पहले से ही शून्य से एक प्रभाग का प्रयास करेगी।

— मार्टिन एंडर
स्रोत
1
आपका कोड खुश है और उदास हो जाता है:D
— स्टीफन
2
अगर आप चाहें तो @Stefan ऑर्डर बदल सकते हैं। ;)
— मार्टिन एंडर
9

PHP, 16 बाइट्स

नए स्पेसशिप ऑपरेटर का उपयोग करता है।

<?=$argv[1]<=>0;
— एलेक्स हॉन्सस्की
स्रोत
यह बताना न भूलें कि यह केवल PHP7 का उत्तर है। और जब से आप उपयोग कर रहे हैं <?=, आपको उपयोग करना चाहिए $_GET[n], जो किसी भी अधिक बाइट को नहीं लेता है। उपयोग करने के लिए <?=, आपको एक वेबसर्वर (अपाचे की तरह) के अंदर होना चाहिए, और वहां आपकी पहुंच नहीं होगी $argv। आप <?php var_dump($argv);अपाचे के माध्यम से एक PHP फ़ाइल से चलाने की कोशिश कर सकते हैं , और यह दिखाएगा NULL।
— इस्माईल मिगुएल
1
"उपयोग करने के लिए <? =, आपको एक वेबसर्वर (अपाचे की तरह) के अंदर रहने की आवश्यकता है," नहीं। <?=कमांड लाइन से ऑपरेटर ठीक काम करता है।
— एलेक्स हॉवान्स्की
दौड़कर php -r '<?=1'मुझे मिलता है PHP Parse error: syntax error, unexpected '<' in Command line code on line 1। लेकिन एक फ़ाइल से ठीक काम करने लगता है। मुझे लगता है की आप सही हो।
— इस्माईल मिगुएल
-rध्वज के लिए कोड स्निपेट को चलाने के लिए है। यह पूर्ण स्रोत है। इसे एक फ़ाइल में सहेजें और फिर चलाएंphp file.php
— एलेक्स हॉवान्स्की
मुझे लगा कि यह पहले से ही है। मैं वास्तव में नहीं जानता था कि यह (अंतर्निहित) -fपैरामीटर का उपयोग करके एक फ़ाइल से काम करता है।
— इस्माईल मिगुएल
9

ब्रेन-फ्लैक 74 42 40 बाइट्स

1000000000 के लिए धन्यवाद 2 बाइट्स बचा लिया

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

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

स्पष्टीकरण:

{                                }       # if 0 do nothing
   (          )                          # push:                           
    {}<     >                            # the input, after 
       (    )                            # pushing:
        [  ]                             # negative:
         ()                              # 1

 (                    )                  # Then push:
  [            ]                         # the negative of the input
                <>                       # on the other stack with:
                   ()                    # a 1 
                  (  )                   # pushed under it

                       {        }        # while 1: 
                        ({}())           # increment this stack and...
                              <>         # switch stacks

                                 {}      # pop the top (the counter or 0 from input)
                                   (  )  # push:
                                    {}   # the top (this is a no-op, or pushes a 0)
— रिले
स्रोत
— गेहूं जादूगर
आप शून्य मोनाद को निकालकर 2 बाइट्स बचा सकते हैं(())
— 0 '
8

सी, 24 20 19 18 बाइट्स

मैं इसे नीचे गोल्फ के लिए दो सी शोषण का दुरुपयोग करता हूं; यह C (GCC) में है।

f(a){a=a>0?:-!!a;}

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

संशोधन इतिहास:

1) f(a){return(a>0)-(a<0);}// 24 बाइट्स

2) f(a){a=(a>0)-(a<0);}// 20 बाइट्स

3) f(a){a=a>0?:-1+!a;}// 19 बाइट्स

4) f(a){a=a>0?:-!!a;}// 18 बाइट्स

संशोधन 1: पहला प्रयास। सरल तर्क

संशोधन 2: जीसीसी में एक मेमोरी / स्टैक बग का दुरुपयोग करता है , जहां तक ​​मैं बता सकता हूं, एक गैर-रिटर्न फ़ंक्शन कुछ मामलों में अंतिम सेट चर वापस कर देगा।

संशोधन 3: तिर्यक व्यवहार का दुरुपयोग करता है जहां अपरिभाषित परिणाम सशर्त परिणाम लौटाएगा (यही कारण है कि मेरी त्रैमासिक पर सही वापसी शून्य है)

संशोधन 4: संशोधन 2 में संदर्भित के !!लिए टर्नरी सशर्त प्रतिस्थापन से एक बूल कास्ट ( ) घटाएं nil।

— अल्बर्ट रेनशॉ
स्रोत
7

रूबी, 10 बाइट्स

->x{x<=>0}
— जीबी
स्रोत
चाहेंगे 0.<=>भी काम करते हैं, या आपको लगता है कि रूबी में की तरह के तरीकों को संदर्भित नहीं कर सकते हैं?
— निक हार्टले
.<=>1 तर्क की उम्मीद है, इसलिए यह खत्म हो जाएगा 0.<=> x, जो लंबा है।
— सिम्स
@QPaysTaxes आप की आवश्यकता होगी 0.method:<=>क्योंकि माणिक में विधि कॉल कोष्ठक का उपयोग नहीं करते हैं और 0.<=>बहुत कम तर्कों के साथ विधि कॉल के रूप में व्याख्या की जाएगी।
— साइओस
7

पर्ल, 9 बाइट्स

आवश्यक -Eकोई अतिरिक्त कीमत पर।

say<><=>0

प्रयोग

perl -E 'say<><=>0' <<< -9999
-1
perl -E 'say<><=>0' <<< 9999
1
perl -E 'say<><=>0' <<< -0
0

मैं मछली ऑपरेटर के साथ खुश हूँ!

— डोम हेस्टिंग्स
स्रोत
1
यह वास्तव में "आवश्यकता" नहीं है -E, यह केवल तभी है जब आप इसे एक फ़ाइल के बजाय सीएलआई से कॉल करते हैं, यही कारण है कि मुझे लगता है कि आपने कोई अतिरिक्त लागत नहीं कहा है।
— nyuszika7h
@ nyuszika7h वास्तव में, मुझे इस तरह से अनुमान लगाने की आवश्यकता है कि परीक्षण से -eकाम नहीं चलेगा, लेकिन -Eअब की तुलना में स्वीकार नहीं किया जाता है -e। मेटा पर सर्वसम्मति के अनुसार। मुझे आशा है कि इससे थोड़ी सहायता मिली होगी!
— डोम हेस्टिंग्स
हाँ, मैं सुझाव नहीं दे रहा था कि इसके लिए किसी अतिरिक्त लागत की आवश्यकता है, क्योंकि यह ठीक काम करता है जब उस स्क्रिप्ट को फ़ाइल से सामान्य रूप से निष्पादित किया जाता है।
— nyuszika7h
7

स्टैक कैट्स , 6 + 4 = 10 बाइट्स

_[:I!:

​ -nmझंडे के लिए +4 बाइट्स । nसंख्यात्मक I / O के लिए है, और चूंकि स्टैक कैट्स को पैलंड्रोमिक होने के लिए कार्यक्रमों की आवश्यकता होती है, mजो मूल स्रोत को देने के लिए स्रोत कोड को स्पष्ट रूप से प्रतिबिंबित करता है।

_[:I!:!I:]_

इसे ऑनलाइन आज़माएं! मूल रूप से सभी अच्छे स्टैक कैट्स गोल्फ के साथ, यह ब्रूट बल द्वारा पाया गया था, एक लंबे शॉट द्वारा किसी भी मैनुअल प्रयास को हराया, और आसानी से एक बड़े कार्यक्रम में शामिल नहीं किया जा सकता है।

Dयदि आप चरण-दर-चरण प्रोग्राम ट्रेस देखना चाहते हैं, तो एक ध्वज जोड़ें , यानी -nmDSTDERR / डीबग के साथ चलाएँ और जांचें।

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

यहाँ प्रासंगिक आदेश हैं:

_           Perform subtraction [... y x] -> [... y y-x], where x is top of stack
[           Move left one stack, taking top of stack with you
]           Move right one stack, taking top of stack with you
:           Swap top two of stack
I           Perform [ if top is negative, ] if positive or don't move if zero. Then
                negate the top of stack.
!           Bitwise negate top of stack (n -> -n-1)

ध्यान दें कि ये सभी कमांड उलटे हैं, इसके उलटा कमांड का दर्पण है। यह स्टैक कैट्स का आधार है - सभी नॉनट्रिविअल टर्मिनेटिंग प्रोग्राम विषम लंबाई के होते हैं, यहां तक ​​कि लंबाई प्रोग्राम स्वयं-रद्द भी करते हैं।

हम साथ शुरू करते हैं

               v
               n
              -1
...  0    0    0    0    0  ...

_घटाना, शीर्ष बनाना -1-n, और [एक स्टैक छोड़ दिया परिणाम को स्थानांतरित करता है:

           v
       -1-n   -1
...  0    0    0    0    0  ...

:शीर्ष दो स्वैप Iकरता है और कुछ नहीं करता है, क्योंकि स्टैक के शीर्ष अब शून्य है। !तब बिटवाइज़ शीर्ष शून्य को एक में बदल देता है -1और :शीर्ष दो को वापस स्वैप करता है। !फिर बिटवाइस शीर्ष को नकारता है, फिर से -1-nवापस मुड़ता है n:

          v
          n
         -1   -1
...  0    0    0    0    0  ...

अब हम उस शाखा पर आधारित हैं I, जो हमारे मूल पर लागू होती है n:

  • यदि nनकारात्मक है, तो हम बाईं ओर एक स्टैक को स्थानांतरित करते हैं और -nएक अंतर्निहित शून्य पर समाप्त होते हैं । :स्वैप, शीर्ष पर एक शून्य डाल रहा है, और ]शून्य को ऊपर -1ले जाता है हम बस चले गए। _तब घटाता है, अंतिम स्टैक को छोड़ देता है [-1 -1], और केवल एक -1आउटपुट होता है क्योंकि आधार -1को अनदेखा किया जाता है।

  • यदि nशून्य है, तो हम नहीं चलते हैं और ऊपर की ओर :स्वैप करते हैं -1। ]इसके बाद इसे दाएं के -1ऊपर छोड़ता है -1, और _घटाता है, अंतिम स्टैक को छोड़ता है [-1 0], जैसे कि शून्य को आउटपुट करना और आधार की अनदेखी करना -1।

  • यदि nसकारात्मक है, तो हम सही एक स्टैक को स्थानांतरित करते हैं और -nएक पर समाप्त होते हैं -1। :स्वैप, -1शीर्ष पर रख रहा है , और ]इस -1अधिकार को एक निहित शून्य के शीर्ष पर ले जाता है। _फिर 0 - (-1) = 1अंतिम स्टैक को घटाता है, देता है और छोड़ता है [1], जो आउटपुट है।

— Sp3000
स्रोत
7

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

median({1,Ans,~1

वैकल्पिक समाधान (अधिक सुझाव देने के लिए स्वतंत्र महसूस करें):

max(~1,min(Ans,1               8  bytes
0:If Ans:Ans/abs(Ans           9  bytes
(Ans>0)-(Ans<0                 10 bytes
— Timtech
स्रोत
क्या ~माना जाता है?
— कॉनर ओ'ब्रायन
@ ConorO'Brien नेगेटिव सिंबल, TI-Basic के घटाव सिंबल में अंतर करने के लिए। मुझे पता है कि Cemetech SC ~इस टोकन का प्रतिनिधित्व करने के लिए भी उपयोग करता है।
— टाइमटेक
ओह बढ़िया। मुझे पता नहीं था।
— कॉनर ओ'ब्रायन
@ ConorO'Brien ठीक है, अब आप जानते हैं। पूछने के लिए धन्यवाद :)
— 22
1
यह मान्य नहीं है - इनपुट के रूप में उपयोगAns करना वैध डिफ़ॉल्ट I / O विधि के मानदंड को पूरा नहीं करता है (इसमें दो बार के रूप में कई डाउनवोट्स नहीं हैं - वर्तमान में यह + 19 / -12 पर है)।
— मेघ
7

MATL , 6 बाइट्स

0>EGg-

इनपुट एक संख्या या एक सरणी हो सकती है। परिणाम संख्या या इसी मान के साथ एक सरणी है।

इसे ऑनलाइन आज़माएं! या कई मामलों का परीक्षण करें सरणी इनपुट का उपयोग करके का ।

व्याख्या

यह बिलिन साइन फ़ंक्शन ( ZS) का उपयोग करने से बचता है ।

0>   % Take input implicitly. Push 1 if positive, 0 otherwise
E    % Multiply by 2
Gg   % Push input converted to logical: 1 if nonzero, 0 otherwise
-    % Subtract. Implicitly display
— लुइस मेंडो
स्रोत
MATL, मैटलैब और ऑक्टेव से अधिक लंबा है ! "
— आदम डे
4
वह उत्तर में भी निर्मित का उपयोग कर सकता था ZS।
— स्टीवी ग्रिफिन
6

जेली , 1 बाइट

Ṡ

TryItOnline!

मोनाडिक साइन परमाणु , Ṡपूर्णांक इनपुट के लिए, या तो एक पूर्ण प्रोग्राम के रूप में या एक मोनडिक लिंक (एक तर्क लेने वाले फ़ंक्शन) के रूप में निर्दिष्ट करता है।

— जोनाथन एलन
स्रोत
6

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

Sign

ठीक वह जो यह टिन पर कहता है

— ग्रेग मार्टिन
स्रोत
एक बाइट को सहेजेंsgn
— Adám
3
वोल्फ्रामअल्फा, मैथमैटिक के समान नहीं है; इसमें अस्पष्ट / प्राकृतिक भाषा इनपुट की स्वचालित व्याख्या शामिल है।
— ग्रेग मार्टिन
तो मुझे यह एक अलग जवाब प्रस्तुत करना चाहिए?
— अड्मण
मुझे उचित लगता है ...
— ग्रेग मार्टिन
6

ऑक्टेव, 26 24 बाइट्स

f=@(x)real(asin(x))/pi*2

यह मेरा पहला कोड-गोल्फ ऑक्टेव उत्तर है, किसी भी गोल्फिंग टिप्स की सराहना की जाती है!

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

asinसवाल से आता है जहां यह कहते हैं के लिए विचार output the sign:)

व्याख्या

नोट: संख्या को विभाजित करके piऔर इसे गुणा 2करके, संपूर्ण संख्या को विभाजित करने के बराबर हैpi/2

मामला 0:

asin(0)पैदावार 0। इसका वास्तविक हिस्सा लेना और इसे विभाजित pi/2करने से आउटपुट पर कोई फर्क नहीं पड़ता।

मामला positive:

asin(1)पैदावार pi/2। asinकिसी भी नंबर से बड़े के 1दे देंगे pi/2+ जटिल संख्या। इसका वास्तविक हिस्सा लेता है pi/2और देता है और इसे विभाजित करता pi/2है1

मामला negative:

asin(-1)पैदावार -pi/2। asinकिसी भी संख्या से छोटी संख्या + जटिल संख्या -1देगी -pi/2। इसका वास्तविक हिस्सा लेता है -pi/2और देता है और इसे विभाजित करता pi/2है-1

— क्रिकटी लिथोस
स्रोत
@LuisMendo N will be an integerमैं भाग्यशाली हूँ कि यह सवाल में :)
— Kritii Lithos
ओह, मैंने वह हिस्सा नहीं पढ़ा था :)
— लुइस मेंडो
1
सी एल ई वी ई आर!
— flawr
आपको इसकी आवश्यकता नहीं है f=यदि बाकी एक वैध, गैर-पुनरावर्ती फ़ंक्शन अभिव्यक्ति है।
— Cyoce
@Cyoce क्षमा करें, लेकिन मैं अनाम कार्यों को पसंद नहीं करता
— Kritii Lithos
6

दरअसल , 1 बाइट

s

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

टिन पर जो कहता है, उसका एक और मामला है - sसाइन फंक्शन।

बिलिन के बिना (4 बाइट्स):

;A\+

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

;A\इनपुट द्वारा इनपुट के निरपेक्ष मान को विभाजित करता है। यह -1नकारात्मक इनपुट के लिए और 1सकारात्मक इनपुट के लिए परिणाम है। दुर्भाग्य से, वास्तव में त्रुटि से निपटने के कारण (यदि कुछ गलत होता है, तो कमांड को अनदेखा किया जाता है), 0चूंकि इनपुट 0स्टैक पर दो एस छोड़ता है । +उन्हें जोड़कर इसे ठीक करता है (जो किसी और चीज के साथ त्रुटि का कारण बनता है, इसलिए इसे अनदेखा किया जाता है)।

— मेगो
स्रोत
6

पीट, 188 53 46 41 बाइट्स

5bpjhbttttfttatraaearfjearoaearbcatsdcclq

ऑनलाइन दुभाषिया यहाँ उपलब्ध है।

यह पिटी कोड मानक करता है (n>0)-(n<0), क्योंकि इसमें साइन चेकिंग बिलिन नहीं है। वास्तव में, कोई कम से कम निर्मित नहीं है, इसलिए इस पद्धति का अधिक सटीक वर्णन होगा (n>0)-(0>n)।

ऊपर का पाठ छवि को दर्शाता है। आप दुभाषिया पृष्ठ पर पाठ बॉक्स में चिपकाकर छवि उत्पन्न कर सकते हैं। सुविधा के लिए मैंने नीचे की छवि प्रदान की है जहां कोडल का आकार 31 पिक्सेल है। ग्रिड पठनीयता के लिए है और कार्यक्रम का हिस्सा नहीं है। यह भी ध्यान दें कि यह कार्यक्रम किसी भी सफेद कोडल को पार नहीं करता है; कार्यक्रम प्रवाह का पालन करने के लिए छवि की सीमा के चारों ओर रंगीन कोडेल का पालन करें।

व्याख्या

कार्यक्रम

Instruction    Δ Hue   Δ Lightness   Stack
------------   -----   -----------   --------------------
In (Number)    4       2             n
Duplicate      4       0             n, n
Push [1]       0       1             1, n, n
Duplicate      4       0             1, 1, in, in
Subtract       1       1             0, in, in
Duplicate      4       0             0, 0, in, in
Push [4]       0       1             4, 0, 0, in, in
Push [1]       0       1             1, 4, 0, 0, in, in
Roll           4       1             0, in, in, 0
Greater        3       0             greater, in, 0
Push [3]       0       1             3, greater, in, 0
Push [1]       0       1             1, 3, greater, in, 0
Roll           4       1             in, 0, greater
Greater        3       0             less, greater
Subtract       1       1             sign
Out (Number)   5       1             [Empty]
[Exit]         [N/A]   [N/A]         [Empty]

किसी भी आगे की फाइल को कम करने के लिए, मुझे वास्तव में प्रोग्राम (हांफना) को बदलना होगाफ़ाइलों को में फ़ाइल को संपीड़ित करने के बजाय कि मैं कर रहा हूं। मैं एक पंक्ति को हटाना चाहूंगा जो इसे 36 तक नीचे पहुंचा देगा। मैं अपने स्वयं के दुभाषिया भी विकसित कर सकता हूं जिसमें बहुत छोटा इनपुट प्रारूप होगा, क्योंकि वास्तव में कोड को बदलने से यह छोटा हो जाता है जो कोड गोल्फ के बारे में नहीं है।

मॉड्स ने मुझे बताया कि समग्र फ़ाइलिज़ वह है जो पीट कोड के लिए मायने रखता है। जैसा कि दुभाषिया पाठ को मान्य इनपुट के रूप में स्वीकार करता है और कच्चे पाठ में किसी भी छवि की तुलना में बहुत छोटी बाइट गिनती होती है, पाठ स्पष्ट विकल्प होता है। मैं इस बारे में चुटीले होने के लिए माफी मांगता हूं लेकिन मैं नियम नहीं बनाता। मेटा चर्चा बारे में इस मामले पर मेरी राय स्पष्ट करती है।

अगर आपको लगता है कि पीट की भावना के खिलाफ जाता है या किसी भी कारण से इस पर चर्चा करना चाहते हैं, तो कृपया मेटा पर चर्चा की जाँच करें ।

— माइक बुफ़र्डेकी
स्रोत
2
मेरा मानना ​​है कि पीट के लिए सम्मेलन सभी कोडल्स को गिनना है ।
— सुपरजेडि २२२४
@ SuperJedi224 वह नहीं है जो मेटा पोस्ट में तय किया गया था, यह छवि में बाइट्स की संख्या की तरह दिखता है जो मैं जा रहा हूं।
— माइक ब्यूफेरेसी 14
6

pushy , 7 बाइट्स

यह शायद सबसे अजीब दिखने वाला कार्यक्रम है जो मैंने कभी लिखा है ...

&?&|/;#

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

यह उपयोग करता है sign(x) = abs(x) / x, लेकिन एक स्पष्ट के साथsign(0) = 0 शून्य विभाजन त्रुटि से बचने के लिए से।

          \ Take implicit input
&?   ;    \ If the input is True (not 0):
  &|      \  Push its absolute value
    /     \  Divide
      #   \ Output TOS (the sign)

यह काम करता है क्योंकि x / abs(x)है 1 जब एक्स सकारात्मक है और -1 जब एक्स नकारात्मक है। यदि इनपुट 0 है, तो प्रोग्राम आउटपुट कमांड पर कूदता है।

4 बाइट्स (गैर-प्रतिस्पर्धात्मक)

छुट्टियों के कारण और बहुत अधिक समय होने के कारण, मैंने पुसी दुभाषिया का पूरा पुनर्लेखन किया है। उपरोक्त कार्यक्रम अभी भी काम करता है, लेकिन क्योंकि 0 / 0अब 0 में डिफ़ॉल्ट है, निम्नलिखित कम है:

&|/#

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

— FlipTack
स्रोत
1
मैं भी उपयोग करने के बारे में सोच रहा था abs, लेकिन पता नहीं था कि क्या करना है 0। बहुत बढ़िया!
— कृतिका लिथोस
5

आर, 25 बाइट्स

'if'(x<-scan(),x/abs(x),0)

नंबर को STDIN में ले जाता है। फिर जांचता है कि क्या यह शून्य है, यदि नहीं, तो रिटर्न x/|x|जो या तो 1है -1, और आउटपुट 0 यदिx=0 ।

यह बिल्ट signकोर्स का उपयोग किए बिना है ।

— JAD
स्रोत
1
बिलिन का उपयोग करना बेशक कम है, लेकिन कम मज़ेदार है sign(scan()):।
— बिलीवोब
क्षमा करें, बिल्व से बचने का स्पष्ट रूप से उल्लेख करना चाहिए
— JAD
5

वी 14 12 बाइट्स

2 बाइट्स के लिए @DJMcMayhem धन्यवाद। प्रतिस्थापन करने के लिए एक रेग-पूर्व का उपयोग करता है। मज़े की तरह, क्योंकि यह बिल्ट-इन नहीं है। मेरे पास एक और मजेदार फ़ंक्शन है, लेकिन यह उस तरह से काम नहीं कर रहा है जैसी मुझे उम्मीद थी।

ͨ-©½0]/±1

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

यह सिर्फ अनुवाद करता है, :%s/\v(-)=[^0].*/\11जो कि किसी एक या अधिक से मेल खाता है -, लेकिन 0, इसके बाद किसी भी संख्या में। इसे पहले मैच (इसलिए या तो -कुछ नहीं) और ए के साथ बदल दिया गया है 1। रेगेक्स 0 से मेल नहीं खाता है, इसलिए वह खुद रहता है।

द मोर फन वे (21 बाइट्स)

é
Àé12|DkJòhé-òó^$/a

TryItOnline

यह इनपुट को बफर के बजाय एक तर्क के रूप में स्वीकार करता है।

é<CR> एक नई लाइन डालें।

Àतर्क को V कोड के रूप में चलाएं। ए- , कर्सर को पिछली पंक्ति में ले जाएगा, और कोई भी संख्या अगले कमांड के लिए गिनती बन जाएगी

é1 डालें (गणना)1 की

2| दूसरे कॉलम में जाएं

D दूसरे कॉलम से सबकुछ हटा दें (केवल एक वर्ण को छोड़कर)

kJ दोनों लाइनों को एक साथ मिलाएं।

òhé-òअनुवाद करने के लिए: " hé-तोड़ने तक चला "। यदि 1 दूसरी पंक्ति पर था, तो यह एच के तुरंत बाद टूट जाता है। यदि यह पहली पंक्ति पर था, तो यह एक सम्मिलित करेगा- ब्रेकिंग से पहले ।

ó^$/aयह तथ्य यह है कि ठीक करता है -1, 0, 1एक खाली छोड़ देंगे, और तर्क रजिस्टर के साथ एक खाली बदल देता है।

— nmjcman101
स्रोत
मुझे पता था कि मुझे उस पृष्ठ को बेहतर ढंग से पढ़ना चाहिए था। यह वास्तव में छोटा नहीं है - मैं 0 को भूल गया, लेकिन मैं एक तर्क के रूप में संख्या लेने की कोशिश कर रहा था और फिर Àé1। एक सकारात्मक संख्या लोगों की एक स्ट्रिंग देती है, एक नकारात्मक संख्या SHOULD एक स्ट्रिंग को एक पंक्ति देती है, और 0 कुछ भी नहीं देती। नकारात्मक संख्या बिट के साथ काम नहीं किया Àहै, लेकिन किया था के साथd$@"
— nmjcman101
आह। खैर जो कारण काम नहीं करता है क्योंकि इस पर जाने के लिए एक और पंक्ति नहीं है। यदि आप é<cr>इसे जोड़ते हैं तो दो खाली लाइनें होंगी और फिर यह काम करेगा । मुझे यकीन है कि आप उसका प्रयोग एक पूरा जवाब पाने के लिए कर सकते हैं अगर नहीं कर रहा हूँ
— DJMcMayhem
मेरे पास एक और लाइन थी, बस अपनी टिप्पणी में स्पष्ट रूप से यह नहीं कहा। --आपने क्या तर्क जोड़ा है?
— nmjcman101
1
इसका अर्थ है "विकल्पों का अंत"। चूंकि -6एक ध्वज के साथ शुरू होता है, docopt (कमांड लाइन विकल्पों के लिए अजगर पुस्तकालय) सोचता है कि यह एक तर्क के बजाय एक कमांड-लाइन ध्वज है। --सिर्फ संकेत जोड़ना कि यह एक तर्क है विकल्प नहीं। अन्यथा, यह अमान्य कमांड लाइन आह्वान के कारण बिल्कुल नहीं चलेगा।
— DJMcMayhem
5

सी #, 16 15 बाइट्स

बेहतर समाधान नील को धन्यवाद

n=>n>0?1:n>>31;

वैकल्पिक रूप से, अंतर्निहित विधि 1 बाइट लंबी है:

n=>Math.Sign(n);

परीक्षण मामलों के साथ पूरा कार्यक्रम:

using System;

public class P
{
    public static void Main()
    {
        Func<int,int> f =
        n=>n>0?1:n>>31;

        // test cases:
        for (int i=-5; i<= 5; i++)
            Console.WriteLine(i + " -> " + f(i));
    }
}
— adrianmp
स्रोत
2
n>>31इसके बजाय प्रयास करें n<0?-1:0।
— नील
1
यह थोड़ा दुखद है जब बिल्टिन सबसे छोटा समाधान भी नहीं है।
— मेगो
मान लीजिए कि C # को
— क्रिया के
1
क) मुझे नहीं लगता कि आपको लंबोदर की आवश्यकता है ;क्योंकि यह एक अभिव्यक्ति है, न कि एक बयान। बी) होगा Math.Signया Math::Signया कुछ इसी तरह एक वैध प्रस्तुत हो सकता है? यह निश्चित नहीं है कि विशेष हैंडल विधियों में C # कैसे है। मूल रूप से, x = Math.Sign;एक मान्य C # कथन होगा यदि xसही प्रकार से आरंभ किया गया था?
— साइओस
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.