आपका कार्य, यदि आप इसे स्वीकार करना चाहते हैं, तो एक ऐसा कार्यक्रम लिखना है जो एक गैर-शून्य संख्या को आउटपुट करता है (पूर्णांक या फ्लोट हो सकता है)। मुश्किल हिस्सा यह है कि अगर मैं आपके स्रोत कोड को उलट देता हूं, तो आउटपुट मूल पूर्णांक नकारात्मक होना चाहिए।

नियम

आपको एक पूर्ण कार्यक्रम बनाना चाहिए । यही है, आपके आउटपुट को STDOUT पर प्रिंट करना होगा।
दोनों संख्याओं को आधार 10 में होना चाहिए (किसी अन्य आधार पर या वैज्ञानिक संकेतन के साथ उन्हें निषिद्ध करना)।
अनुगामी / अग्रणी स्थानों के साथ संख्याओं को आउटपुट करने की अनुमति है।
यह कोड-गोल्फ है, इसलिए प्रत्येक भाषा में सबसे छोटा (मूल) कोड जीत जाता है!
डिफ़ॉल्ट ढीले लागू होते हैं।

उदाहरण

मान लीजिए कि आपका स्रोत कोड है ABCऔर उसका संबंधित आउटपुट है 4। यदि मैं CBAइसके बजाय लिखता हूं और इसे चलाता हूं , तो आउटपुट होना चाहिए -4।

code-golf source-layout

— HighlyRadioactive
स्रोत

6

यदि हम बाइट स्तर के बजाय बिट स्तर पर उलट कर सकते हैं तो एक बाइट -(0x45 = 0b00101101) जेली में काम करता है - -उपज -1 क्योंकि यह शाब्दिक -1 को परिभाषित करता है, जबकि Ṇ(0xB4 = 0b1010100) 1 उपज देता है क्योंकि यह तार्किक तार्किक प्रदर्शन नहीं करता है शून्य के निहित इनपुट के। (बेशक Ṇकाम करता है: पी)

— जोनाथन एलन

@TwilightSparkle क्या "अप्रयुक्त, खाली इनपुट" का अर्थ है कि हम ईओएफ तक पहुंचने वाले इनपुट कार्यों पर तुरंत भरोसा कर सकते हैं?

— बोर्का 223

1

@ Borka223 नहीं, आप नहीं कर सकते।

— हाईलीरेडियोएक्टिव

@JoKing नकल। मैं उसे हटा दूंगा।

— HighlyRadioactive

44

05AB1E , 2 बाइट्स

(1

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

! इल्न्नो टीआई yrT

(       # negate nothing
 1      # push 1 (and implictly output it)

1       # push 1
 (      # negate it (and implictly output it)

— ग्रिमी
स्रोत

10

+1 के लिए " ! Enilno ti yrT " ..

— Nat

28

जावास्क्रिप्ट (V8) , 19 बाइट्स

print(1)//)1-(tnirp

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

लगभग समान ...

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 19 बाइट्स

Print(1)//)1-(tnirP

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

(इसे इंगित करने के लिए @someone का धन्यवाद)

अभी भी बहुत कुछ उसी में ...

लुआ , 19 बाइट्स

print(1)--)1-(tnirp

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

लेकिन कम में ...

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

print 1#1-tnirp

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

PHP में भी छोटा है, क्योंकि इसमें यह मैजिक प्रिंटिंग टूल है: <?=...

PHP , 12 बाइट्स

<?=1;#;1-=?<

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

रूबी में भी कम, क्योंकि आप inspectप्रिंट के बजाय कर सकते हैं

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

p 1#1- p

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

— अरनॉल्ड
स्रोत

इसके अलावा C # इंटरएक्टिव Print(1)//)-1(tnirP,। ( इसे ऑनलाइन आज़माएं! )

— मेरा सर्वनाम 14

C # के लिए, सबसे छोटा कार्यक्रम भी संभावित एक है:class A{static void Main(){System.Console.Write(1);}}//}};)1-(etirW.elosnoC.metsyS{)(niaM diov citats{A ssalc

— LegionMammal978

प्रोग्रामिंग भाषा नहीं है, लेकिन आप 1<!--!<1-HTML के साथ (9 बाइट्स) कर सकते हैं , जो -1<!--!<1कि उलट होने पर होगा । यह आपके उत्तर के समान ही है।

— इस्माईल मिगुएल

लूआ में ज्यादातर यही है:print(1)--)1-(tnirp

— वैल

1

@EricDuminil: codegolf.stackexchange.com/a/193169/81663

— Night2

28

पॉवरशेल , 4 3 बाइट्स

1-0

इसे ऑनलाइन आज़माएं! या ! enilno ti yrT

संख्या-टिप्पणी-संख्या प्रारूप के बजाय अंकगणित का उपयोग करके एक बाइट को गला दिया।

यह जाहिरा तौर पर भी jshell (प्रति सैम ), और jq (प्रति मैनटवर्क - 1-0और 0-1) के समान है।

— AdmBorkBork
स्रोत

Jshell में वही

— Sam

Jq में समान :। 1-0 0-1

— मैनावर्क

12

/// , 4 बाइट्स

9/9-

आउटपुट 9।

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

उलट:

-9/9

आउटपुट -9।

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

/मुद्रित होने से पहले सब कुछ , जबकि बाकी को अनदेखा किया जाता है (वास्तव में स्लैश का उपयोग नहीं किया जाता है, इसलिए मुझे नहीं पता कि वास्तव में क्या होता है, लेकिन यह आउटपुट नहीं करता है)।

— स्टीफन
स्रोत

2

स्लैश का उपयोग करने के लिए +1। /पैटर्न पढ़ने प्रक्रिया शुरू होती है, और इस प्रकार, यह बाद पात्रों पैटर्न, नहीं outputted में readed है।

— HighlyRadioactive

2

मैं साथ आया /\-//1-और सोचा कि मैं चतुर था। : डी

— टान्नर स्विफ्ट

10

क्लेन 011, 5 बाइट्स

1-
@/

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

औंधा

/@
-1

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

ये क्लेन की अनूठी टोपोलॉजी का लाभ उठाते हैं, विशेष रूप से वास्तविक प्रक्षेप्य तल। (हालांकि व्यक्तिगत रूप से प्रत्येक उत्तर में केवल क्लेन बोतल की आवश्यकता होती है)।

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

10

व्हॉट्सएप , 21 बाइट्स

S S S T N
T   N
S T N
N
N
T   S N
T   N
T   T   S S

पत्र S(स्थान), T(टैब), और N(नई-पंक्ति) केवल हाइलाइटिंग के रूप में जोड़े गए।

आउटपुट 1/ -1।

इसे ऑनलाइन आज़माएं या इसे ऑनलाइन उल्टा आज़माएं (केवल कच्चे स्थान, टैब और नई-लाइनों के साथ)।

स्पष्टीकरण:

एक्ज़िट प्रोग्राम बिल्टिन का उपयोग करते हुए एक छोटा पैलिंड्रोम बनाया जा रहा है NNN।
नियमित कार्यक्रम होगा:

SSSTN  # Push 1 to the stack
TNST   # Pop and print the top of the stack as number
NNN    # Exit the program, making everything after it no-ops

रिवर्स प्रोग्राम होगा:

SSTTN  # Push -1 to the stack
TNST   # Pop and print the top of the stack as number
NNN    # Exit the program, making everything after it no-ops

किसी संख्या को धकेलने की छोटी अतिरिक्त व्याख्या:

पहला S: स्टैक मैनिपुलेशन को सक्षम करें
दूसरा S: ढेर पर एक नंबर धक्का
Sया T: क्रमशः सकारात्मक / नकारात्मक
कुछ अनुगामी S/ Tअनुगामी द्वारा N: बाइनरी में संख्या, कहाँ S=0औरT=1

यानी SSTTSTSNधक्का देता है -10।

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

7

टी-एसक्यूएल, 16 बाइट्स

--Forwards:
PRINT 4--4-TNIRP

--Backwards:
PRINT-4--4 TNIRP

4 को चुना गया क्योंकि 1 का अत्यधिक उपयोग किया जाता है :)

— BradC
स्रोत

1

यदि आप उत्सुक हैं, तो MySQL के लिए एक उत्तर select 1#1-tceles(17 बाइट्स) होगा। आप sqlfiddle.com/# ! -9/9eecb/107825 पर परिणाम की जांच कर सकते हैं ।

— इस्माईल मिगुएल

7

जाप , 2 बाइट्स

किसी भी एकल अंक पूर्णांक >0के स्थान पर इस्तेमाल किया जा सकता 2के रूप में कर सकते हैं A-G, H, I, Jया L( 10-16, 32, 64, -1और 100, क्रमशः)।

n2

इसका परीक्षण करें | औंधा

nकिसी पूर्णांक पर लागू करने की विधि, उस पूर्णांक को उस तर्क से घटा देती है, जो उसके पास जाता है, जो चूक करता है 0। जब आगे की ओर चलाया जाता है, तो nविधि को पहले निहित इनपुट पर चलाया जा रहा है, जो कि चूक भी करता है 0।

वैकल्पिक रूप से, gविधि का उपयोग इसके बजाय किया जा सकता है n, जो इसके तर्क को इसके लागू होने वाले पूर्णांक से घटाने के परिणाम का संकेत देता है।

— झबरा
स्रोत

7

टिप्पणियों के बिना हास्केल , 41 बाइट्स

फ़ॉरवर्ड प्रिंट 1+ न्यूलाइन:

main=print$!1
niam=main
"1-"!$rtStup=niam

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

-1बिना किसी नई रेखा के उलट प्रिंट (जिसे 2 बाइट की लागत पर जोड़ा जा सकता है):

main=putStr$!"-1"
niam=main
1!$tnirp=niam

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

प्रत्येक प्रोग्राम की पहली पंक्ति संख्या को प्रिंट करती है।
- -1कोष्ठक से बचने के लिए स्ट्रिंग आउटपुट का उपयोग किया जाता है।
- $!एक स्थान के बजाय (सख्त अनुप्रयोग) का उपयोग करना उलट रेखा को ऑपरेटर की एक वैध परिभाषा बनाने की अनुमति देता है !$(बस $ऐसा नहीं करेगा क्योंकि पुनर्वितरण उपयोग को तोड़ देगा)।
मध्य रेखा सुनिश्चित करती niamहै कि अंतिम रेखा के लिए परिभाषित किया गया है।
अंतिम पंक्ति एक ऑपरेटर की एक परिभाषा है !$, जिसका उपयोग नहीं किया जाता है, लेकिन सही ढंग से पार्स करने और टाइप करने की आवश्यकता होती है।

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

7

PHP , 15 13 बाइट्स

टिप्पणी के दुरुपयोग के बिना एक PHP संस्करण। ohceएक अपरिभाषित स्थिरांक है, इसलिए यह उसके नाम के स्ट्रिंग मान के बराबर होगा। नतीजतन, यह प्रिंट करने की कोशिश करेगा +1-'ohce'या -1+'ohce'जब उलट जाएगा। चूंकि 'ohce'एक गैर-संख्यात्मक मान है, इसलिए अंकगणितीय कार्यों में इसके बजाय 0 का उपयोग किया जाएगा और केवल 1या -1मुद्रित किया जाएगा।

;echo+1-ohce;

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

— Night2
स्रोत

यह चालाकी है। अच्छा!

— AdmBorkBork

1

यार, यह दुख की बात है कि मैं आपके सामने उसी जवाब पर पहुंचा हूं, 3 घंटे देर से :( मेरा उत्थान है।

— इस्माइल मिगुएल

7

Google , 3 बाइट्स

2-1

इसे ऑनलाइन आज़माएं!
! इल्न्नो टीआई yrT

— नेट
स्रोत

1

यह

— pizzapants184

6

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

NC

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

Nउदाहरण के लिए, परिणाम 0, उसके Cबाद, परिणाम 1-0= 1।

CN

इसे ऑनलाइन आज़माएं! Complement, परिणाम 1-0= 1। Nजैसे, परिणाम -1।

— AdmBorkBork
स्रोत

6

के (ngn / k) , 3 बाइट्स

2-1

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

क्या मैं कुछ भूल रहा हूँ? REPL भाषाओं के लिए स्पष्ट लगता है

— घसीट
स्रोत

6

क्यूबिक्स , 7 6 5 बाइट्स

@)O(@

इसे यहाँ
उलट कर देखें

व्याख्या

Cubified:

  @
) O ( @
  .

नियंत्रण प्रवाह को अनियंत्रित करते हुए, हम निष्पादित करते हैं )O(@, जो वेतन वृद्धि, आउटपुट, डिक्रीमेंट और निकास करता है।

उलट और घनीभूत:

  @
( O ) @
  .

नियंत्रण प्रवाह को अनियंत्रित करते हुए, हम निष्पादित करते हैं (O)@, जो घटते हैं, आउटपुट, वेतन वृद्धि, और बाहर निकलते हैं।

पुराना वर्जन

@O(.)O@

इसे यहाँ
उलट कर देखें

लघु के रूप में नहीं, बल्कि सौंदर्य से भरपूर।

— स्मृति सहायक
स्रोत

अच्छा है, इसे 1 क्यूब के आकार पर रखने का तरीका!

— ग्यूसेप

3

@)O(@5 बाइट्स के लिए और समरूपता की बहाली :)

— मिकी

5

रूनिक एनकाउंटर , 4 बाइट्स

1@Z1

इसे ऑनलाइन आज़माएं! इसे उलटा करके देखें!

मुझे 1कमांड का उपयोग करने का कोई तरीका नहीं मिला , यहां तक कि एक बाइट या दो की कीमत पर भी।

1@ɩ भी काम करता है, लेकिन बाइट्स की एक ही संख्या है।

— Draco18s
स्रोत

इनपुट क्यों? प्रश्न ने कहा कि आपके कार्यक्रम को कोई इनपुट नहीं लेना चाहिए।

— हाईलीरेडियोएक्टिव

@TwilightSparkle मैंने गलत

— समझा

हां मेरे द्वारा देखा जाता है। चतुर।

— HighlyRadioactive

5

एपीएल (डायलॉग यूनिकोड) , 4 3 बाइट्स

1-0

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

तुच्छ उत्तर। 1जब दौड़ते हैं और ¯1जब पलटते हैं तो प्रिंट होते हैं ।

— जे। सल्ल
स्रोत

5

स्टैक कैट्स `-mn` , 4 बाइट्स

:-:_

इसे ऑनलाइन आज़माएं! पाद लेख में मैंने अन्य सभी 4-बाइट समाधानों को शामिल किया है। (स्टैक कैट्स पहली लाइनफीड के बाद सब कुछ अनदेखा कर देते हैं।)

रिवर्स की कोशिश करो!

व्याख्या

-nसंख्यात्मक उत्पादन पर झंडा बदल जाता है (और इनपुट है, लेकिन हम किसी भी जरूरत नहीं है), और -mझंडा सामान्य रूप से सिर्फ एक गोल्फ सुविधा जो आप स्रोत कोड की अनावश्यक भाग से बचने की सुविधा देता है है। ऐसा इसलिए है क्योंकि हर स्टैक कैट्स प्रोग्राम को मिरर समरूपता की आवश्यकता होती है। -mझंडे के साथ आप केवल इसे पहले आधा (केंद्रीय चरित्र) देते हैं। तो यहाँ वास्तविक कार्यक्रम है:

:-:_:-:

जैसा कि आप पहले TIO लिंक में देख सकते हैं, 4 टन बाइट समाधान है, लेकिन मैंने इसकी सरलता के लिए इसे चुना। स्टैक कैट्स स्टैक-आधारित है, और यह प्रोग्राम केवल प्रारंभिक स्टैक का उपयोग करता है। चूंकि हमारे पास कोई इनपुट नहीं है, इसलिए इसमें -1शून्य के अनंत कुएं के ऊपर एक एकल (एक ईओएफ मार्कर) होता है। कार्यक्रम में तीन आज्ञाओं के निम्नलिखित अर्थ हैं:

:   Swap the top two stack elements.
-   Negate the top stack element (i.e. multiply by -1).
_   Pop a. Peek b. Push b-a.

तो यहां बताया गया है कि कैसे प्रोग्राम स्टैक को संशोधित करता है (राज्यों और कमांडों को यह इंगित करने के लिए कंपित किया जाता है कि प्रत्येक कमांड स्टैक को एक राज्य से अगले में कैसे बदलता है):

   :   -   :   _   :   -   :

-1   0   0  -1   1   0   0   1
 0  -1  -1   0   0   1   1   0
 0   0   0   0   0   0   0   0
 …   …   …   …   …   …   …   …

जैसा कि यह पता चला है, एकमात्र आदेश जो वास्तव में यहां कुछ भी करता है _जो हमारे ईओएफ मार्कर को एक में बदल देता है 1। कार्यक्रम के अंत में आउटपुट निहित है, और ईओएफ मार्कर वैकल्पिक है, इसलिए यह बस 1हमें प्रिंट करता है ।

अब यदि हम स्रोत कोड को उलट देते हैं, तो निहितार्थ के कारण, वास्तविक कार्यक्रम बन जाता है:

_:-:-:_

यह कुछ अलग करता है:

   _   :   -   :   -   :   _

-1   1   0   0   1  -1   0  -1
 0   0   1   1   0   0  -1  -1
 0   0   0   0   0   0   0   0
 …   …   …   …   …   …   …   …

इस बार स्टैक का निचला भाग अभी भी एक है -1इसलिए यह ईओएफ मार्कर के रूप में कार्य करता है और केवल इसके -1शीर्ष पर ही प्रिंट होता है।

...

अब उस सब के साथ कहा, चूंकि स्टैक कैट्स का उलटा कोड के साथ इस तरह का एक अनूठा रिश्ता है, मुझे लगता है कि उपयोग -mकरना थोड़ा धोखा है। यह आमतौर पर केवल स्रोत कोड के अनावश्यक भाग को छोड़ कर बाइट्स को बचाने के लिए होता है, लेकिन यहां यह वास्तव में चुनौती को बहुत आसान बना देता है और यहां तक कि पूरे कार्यक्रम को छोटा कर देता है। ऐसा इसलिए है क्योंकि किसी पूर्ण प्रोग्राम को उलटने से प्रोग्राम केवल तभी बदलेगा जब उसमें कोई भी हो <>[], जिसका अर्थ यह भी है कि प्रोग्राम कई स्टैक का उपयोग कर समाप्त होता है (स्टैक कैट्स में वास्तव में स्टैक्स का टेप होता है, जहां सभी लेकिन प्रारंभिक एक ही भरे होते हैं के साथ शुरू करने के लिए शून्य के साथ)। इसके अलावा, इसे उल्टा करने से बस स्वैप होता है <>और []जोड़े, जो अभी भी निष्पादन को सममित बनाता है। उस समरूपता को तोड़ने का एकमात्र तरीका है Iजो उपयोग करता है -]या करता है-[या स्टैक के शीर्ष के संकेत के आधार पर कुछ भी नहीं। इसलिए...

स्टैक कैट्स `-n` , 11 बाइट्स

*|]I*:*I[|*

इसे ऑनलाइन आज़माएं! पाद लेख में फिर से एक ही बाइट गिनती में अन्य सभी विकल्प शामिल हैं। उन आउटपुट में से कुछ 1 / -1 और कुछ आउटपुट 2 / -2 जैसा कि प्रत्येक प्रोग्राम के बाद संकेत दिया गया है। मैं यह एक कि उत्पादन 2 में से एक के रूप में थोड़े बेतरतीब ढंग से समझाने के लिए उठाया।

रिवर्स की कोशिश करो!

व्याख्या

जैसा कि मैंने कहा, यह थोड़ा लंबा है। यहां तक कि अगर हमने इसके लिए -mनोटेशन का उपयोग किया है, तो यह उपर्युक्त 4 के बजाय 6 बाइट्स में वजन करेगा।

इस समय उपयोग में आदेश:

*   Toggle the least significant bit of the top of the stack.
|   Reverse the longest non-zero of prefix on this stack.
[]  Move one stack to the left/right and take the top of the current stack with you.
I   If the top of the stack is positive, -], if it's negative, -[, otherwise do nothing.
:   Swap the top two stack elements.

पहला प्रोग्राम केवल दो स्टैक का उपयोग करता है। यह ASCII कला में करने के लिए थोड़ा गड़बड़ है, लेकिन मैं अपनी पूरी कोशिश करूँगा। वर्ग कोष्ठक इंगित करते हैं कि टेप हेड किस स्टैक पर है, और मैं स्टैक स्टेट्स के प्रत्येक जोड़े के बीच कमांड डालूँगा।

  [-1]
…   0   0   …
    0   0
    …   …

      *

  [-2]
…   0   0   …
    0   0
    …   …

      | (does nothing)
      ]

      [-2]
…   0   0   …
    0   0
    …   …

      I

   [2]
…   0   0   …
    0   0
    …   …

      *

   [3]
…   0   0   …
    0   0
    …   …

      :

   [0]
…   3   0   …
    0   0
    …   …

      *

   [1]
…   3   0   …
    0   0
    …   …

      I

      [-1]
…   3   0   …
    0   0
    …   …

      [

  [-1]
…   3   0   …
    0   0
    …   …

      |

  [ 3]
…  -1   0   …
    0   0
    …   …

      *

  [ 2]
…  -1   0   …
    0   0
    …   …

अब -1ईओएफ मार्कर के रूप में कार्य करता है और 2प्रिंट हो जाता है।

जब तक अन्य कार्यक्रम समान है [। यह अभी भी लगभग सभी तरह से दूसरा है I। हम तकनीकी रूप से एक अलग स्टैक पर होंगे, लेकिन उन पर मूल्यों के बिना, वे सभी अविवेच्य हैं। लेकिन फिर फर्क पड़ता है I[और I]समाप्त होता है:

    *|[I*:*I

      [-1]
…   3   0   0   …
    0   0   0
    …   …   …

        ]

          [-1]
…   3   0   0   …
    0   0   0
    …   …   …

        | (does nothing)
        *

          [-2]
…   3   0   0   …
    0   0   0
    …   …   …

और इस बार, हमारे पास EOF मार्कर नहीं है, लेकिन कार्यक्रम अभी भी आउटपुट करता है -2।

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

4

Zsh , 12 बाइट्स

<<<2 # 2-<<<

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

मूल आगे, टिप्पणी, रिवर्स विधि।

यदि I / O कम प्रतिबंधात्मक है, तो एक और अधिक दिलचस्प 11 बाइट समाधान संभव है, जो कि नकारात्मक रिटर्न कोड का समर्थन करने वाले Zsh के लिए धन्यवाद:

return -127

उलटा, 721- nruterकोड के साथ बाहर निकलता है 127(कमांड नहीं मिला)। exit -127इस्तेमाल नहीं किया जा सकता है, यह एक के लिए डाली जाएगी u8। इसे ऑनलाइन आज़माएं!

— GammaFunction
स्रोत

4

सीजाम , 3 बाइट्स

W;1

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

वे कैसे काम करते हैं

सामान्य संस्करण:

W    e# Push -1
;    e# Delete
1    e# Push 1
     e# Implicit display

रिवर्स संस्करण: आपको यह विचार मिलता है।

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

4

MATL , 3 बाइट्स

Nqv

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

वे कैसे काम करते हैं

सामान्य:

N   % Push number of elements in the stack: 0
q   % Subtract 1: gives -1
v   % Concatenate stack contents vertically: leaves -1 as is
    % Implicit display stack contents

उलट:

v   % Concatenate stack contents vertically: gives the empty array, []
q   % Subtract 1: leaves [] as is
N   % Push number of elements in the stack: 1
    % Implicit display. [] is not displayed

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

4

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 21 18 बाइट्स

Print@1;tnirP//1-0

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

-3 मार्टिन एंडर को धन्यवाद

— attinat
स्रोत

4

हेक्सागोनी , 5 बाइट्स

1!@!(

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

कोई भी मान्य कार्यक्रम होना चाहिए:

समाप्ति आदेश ( @या :) है। बाद वाला केवल पूर्व के लिए अलग होता है जब मेमोरी पॉइंटर मूवमेंट कमांड होता है। साथ ही यह कमांड पहली या आखिरी बाइट पर नहीं होनी चाहिए।
एक आउटपुट कमांड है। ( !, ;यह भी संभव है लेकिन शायद अधिक बाइट्स ले जाएगा)
एक मेमोरी हेरफेर कमांड है।

इसलिए 2-बाइट प्रोग्राम स्पष्ट रूप से असंभव है। 3-बाइट प्रोग्राम असंभव है क्योंकि दूसरा बाइट टर्मिनेशन कमांड होना चाहिए, और पहला बाइट एक मिरर / आईपी हेरफेर कमांड नहीं होना चाहिए, इसलिए केवल 1 बाइट को निष्पादित किया जा सकता है।

मुझे लगता है कि 4-बाइट कार्यक्रम संभव नहीं है। इस तरह के कार्यक्रम में a@bcहेक्सागोनल ग्रिड के साथ फॉर्म होना चाहिए

 Forward:       | Backward:
                | 
  c b           |   a @
 @ a .          |  b c .
  . .           |   . .

इसलिए aएक आईपी पुनर्निर्देशन आदेश होना चाहिए। हालांकि यह केवल 1 मेमोरी हेरफेर कमांड के साथ सकारात्मक और नकारात्मक दोनों संख्या उत्पन्न करना असंभव है।

— user202729
स्रोत

एक अन्यथा तुच्छ उत्तर में इष्टतमता के प्रमाण के लिए +1

— जो किंग

3

हास्केल , 28 बाइट्स

main=print 1--)1-(tnirp=niam

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

यह enilno की कोशिश करो!

— Sacchan
स्रोत

3

त्रिकोणीय , 4 बाइट्स

i%%d

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

आउटपुट 1।

Ungolfed:

   i
  % %
 d

उलट:

d%%i

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

आउटपुट -1।

— मोनिका को बहाल करो
स्रोत

3

जावा 5 या 6, 127 67 बाइट्स

enum A{A;{System.out.print(9);}}//}};)9-(tnirp.tuo.metsyS{;A{A mune

आउटपुट 9/ -9।

कोई भी ऑनलाइन कंपाइलर, क्योंकि जावा 5 या 6 कहीं भी उपलब्ध नहीं है।

हालाँकि आप इस 127 बाइट्स जावा 8 के बराबर की
कोशिश कर सकते हैं : इसे ऑनलाइन आज़माएँ या इसे ऑनलाइन उल्टा आज़माएँ ।

स्पष्टीकरण:

enum A{                              // Create an enum
 A;                                  //  With a mandatory value
 {                                   //  And in a separate instance code-block:
  System.out.print(9);}}             //   Print 9 to STDOUT
//}};)9-(tnirp.tuo.metsyS{;A{A mune  // Comment and thus a no-op

जावा 5 और 6 में एक बग था जो आपको प्रोग्राम के अनिवार्य मुख्य-विधि को याद करने के बावजूद कुछ करने के लिए एक एनम के अंदर एक कोड ब्लॉक बनाने की अनुमति देता है। इसके परिणामस्वरूप त्रुटि होगी:

java.lang.NoSuchMethodError:
थ्रेड में मुख्य अपवाद "मुख्य"

लेकिन फिर भी आउटपुट होगा कि हम पहले क्या चाहते हैं, इसलिए हम इसे अनदेखा कर सकते हैं ।

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

3

गोलांग , 109 बाइट्स

package main;import "fmt";func main(){fmt.Println(1)}//})1(nltnirP.tmf{)(niam cnuf;"tmf" tropmi;niam egakcap

और इसका उल्टा:

package main;import "fmt";func main(){fmt.Println(-1)}//})1(nltnirP.tmf{)(niam cnuf;"tmf" tropmi;niam egakcap

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

— TheMrMittens
स्रोत

2

मुझे नहीं पता, लेकिन ऐसा लगता है कि आप कुछ बाइट निकाल सकते हैं। Printlnहो सकता है Print, और import "fmt";अंतरिक्ष की जरूरत नहीं है: import"fmt";। :)

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

3

पर्ल 5 (-पी), 12 बाइट्स

\$--{}}{++$\

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

! इल्न्नो टीआई yrT

}{छद्म ऑपरेटर वास्तव में काम में आता।

पर्ल 5 (-M5.010), 9 बाइट्स

एक टिप्पणी में नहुएल फोइउल द्वारा प्रदान किया गया

say+1-yas

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

! इल्न्नो टीआई yrT

— ग्रिमी
स्रोत

2

होना चाहिएsay 1#1-yas

— नहुएल फौलीउल

@NahuelFouilleul वास्तव में Yas

— ग्रिमी

1

9 बाइट्स: say+1-yasऔरsay-1+yas

— नहुएल फौइलुल

3

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

-`<
-

प्रिंट करता है 1।

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


-
<`-

प्रिंट करता है -1।

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

स्पष्टीकरण: `1`

-`<
-

यह ... कुछ नहीं करता। के कारण `, इस से एक प्रतिस्थापन है <करने के लिए -(विन्यास के साथ -है, जो कुछ नहीं करता है), लेकिन इनपुट खाली है, तो उत्पादन में अच्छी तरह से खाली है।

और यह दूसरा चरण खाली इनपुट के खिलाफ खाली रेगेक्स से मेल खाता है और मैचों की संख्या को गिनता है, जो कि ठीक 1. आउटपुट है।

स्पष्टीकरण: `-1`

इस बार हम खाली रेगेक्स की जगह लेते हैं -। यह वास्तव में खाली इनपुट को एकल में बदल देता है -।

<`-

यहां, कॉन्फ़िगरेशन वास्तव में कुछ करता है: <चरण को निष्पादित करने से पहले चरण के इनपुट को प्रिंट करता है , इसलिए हम प्रिंट करते हैं -। फिर -चरण के इनपुट में हाइफ़न को गिना जाता है जो फिर से होता है। 1. निहित आउटपुट के कारण, यह एक के 1बाद प्रिंट करता है -, हमें -1आवश्यकतानुसार देता है।

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

3

$\Large{\mathbf{\TeX} \left(\text{MathJax}\right)},~4\,\text{bytes}$

1%1-

\begin{array}{rcc} Code & Result \\ Forward: & 1%1- & 1 \\ Backward: & -1%1 & - 1 \end{array}

$\begin{array}{|r|c|c|} \hline & \textbf{Code} %& \begin{array}{c}\boxed{\textbf{Boxed}} \\ \textbf{Result} \end{array} & \textbf{Result} \\\hline \textbf{Forward:} & \texttt{1%1-} & %\boxed{ 1%1- %} \\\hline \textbf{Backward:} & \texttt{-1%1} & %\boxed{ -1%1 %} \\\hline \end{array}$

— नेट
स्रोत

3

ब्रेनफक , 156 बाइट्स

+++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++<+++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++

इसे ऑनलाइन आज़माएं! / फॉरवर्ड / बैश में पिछड़े सत्यापनकर्ता

-1आगे और \n1पीछे प्रिंट करता है ।

लगभग तुच्छ होने के बावजूद, मेरा मानना है कि यह इस विशेष निश्चित आउटपुट के लिए इष्टतम समाधान है।

प्रमाण:

कार्यक्रम [या नहीं हो सकता है ]।

इसलिए प्रोग्राम का फॉर्म होना चाहिए <A> . <B> . <C>।
प्रत्येक की ,पर्याप्त संख्या के साथ या <की संख्या में वृद्धि के बिना बदला जा सकता है ।+-
प्रत्येक +केवल आगे या पिछड़े कार्यक्रम में ही उपयोगी है, दोनों कभी नहीं।

प्रमाण: +भाग A में स्पष्ट रूप से केवल अग्रेषित कार्यक्रम में उपयोगी है, और +भाग C में स्पष्ट रूप से केवल पिछड़े कार्यक्रम में उपयोगी है।

Denote shift(P)= <P की संख्या - P की संख्या >। पी। पर विचार करें कार्यक्रम <B> = <D> + <E>, +बीच में आगे के कार्यक्रम में उपयोगी है $\iff$ shift(E) = 0, इसी तरह यह पिछड़े कार्यक्रम में उपयोगी है $\iff$ shift(D) = 0। हालाँकि, यदि shift(D) = shift(E) = 0उसके बाद प्रोग्राम Bआगे या पीछे चलाया जाता है , तो दूसरी बार प्रिंट करने से पहले वर्तमान सेल में एक निश्चित मान जोड़ देगा, जो कि ऐसा नहीं हो सकता है ord('1') - ord('\n') != ord('1') - ord('-')।

इसलिए कार्यक्रम को कम से कम ord('-')+ord('1')+ord('\n')+ord('1') = 153 +s, 2 .s और कम से कम < >या ,इसलिए की आवश्यकता है shift(B) != 0।

— user202729
स्रोत

मैं स्रोत कोड को उलट देता हूं, आप आउटपुट को नकार देते हैं!

नियम

उदाहरण

05AB1E , 2 बाइट्स

जावास्क्रिप्ट (V8) , 19 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 19 बाइट्स

लुआ , 19 बाइट्स

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

PHP , 12 बाइट्स

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

पॉवरशेल , 4 3 बाइट्स

/// , 4 बाइट्स

क्लेन 011, 5 बाइट्स

औंधा

व्हॉट्सएप , 21 बाइट्स

टी-एसक्यूएल, 16 बाइट्स

जाप , 2 बाइट्स

टिप्पणियों के बिना हास्केल , 41 बाइट्स

PHP , 15 13 बाइट्स

Google , 3 बाइट्स

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

के (ngn / k) , 3 बाइट्स

क्यूबिक्स , 7 6 5 बाइट्स

व्याख्या

पुराना वर्जन

रूनिक एनकाउंटर , 4 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 4 3 बाइट्स

स्टैक कैट्स -mn , 4 बाइट्स

व्याख्या

स्टैक कैट्स -n , 11 बाइट्स

व्याख्या

Zsh , 12 बाइट्स

सीजाम , 3 बाइट्स

वे कैसे काम करते हैं

MATL , 3 बाइट्स

वे कैसे काम करते हैं

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 21 18 बाइट्स

हेक्सागोनी , 5 बाइट्स

हास्केल , 28 बाइट्स

त्रिकोणीय , 4 बाइट्स

जावा 5 या 6, 127 67 बाइट्स

गोलांग , 109 बाइट्स

पर्ल 5 (-पी), 12 बाइट्स

पर्ल 5 (-M5.010), 9 बाइट्स

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

स्पष्टीकरण: 1

स्पष्टीकरण: -1

ब्रेनफक , 156 बाइट्स

स्टैक कैट्स `-mn` , 4 बाइट्स

स्टैक कैट्स `-n` , 11 बाइट्स

स्पष्टीकरण: `1`

स्पष्टीकरण: `-1`