कार्य

एक सकारात्मक पूर्णांक को देखते हुए n, आउटपुट n+1यदि nविषम है, और आउटपुट n-1यदि nहै भी।

इनपुट

एक सकारात्मक पूर्णांक। आप मान सकते हैं कि पूर्णांक भाषा की हैंडलिंग क्षमता के भीतर है।

उत्पादन

एक सकारात्मक पूर्णांक, ऊपर निर्दिष्ट।

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

input output
    1      2
    2      1
    3      4
    4      3
    5      6
    6      5
    7      8
    8      7
  313    314
  314    313

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।

मानक खामियां लागू होती हैं।

संदर्भ

OEIS A103889

code-golf number

— लीक नन
स्रोत

क्या हम इनपुट को एकात्मक मानते हैं?

— कृति लिथोस

2

यह आश्चर्य की बात होगी, बहुत आसान अगर यह कुछ अन्य भाषाओं में आसपास का रास्ता था

— MildlyMilquetoast

3

@ मिस्तफाइगिन्स यह अच्छी तरह से ज्ञात है कि मुझे पूरा यकीन है कि ओपी ने इसे इस तरह बनाया था।

— अर्जन जोहानसन

24

सी, 20 बाइट्स

f(x){return-(-x^1);}

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

— feersum
स्रोत

7

@LeakyNun मैं एक फ़ंक्शन नहीं लिख रहा हूं जिसमें रिटर्न स्टेटमेंट का अभाव है।

— feersum

18

@EriktheOutgolfer नंबर नहीं। नूह-उह। नंबर

— feersum

10

@Sisyphus लेकिन यह कोड-गोल्फ है , और यह मेरे TIO लिंक पर काम करता है, इसलिए यह मान्य है।

— एरिक आउटोलॉफ़र

7

@EriktheOutgolfer मैं जो कह रहा हूं वह यह है कि आपका कथन ("पहले तर्क को बताना रिटर्न स्टेटमेंट के बराबर है") तथ्यात्मक रूप से गलत है। क्या इस तरह के कोड से कुछ परिस्थितियों में काम का जवाब उत्पन्न हो सकता है, यह एक और सवाल है (जिसे मैंने अपनी पहली टिप्पणी में यह कहते हुए संबोधित किया है कि मैं इस तरह के किसी भी कोड को पोस्ट नहीं करने की योजना बना रहा हूं)।

— feersum

8

@EriktheOutgolfer यदि कोई उत्तर कार्यान्वयन के विशिष्ट व्यवहार पर निर्भर करता है, तो उसे कार्यान्वयन को निर्दिष्ट करना चाहिए। यह उत्तर नहीं देता है, इसलिए यह कोड अमान्य होगा।

— साइफस

17

स्टैक कैट्स , 3 + 3 ( `-n`) = 6 बाइट्स

-*-

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

-nसंख्यात्मक इनपुट और आउटपुट के साथ काम करने के लिए ध्वज की आवश्यकता है ।

व्याख्या

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

-   Multiply the input by -1.
*   Toggle the least significant bit of the value (i.e. take it XOR 1).
-   Multiply the result by -1.

इनपुट और आउटपुट प्रोग्राम की शुरुआत और अंत में निहित होते हैं, क्योंकि इनपुट और उत्पादन आउटपुट लेना एक प्रतिवर्ती ऑपरेशन नहीं है, इसलिए वे कमांड नहीं हो सकते हैं।

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

1

क्या झंडे हमेशा अतिरिक्त स्थान के साथ गिने जाते हैं, मुझे नहीं लगता कि मैंने झंडे (जैसे पर्ल) का उपयोग करते हुए अन्य उत्तर देखे हैं? संपादित करें: ओके एनवीएम, प्रासंगिक मेटा पोस्ट मिला । " मैं उन लोगों को चरित्र के अंतर के रूप में गिनता हूं जो उनके बिना सबसे कम समकक्ष आह्वान के लिए गिना जाता है। " ... " perl -nle 'stuff'2 वर्णों से अधिक है perl -e 'stuff', इसलिए यह 2 और वर्णों के लिए गिना जाता है "। तो (space)-nझंडे के बिना 3 बाइट्स अधिक है।

— केविन क्रूज़सेन

@ केविनक्रूजसेन यह इस बात पर निर्भर करता है कि आपको वास्तव में एक सामान्य आह्वान में कितने बाइट्स जोड़ने की आवश्यकता है। पर्ल और कई अन्य उत्पादन भाषाओं में, आप कोड को -e "code"फिर से लागू कर सकते हैं और फिर से पहले अतिरिक्त झंडे सम्मिलित कर सकते हैं e, जैसे -pe "code"। तब -pझंडा केवल एक बाइट है। हालांकि, स्टैक कैट्स के पास ऐसा कोई -eतर्क नहीं है, इसलिए आपको हमेशा <sp>-nकमांड में पूर्ण जोड़ने की आवश्यकता है , और इसलिए यह तीन बाइट्स है।

— मार्टिन एंडर

12

x86 असेंबली, 9 बाइट्स (प्रतिस्पर्धा में प्रवेश के लिए)

हर कोई जो उच्च स्तरीय भाषाओं में इस चुनौती का प्रयास कर रहा है, कच्चे बिट्स में हेरफेर करने का असली मज़ा गायब है । ऐसा करने के तरीकों पर बहुत सारे सूक्ष्म बदलाव हैं, यह पागल है - और सोचने में बहुत मज़ा आता है। यहाँ कुछ समाधान हैं जो मैंने 32-बिट x86 असेंबली भाषा में तैयार किए हैं।

मैं अग्रिम में क्षमा चाहता हूं कि यह विशिष्ट कोड-गोल्फ उत्तर नहीं है। मैं पुनरावृत्ति अनुकूलन (आकार के लिए) की सोचा प्रक्रिया के बारे में बहुत कुछ करने के लिए जा रहा हूँ। उम्मीद है कि यह बड़े दर्शकों के लिए दिलचस्प और शैक्षिक है, लेकिन अगर आप TL हैं, तो DR;

स्पष्ट और कुशल समाधान यह परीक्षण करना है कि क्या मूल्य विषम है या यहां तक कि (जो कम से कम महत्वपूर्ण बिट को देखकर कुशलता से किया जा सकता है), और फिर तदनुसार n + 1 या n accordingly 1 के बीच चयन करें । यह मानते हुए कि इनपुट को ECXरजिस्टर में एक पैरामीटर के रूप में पारित किया गया है , और परिणाम EAXरजिस्टर में वापस आ गया है , हमें निम्नलिखित फ़ंक्शन मिलते हैं:

F6 C1 01  |  test  cl, 1                      ; test last bit to see if odd or even
8D 41 01  |  lea   eax, DWORD PTR [ecx + 1]   ; set EAX to n+1 (without clobbering flags)
8D 49 FF  |  lea   ecx, DWORD PTR [ecx - 1]   ; set ECX to n-1 (without clobbering flags)
0F 44 C1  |  cmovz eax, ecx                   ; move in different result if input was even
C3        |  ret

^{(13 बाइट्स)}

लेकिन कोड-गोल्फ प्रयोजनों के लिए, वे LEAनिर्देश महान नहीं हैं, क्योंकि वे एनकोड करने के लिए 3 बाइट लेते हैं। एक साधारण DECरीमेक ECXबहुत छोटा होगा (केवल एक बाइट), लेकिन यह झंडे को प्रभावित करता है, इसलिए हमें कोड को व्यवस्थित करने के तरीके में थोड़ा चतुर होना होगा। हम डिक्रिप्ट पहले कर सकते हैं , और ऑड / इवन टेस्ट सेकंड में , लेकिन फिर हमें ऑड / इवन टेस्ट के परिणाम को पलटना होगा।

इसके अलावा, हम एक शाखा में सशर्त-चाल अनुदेश को बदल सकते हैं, जो कोड को और अधिक धीरे-धीरे चला सकता है (यह इस बात पर निर्भर करता है कि शाखा कितनी अनुमानित है - यदि इनपुट असमान रूप से और यहां तक कि एक शाखा को वैकल्पिक रूप से वैकल्पिक करता है; पैटर्न, यह तेज़ होगा), जो हमें एक और बाइट बचाएगा।

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

    48     |  dec  eax          ; decrement first
    A8 01  |  test al, 1        ; test last bit to see if odd or even
    75 02  |  jnz  InputWasEven ; (decrement means test result is inverted)
    40     |  inc  eax          ; undo the decrement...
    40     |  inc  eax          ; ...and add 1
  InputWasEven:                 ; (two 1-byte INCs are shorter than one 3-byte ADD with 2)

^{(इनलाइन: 7 बाइट्स; एक फ़ंक्शन के रूप में: 10 बाइट्स)}

लेकिन क्या होगा अगर आप इसे एक समारोह बनाना चाहते हैं? कोई भी मानक कॉलिंग कन्वेंशन मापदंडों को पारित करने के लिए समान रजिस्टर का उपयोग नहीं करता है जैसा कि वह रिटर्न वैल्यू के लिए करता है, इसलिए आपको MOVफ़ंक्शन की शुरुआत या अंत में एक रजिस्टर-रजिस्टर निर्देश जोड़ना होगा । यह गति में लगभग कोई लागत नहीं है, लेकिन यह 2 बाइट्स जोड़ता है। ( RETनिर्देश भी एक बाइट जोड़ता है, और फ़ंक्शन कॉल से बनाने और वापस करने की आवश्यकता के द्वारा शुरू किया गया कुछ ओवरहेड है, जिसका अर्थ है कि यह एक उदाहरण है जहां केवल एक क्लासिक गति होने के बजाय इनलाइनिंग एक गति और आकार दोनों लाभ पैदा करता है। -for-space tradeoff।) सभी में, एक फ़ंक्शन के रूप में लिखा गया है, यह कोड 10 बाइट्स के लिए फुलाता है।

10 बाइट्स में हम और क्या कर सकते हैं? यदि हम प्रदर्शन (कम से कम, पूर्वानुमेय प्रदर्शन) के बारे में बिल्कुल परवाह करते हैं , तो उस शाखा से छुटकारा पाना अच्छा होगा। यहां एक शाखा रहित, बिट-ट्विडलिंग समाधान है जो बाइट्स में समान आकार है। मूल आधार सरल है: हम पिछले बिट को फ्लिप करने के लिए एक बिट वाइज XOR का उपयोग करते हैं, एक विषम मूल्य को एक समरूप में परिवर्तित करते हैं, और इसके विपरीत। लेकिन अजीब इनपुटों के लिए एक niggle है- जो हमें n-1 देता है , जबकि इनपुट्स के लिए भी यह हमें n + 1 देता है - हम जो चाहते हैं उसके ठीक विपरीत। तो, इसे ठीक करने के लिए, हम एक नकारात्मक मूल्य पर ऑपरेशन करते हैं, प्रभावी रूप से साइन को फ्लिप करते हैं।

8B C1     |  mov eax, ecx   ; copy parameter (ECX) to return register (EAX)
          |
F7 D8     |  neg eax        ; two's-complement negation
83 F0 01  |  xor eax, 1     ; XOR last bit to invert odd/even
F7 D8     |  neg eax        ; two's-complement negation
          |
C3        |  ret            ; return from function

^{(इनलाइन: 7 बाइट्स; एक फ़ंक्शन के रूप में: 10 बाइट्स)}

बहुत सुंदर; यह देखना मुश्किल है कि इस पर कैसे सुधार किया जा सकता है। एक बात मेरी आंख को पकड़ती है, हालांकि: उन दो 2-बाइट के NEGनिर्देश। सच कहूँ तो, दो बाइट्स एक साधारण बाइट को एनकोड करने के लिए एक बाइट की तरह लगता है, लेकिन यह निर्देश सेट है जिसके साथ हमें काम करना है। क्या कोई वर्कअराउंड हैं? ज़रूर! यदि हम XOR-2 करते हैं, तो हम दूसरे NEGप्याज को एक INCपुनरावृत्ति से बदल सकते हैं :

8B C1     |  mov eax, ecx
          |
F7 D8     |  neg eax
83 F0 FE  |  xor eax, -2
40        |  inc eax
          |
C3        |  ret

^{(इनलाइन: 6 बाइट्स; एक फ़ंक्शन के रूप में: 9 बाइट्स)}

X86 निर्देश सेट की विषमताओं में से एक बहुउद्देशीय LEAनिर्देश है , जो एक रजिस्टर-रजिस्टर चाल, एक रजिस्टर-रजिस्टर जोड़, एक निरंतर द्वारा ऑफसेट, और सभी को एक निर्देश में स्केल कर सकता है!

8B C1        |  mov eax, ecx
83 E0 01     |  and eax, 1        ; set EAX to 1 if even, or 0 if odd
8D 44 41 FF  |  lea eax, DWORD PTR [ecx + eax*2 - 1]
C3           |  ret

^{(10 बाइट्स)}

ANDनिर्देश उस निर्देश की तरह है जो TESTहमने पहले इस्तेमाल किया था, जिसमें दोनों एक बिटवाइज़-एंड करते हैं और तदनुसार झंडे सेट करते हैं, लेकिन ANDवास्तव में गंतव्य ऑपरेंड को अपडेट करता है। LEAअनुदेश तो 2 से इस मापता है, 1. द्वारा मूल इनपुट मूल्य, और decrements जोड़ता है, तो इनपुट मूल्य अजीब था, इस घटाता 1 - इसे से (2 × 0 1 = -1); यदि इनपुट मान समान था, तो इसमें 1 (2 × 1 - 1 = 1) जोड़ा जाता है।

यह कोड लिखने के लिए एक बहुत तेज़ और कुशल तरीका है, क्योंकि निष्पादन का अधिकांश भाग सामने के अंत में किया जा सकता है, लेकिन यह हमें बाइट्स के तरीके से बहुत अधिक नहीं खरीदता है, क्योंकि किसी कॉम्प्लेक्स को एन्कोड करने में बहुत सारे लगते हैं LEAअनुदेश। यह संस्करण इनलाइन उद्देश्यों के लिए भी काम नहीं करता है, क्योंकि इसके लिए आवश्यक है कि मूल इनपुट मूल्य को LEAनिर्देश के इनपुट के रूप में संरक्षित किया जाए । इसलिए इस अंतिम अनुकूलन प्रयास के साथ, हम वास्तव में पीछे की ओर चले गए हैं, यह सुझाव देते हुए कि इसे रोकने का समय आ सकता है।

इस प्रकार, अंतिम प्रतिस्पर्धी प्रविष्टि के लिए, हमारे पास एक 9-बाइट फ़ंक्शन है जो ECXरजिस्टर में इनपुट मान ( 32-बिट x86 पर एक अर्ध-मानक रजिस्टर-आधारित कॉलिंग कन्वेंशन ) लेता है , और EAXरजिस्टर में परिणाम देता है (जैसा कि) सभी x86 कॉलिंग कन्वेंशन):

           SwapParity PROC
8B C1         mov eax, ecx
F7 D8         neg eax
83 F0 FE      xor eax, -2
40            inc eax
C3            ret
           SwapParity ENDP

MASM के साथ इकट्ठा होने के लिए तैयार; C से कॉल करें:

extern int __fastcall SwapParity(int value);                 // MSVC
extern int __attribute__((fastcall)) SwapParity(int value);  // GNU

— कोडी ग्रे
स्रोत

बस dec eax; xor eax, 1; inc eaxकाम नहीं करेगा और एक बाइट अधिक बचा सकता है?

— इल्मरी करोनें

11

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

-*ạ

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

स्यूडोकोड: abs((-1)**n - n)

— लीक नन
स्रोत

मैं वास्तव में (ab) उपयोग की योजना बना रहा था -1।

— आउटगॉल्फ

उसके लिए खेद है।

— लीक नून

कोई खेद नहीं है, अच्छी तरह से किया! मुझे समझ नहीं आया कि इसे जल्दी से कैसे किया जाए ...

— एरिक आउटफोलर

11

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

lambda n:n-1+n%2*2

बहुत साधारण। पहले हम n-1 की गणना करते हैं और यह तय करते हैं कि इसमें 2 जोड़ना है या नहीं।

यदि n सम है -> n mod 2 0 होगा, तो हम 2 * 0 को n-1 में जोड़ देंगे , जिसके परिणामस्वरूप n-1 होगा ।

यदि n विषम है -> एन आधुनिक 2 1 हो जाएगा, इस प्रकार हम जोड़ देंगे 2 * 1 करने के लिए n-1 , जिसका परिणाम n + 1 ।

मुझे एक स्पष्टीकरण पसंद है जो मैंने एमएस पेंट और एक लैपटॉप टचपैड के साथ बनाया था ...

— Yytsi
स्रोत

10

पायथन, 16 बाइट्स

lambda x:-(-x^1)

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

— sagiksp
स्रोत

3

ब्रूट फोर्सिंग किसी भी छोटे समाधान को वर्णों का उपयोग करके नहीं ढूंढता है "x+-012~|&^()*/%"।

— xnor

@xnor अच्छी बात है मुझे यह मिल गया!

— सायगिक्स

1

और ऐसा लगता है कि तुच्छ पुनर्व्यवस्था के अलावा कोई अन्य समान लंबाई वाले समाधान नहीं हैं -(1^-x)।

— xnor

8

MATL , 7 बाइट्स

Q:HePG)

यह किसी भी अंकगणितीय संचालन से बचा जाता है। इसे ऑनलाइन आज़माएं!

व्याख्या

4उदाहरण के रूप में इनपुट पर विचार करें ।

Q    % Implicit input. Add 1
     % STACK: 5
:    % Range
     % STACK: [1 2 3 4 5]
He   % Reshape with 2 rows in column-major order. Pads with a zero if needed
     % STACK: [1 3 5;
               2 4 0]
P    % Flip vertically
     % STACK: [2 4 0;
               1 3 5]
G    % Push input again
     % STACK: [2 4 0;
               1 3 5], 4
)    % Index, 1-based, in column major order. Implicitly display
     % STACK: 3

— लुइस मेंडो
स्रोत

1

अच्छा! पसंद है !

— स्टीवी ग्रिफिन

6

ब्रिंगोल्फ v0.1 , 11 10 बाइट्स

.1>2,%?+:-

इसे ऑनलाइन आज़माएं! (दूसरा तर्क ब्रिंगोल्फ कोड है, तीसरा तर्क इनपुट है)

नील को एक बाइट दिया

पहले कभी प्रतिस्पर्धा करने वाले ब्रिंगोल्फ जवाब: डी

स्पष्टीकरण:

.            Duplicate the top of the stack
 1>          Push 1 to the bottom of the stack
   2         Push 2 to stack
    ,%       Pop last 2 items, mod them and push result
      ?      If last item > 0
       +     Add the 1 to the input
        :    Else
         -   Subtract the 1 from the input

             No semicolon in code so print last item

ब्रिंगोल्फ v0.2 , 9 बाइट्स [गैर-प्रतिस्पर्धी]

.2%?1+:1-

इसे ऑनलाइन आज़माएं! (दूसरा तर्क ब्रिंगोल्फ कोड है, तीसरा तर्क इनपुट है)

स्पष्टीकरण के लिए ऊपर देखें। केवल अंतर ब्रिंगोल्फ v0.2 में है, जो डायडिक ऑपरेटरों के डिफ़ॉल्ट व्यवहार, और के कार्य है, संशोधक उलट हैं, जिसका अर्थ है कि v0.1 उत्तर में 2 अल्पविराम की अब आवश्यकता नहीं है।

हालांकि चुनौती के बाद v0.2 जारी किया गया था, इसलिए यह किसी की गैर-प्रतिस्पर्धात्मक है

— Skidsdev
स्रोत

5

आपकी नई भाषा के लिए बधाई!

— लीक नून

क्या .1<2,%?+:-मैं क्या लगता है कि यह करता हो?

— नील

@ नहीं काफी नहीं, आपको -ऑपरेशन को सही तरीके से करने के लिए अल्पविराम की आवश्यकता होगी , जिस स्थिति में यह अभी भी मेरे जवाब के समान लंबाई होगी

— स्काइड्सडेव

@ माय्यूब मैं इनपुट <के 1नीचे घूमने की उम्मीद कर रहा था , ताकि यह पहले से ही सही जगह पर हो।

— नील

@ अगर इनपुट एक समान संख्या है, तब तक जब तक यह -ढेर तक पहुंचता है, इस तरह दिखता है: [n,1]ब्रेकिंगॉल्फ ऑपरेटर उलट होते हैं, इसलिए यह प्रदर्शन करेगा 1 - n, जिसके परिणामस्वरूप -(n-1)वांछित परिणाम बस होगाn-1

— स्काइड्सदेव

5

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

cO1)I(//@

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

व्याख्या

नेट संस्करण

    c O
    1 )
I ( / / @ . . .
. . . . . . . .
    . .
    . .

निष्पादित अक्षर हैं

I(1c)O@
I          Input
 (         Decrement
  1c       XOR with 1
    )      Increment
     O@    Output and exit

4

पायथन, 68 बाइट्स

lambda x:[m.floor(x-m.cos(m.pi*x)) for m in [__import__('math')]][0]

एक अद्वितीय दृष्टिकोण की भावना में। निम्नलिखित ग्राफ फ़ंक्शन को दर्शाता है (पहले 10 मामलों का प्रतिनिधित्व करने वाले बैंगनी डॉट्स के साथ)। सिद्धांत रूप में यह संभव होना चाहिए कि अधिकांश (सभी?) आवधिक कार्यों (जैसे पाप, तन, सेकंड) के आधार पर इस प्रश्न के समाधान का निर्माण किया जाए। वास्तव में, कोड में सेकंड के लिए cos को प्रतिस्थापित करना चाहिए जैसा कि काम करना चाहिए।

— penalosa
स्रोत

3

PHP, 15 बाइट्स

<?=-(-$argn^1);

— user63956
स्रोत

2

मैं इसे कैसे चलाऊं? मैं यह जांचने की कोशिश कर रहा हूं कि क्या ;आवश्यक है, और एक .phpफ़ाइल का उपयोग करने की कोशिश की है और सीधे php (php7 cli) में भी गूंज रहा है। हर बार मुझे बताया जाता है कि $argnएक अपरिभाषित चर है।

— आंद्रकिस

2

साथ @Andrakis Fझंडा और एक पाइप लाइन: echo 42 | php -F script.php।

— user63956

3

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

x=>x-(-1)**x

f=x=>x-(-1)**x;

<input id=i oninput=o.innerText=f(this.value) type=number><pre id=o>

स्निपेट का विस्तार करें

एक और दृष्टिकोण, _{सी उत्तर से चुराए गए} 10 बाइट्स _(sssshhh)

x=>-(-x^1)

f=x=>-(-x^1)

<input id=i oninput=o.innerText=f(this.value) type=number><pre id=o>

स्निपेट का विस्तार करें

— मैथ्यू रो
स्रोत

1. आपको अर्धविराम शामिल करने की आवश्यकता नहीं है; 2.x=>x-(-1)**x

— लीक नून

क्यों |0? दोनों समाधान ऐसे दिखते हैं मानो उन्हें स्वचालित रूप से स्ट्रिंग को संख्याओं में बदलना चाहिए। (पहले समाधान के लिए, यदि आप दशमलव से बचना चाहते हैं, तो उपयोग करें <input type=number>।)

— नील

@Neil मुझे सूचित करने के लिए धन्यवाद!

— मैथ्यू रो

3

जावास्क्रिप्ट (ईएस 6), 14 13 12 10 बाइट्स

n=>-(-n^1)

1 बाइट ने ल्यूक को धन्यवाद दिया ।
2 बाइट्स feersum के सी समाधान पोर्ट करके बचाया । (यदि वह पर डूब गया है, तो कृपया मुझे बताएं और मैं अपने पिछले समाधान पर वापस जाऊंगा)

कोशिश करो

f=
n=>-(-n^1)
i.addEventListener("input",_=>o.innerText=f(+i.value))

<input id=i type=number><pre id=o>

स्निपेट का विस्तार करें

मूल, 12 बाइट्स

n=>n-1+n%2*2

— झबरा
स्रोत

2

पायथन, 20 बाइट्स

lambda n:n+(n%2or-1)

n%2or-1अगर यह अजीब है, तो 1 वापस आ जाएगा, लेकिन अगर यह n%2"झूठा" (0) है, तो यह बदले में -1 देता है। फिर हम बस इसे जोड़ते हैंn ।

पिछला समाधान, 23 बाइट्स

lambda n:[n-1,n+1][n%2]

n%2शेष राशि की गणना तब की nजाती है जब इसे 2 से विभाजित किया जाता है। यदि यह सम्‍मिलित है, तो यह 0 देता है, और इस सूची में तत्व 0 है n-1। यदि यह विषम है, तो यह सूची में 1, और तत्व 1 है n+1।

— numbermaniac
स्रोत

1

एक लैम्ब्डा का प्रयोग करें:lambda n:[n-1,n+1][n%2]

— लीक नून

आह हाँ, इसलिए यह इस मामले में छोटा था। धन्यवाद कर दिया!

— नंबरमानस

2

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

.+
$*
^11(?=(11)*$)

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

— नील
स्रोत

2

05AB1E , 4 बाइट्स

(1^(

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

— Okx
स्रोत

वैकल्पिक 4 बाइट समाधान: इसे ऑनलाइन आज़माएं! ।

— कॉमरेड स्पार्कलेपनी

लेकिन Èi>ë<बहुत सुंदर है ;_;।

— मैजिक ऑक्टोपस Urn

2

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

u%2!I(/+@O<

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

व्याख्या

नेट संस्करण:

    u %
    2 !
I ( / + @ O < .
. . . . . . . .
    . .
    . .

वर्णों को निम्नलिखित क्रम में निष्पादित किया जाता है:

I(2%!+O@
I        # Take a number as input
 (       # Decrement it
  2%     # Take the parity of the decremented number
         # (0 if the input is odd, 1 if it's even)
    !    # If that number is zero:
     +   #   Add 2
      O  # Output the number
       @ # Terminate the program

— ल्यूक
स्रोत

2

ब्रेन-फ्लैक , 36 बाइट्स

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

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

मैं व्यक्तिगत रूप से इस जवाब से वास्तव में खुश हूं क्योंकि यह इस समस्या को हल करने के पारंपरिक तरीके की तुलना में बहुत कम है।

व्याख्या

कोड का पहला बिट

(({})(()))

स्टैक को बस से परिवर्तित करता nहै

n + 1
  1
  n

तब जबकि स्टैक का शीर्ष शून्य है, हम इसे घटाते हैं और इसके तहत संख्या का चिह्न फ्लिप करते हैं

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

हम शून्य को हटाते हैं और दो शेष संख्याओं को जोड़ते हैं

{}({}{})

— गेहूं का जादूगर
स्रोत

2

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

ग्रेग मार्टिन के लिए 3 बाइट्स बचाए गए!

#-1[-1][[#~Mod~2]]&

पिछला उत्तर, 22 बाइट्स

#+{-1,1}[[#~Mod~2+1]]&

स्पष्टीकरण (पिछले उत्तर के लिए)

गणितज्ञ की अच्छी विशेषता है कि अंकगणित जैसे संचालन स्वचालित रूप से सूचियों पर थ्रेड करते हैं।

इस मामले में, हम लेते हैं Mod[#,2]जो 0 या 1 पर लौटेगा, लेकिन हमें 1 जोड़ने की आवश्यकता है क्योंकि गणित सूची 1-अनुक्रमित है। अगर यह भी है , तो यह 1 से बाहर आता है, इसलिए #-1लौटा दिया जाता है। यदि यह विषम है , तो यह 2 से बाहर आता है, इसलिए #+1वापस लौटा दिया जाता है।

— numbermaniac
स्रोत

2

आप गणितज्ञ की [[0]]क्षमता का दुरुपयोग करके तीन बाइट्स बचा सकते हैं #-1[-1][[#~Mod~2]]&:।

— ग्रेग मार्टिन

वह पागल है, ऐसा कभी नहीं सोचा होगा। धन्यवाद कर दिया!

— नंबरमैनी

2

समझदार , 8 बाइट्स

-::^~-^-

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

व्याख्या

यदि यह आसपास का दूसरा तरीका था, (यदि वृद्धि विषम है, तो भी वृद्धि), ऐसा करना काफी आसान होगा।

हम बस पिछले बिट फ्लिप होगा।

::^~-^

यहाँ तय यह है कि हम नकारात्मक रहते हुए अंतिम बिट फ्लिप करते हैं। ऋणात्मक संख्याओं की अवहेलना से 1 अंक दूर हैं ~इसलिए यह समस्या को हल करने वाला एक ऑफसेट बनाता है।

इसलिए हम सिर्फ कार्यक्रम निकालते हैं और इसे लपेटते हैं -।

-::^~-^-

— गेहूं का जादूगर
स्रोत

1

जावा 8, 16 10 बाइट्स

n->-(-n^1)

जावा 7, 34 28 बाइट्स

int c(int n){return-(-n^1);}

@ Fersersum के अद्भुत सी उत्तर के बोरिंग पोर्ट ।
इसे यहाँ आज़माएँ।

पुराने उत्तर:

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

n->n%2<1?n-1:n+1

जावा 7, 34 बाइट्स

int c(int n){return--n%2>0?n:n+2;}

स्पष्टीकरण (पुराने जावा 7 उत्तर में):

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

int c(int n){return n%2<1?n-1:n+1;}अंतरिक्ष से छुटकारा पाने के लिए उपरोक्त उत्तर एक छोटा संस्करण है।

int c(int n){     // Method with integer parameter and integer return-type
  return--n%2>0?  //  If n-1 mod-2 is 1:
    n             //   Return n-1
   :              //  Else:
    n+2;          //   Return n+1
}                 // End of method

— केविन क्रूज़सेन
स्रोत

1

जाप , 6 बाइट्स

n ^1 n

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

— ओलिवर
स्रोत

1

पायथन, 20 बाइट्स

lambda n:n+(n&1)*2-1

— Wondercricket
स्रोत

1

बेफुज 93 , 18 बाइट्स

&:2%#v_1+.@
@.-1 <

मैं अभी तक इसे गोल्फ नहीं कर रहा हूं (मुझे उम्मीद है)।

— डैनियल
स्रोत

गोल्फ युक्तियाँ: Befunge 98 का उपयोग करने की क्षमता है kv(या jvअगर यह कड़ाई से 1 या 0 है) के बजाय #v_। इसके अलावा, यदि आप इसे ऑनलाइन उपयोग कर रहे हैं (और मैं इसे सुझाता हूं), तो आप प्रोग्राम को दूसरे के साथ समाप्त कर सकते हैं &(हालांकि इसमें 60 सेकंड का समय लगेगा), इसलिए @यदि आप इसका उपयोग करते हैं तो आप पहली पंक्ति से छुटकारा पा सकते हैं । यहाँ Befunge-98 के लिए आदेशों की पूरी सूची है , हालांकि वे सभी TIO में सही ढंग से लागू नहीं किए जा सकते हैं, जैसे &EOF पर उलटने के बजाय कार्यक्रम को समाप्त करना।

— माइल्डमिल्टनकॉस्ट

इसके अलावा, ऐसा लगता है कि आप 98 के बजाय befunge 93 का उपयोग कर रहे हैं, जिसमें कम कमांड हैं। आप अपने लिंक नाम को ठीक करना चाह सकते हैं यदि यह वास्तव में 93 है और 98 नहीं है

— माइल्डलीमिलकॉस्ट

@MistahFiggins, आह हाँ आप सही हैं मैं 93 का उपयोग कर रहा था।

— डैनियल

1

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

->n{-(-n^1)}

— Cyoce
स्रोत

1

आर, 17 बाइट्स

(n=scan())-(-1)^n

n=scan()अंक का मान कहाँ है

— Nutle
स्रोत

मुझे तुम्हारी जरूरत है लगता है -(-1)^nके बजाय +(-1)^nक्योंकि हम वापस जाने के लिए की जरूरत n-1है, तो nभी है

— ग्यूसेप

@ गुइसेप्पे ओह, हां, बिल्कुल, मूर्खतापूर्ण गलती

— नटले

1

कैसियो-बेसिक, 27 बाइट्स

piecewise(mod(n,2),1,-1)+n

फ़ंक्शन के लिए 26 बाइट्स, दर्ज करने के लिए +1 n पैरामीटर बॉक्स में ।

— numbermaniac
स्रोत

0

सी, 29 बाइट्स

a(int b){return b%2?b+1:b-1;}

— स्काईनेट
स्रोत

0

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

‘’Ḃ?

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

— आउटगोल्फर को एरिक करें
स्रोत

@LeakyNun testcases के लिए धन्यवाद

— एरिक द आउटगलर

0

बैच, 20 बाइट्स

@cmd/cset/a"-(1^-%1)

स्वतंत्र रूप से @ feersum के एल्गोरिथ्म को फिर से खोजा, ईमानदार!

— नील
स्रोत

समता को स्वाहा करो

कार्य

इनपुट

उत्पादन

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

स्कोरिंग

संदर्भ

सी, 20 बाइट्स

स्टैक कैट्स , 3 + 3 ( -n) = 6 बाइट्स

व्याख्या

x86 असेंबली, 9 बाइट्स (प्रतिस्पर्धा में प्रवेश के लिए)

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

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

पायथन, 16 बाइट्स

MATL , 7 बाइट्स

व्याख्या

ब्रिंगोल्फ v0.1 , 11 10 बाइट्स

ब्रिंगोल्फ v0.2 , 9 बाइट्स [गैर-प्रतिस्पर्धी]

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

व्याख्या

पायथन, 68 बाइट्स

PHP, 15 बाइट्स

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

एक और दृष्टिकोण, सी उत्तर से चुराए गए 10 बाइट्स (sssshhh)

जावास्क्रिप्ट (ईएस 6), 14 13 12 10 बाइट्स

कोशिश करो

मूल, 12 बाइट्स

पायथन, 20 बाइट्स

पिछला समाधान, 23 बाइट्स

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

05AB1E , 4 बाइट्स

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

व्याख्या

ब्रेन-फ्लैक , 36 बाइट्स

व्याख्या

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

पिछला उत्तर, 22 बाइट्स

स्पष्टीकरण (पिछले उत्तर के लिए)

समझदार , 8 बाइट्स

व्याख्या

जावा 8, 16 10 बाइट्स

जावा 7, 34 28 बाइट्स

जाप , 6 बाइट्स

पायथन, 20 बाइट्स

बेफुज 93 , 18 बाइट्स

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

आर, 17 बाइट्स

कैसियो-बेसिक, 27 बाइट्स

सी, 29 बाइट्स

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

बैच, 20 बाइट्स

स्टैक कैट्स , 3 + 3 ( `-n`) = 6 बाइट्स

एक और दृष्टिकोण, _{सी उत्तर से चुराए गए} 10 बाइट्स _(sssshhh)