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

36

एक चीर-फाड़ की उदास चीर- फाड़ । उन ऊपर जाओ!

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

उदाहरण

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

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

यदि आप हस्ताक्षरित शून्य का समर्थन करते हैं, तो एक इनपुट 0दे सकता है 0या देना चाहिए ।-0-00

code-golf  math  number  source-layout 
— एडम
स्रोत
5
हमें उसी प्रश्न की प्रतिलिपि की आवश्यकता क्यों है?
— ईसाई
5
@Christian यह कि एक निरंतर संख्या (और इसकी अवहेलना) को आउटपुट करता है, जबकि इसे इनपुट और रिटर्न / नकार देना पड़ता है। बहुत सारी भाषाओं में एक बहुत अलग काम।
— आदम
5
हाँ, अब मुझे अंतर दिखाई दे रहा है। बहुत ध्यान से पढ़ने की जरूरत है
— ईसाई
यदि C # जैसी संरचित भाषा का उपयोग कर रहे हैं, तो क्या आप लाइनों को उलट रहे हैं?
— PerpetualJ
@PerpetualJ नहीं, पात्रों की सूची जैसे स्रोत को देखें, जिनमें से कुछ लाइन ब्रेक हैं।
— एडम

जवाबों:

18

पॉवरशेल , 18 14 बाइट्स

$args#"sgra$"-

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

सबसे पहले तुच्छ टिप्पणी-दुर्व्यवहार के जवाब

— Veskah
स्रोत
4
हे भगवान। यह फिर नहीं ।
— 1922 में JL2210
1
"पहले तुच्छ टिप्पणी-दुर्व्यवहार के जवाब" TIO लिंक द्वारा भुनाया गया!
— योना
11

x86 मशीन कोड, 3 बाइट्स

C3 D8 F7

कोड के उपरोक्त बाइट्स एक फ़ंक्शन को परिभाषित करते हैं जो एक नो-ऑप है: यह बस कॉल करने वाले को नियंत्रण लौटाता है। उस समारोह के बाद दो कचरा बाइट्स होते हैं जिन्हें निष्पादित नहीं किया जाएगा, क्योंकि वे एक वापसी के बाद आते हैं - वे "नो मैन्स लैंड" में हैं। असेंबलर mnemonics में:

ret                     ; C3    
fdiv  st(0), st(7)      ; D8 F7

ठीक है, इसलिए अब कुछ ट्रोल आते हैं और बाइट्स के क्रम को उलट देते हैं:

F7 D8 C3

ये बाइट्स अब एक फ़ंक्शन को परिभाषित करते हैं जो पूर्णांक तर्क में लेता है EAX रजिस्टर , इसे नकारता है, और कॉल करने वाले पर नियंत्रण वापस करता है। असेंबलर mnemonics में:

neg  eax     ; F7 D8
ret          ; C3

तो ... यह आसान था। :-)

ध्यान दें कि हम "नकारात्मक" निर्देश को कुछ भी बना सकते हैं जो हम चाहते हैं, क्योंकि इसे "फॉरवर्ड" अभिविन्यास में कभी निष्पादित नहीं किया गया है और केवल "उलट" अभिविन्यास में निष्पादित किया गया है। इसलिए, हम समान रूप से अधिक जटिल सामान करने के लिए एक ही पैटर्न का पालन कर सकते हैं। उदाहरण के लिए, यहां हम एक अलग रजिस्टर में पूर्णांक तर्क लेते हैं (कहते हैं, EDIसिस्टम V कॉलिंग कन्वेंशन का पालन करने के लिए आमतौर पर * nix सिस्टम पर उपयोग किया जाता है), इसे नकारात्मक करें, और इसे पारंपरिक EAXरजिस्टर में लौटाएं :

C3      ret
D8 F7   fdiv  st(0), st(7)      ;  \ garbage bytes that
F8      clc                     ;  | never get executed,
89      .byte 0x89              ;  / so nobody cares

  ↓ ↓

89 F8   mov  eax, edi
F7 D8   neg  eax
C3      ret
— कोडी ग्रे
स्रोत
10

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

oN

इसे ऑनलाइन आज़माएं! और इसके विपरीत ।

oN - (input) OR ((input) negated)

No - ((input) negated) OR (input)
— जोनाथन एलन
स्रोत
हे, आप भी कर सकते हैं ḷN, या तर्क के लिए कोई ज़रूरत नहीं है। : डी
— एरिक आउटगॉल्फ
10
Na, शब्द aNसौंदर्य प्रभाव देते हैं :)
— जोनाथन एलन
7

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

अनाम पहचान समारोह, 0जब उलट से घटाव में बदल रहा है।

id--)-0(

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

उलट:

(0-)--di

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

— अर्जन जोहान्सन
स्रोत
2
आप अपने उलट संस्करण के साथ हाइलाइटिंग कोड को तोड़ने में कामयाब रहे हैं!
— टिम
@ तैमूर जिज्ञासु। परीक्षण से पता चलता है कि जब कोई टिप्पणी सही कोष्ठक के ठीक बाद शुरू होती है तो वह विफल हो जाती है।
— अर्जन जोहानसन
6

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

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

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

का मामूली संशोधन स्रोत कोड को उल्टा करने के लिए मेरे व्हाट्सएप जवाब , आप आउटपुट को नकारते हैं! चुनौती ।

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

स्पष्टीकरण:

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

SSSN   # Push 0 to the stack
SNS    # Duplicate it
TNTT   # Read STDIN as integer, and store it at heap address 0
TTT    # Retrieve the input from heap address 0, and push it to the stack
TNST   # Pop and print the top of the stack as number
NNN    # Exit the program, making everything after it no-ops

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

SSSN   # Push 0 to the stack
SNS    # Duplicate it
TNTT   # Read STDIN as integer, and store it at heap address 0
TTT    # Retrieve the input from heap address 0, and push it to the stack
SSTTN  # Push -1 to the stack
TSSN   # Multiply the top two values on the stack together
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। हमारे लिए 0एक स्पष्ट की जरूरत नहीं है S=0, तो बस SSSNया SSTNपर्याप्त है।

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

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

#)]}{[(

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

उलट:

([{}])#

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

नोट: केवल उन दुभाषियों में काम करता है जो टिप्पणियों का समर्थन करते हैं (जैसे रेन-फ्लैक में काम करता है, लेकिन ब्रेनहैक में नहीं)

यदि हम केवल बाइट्स उलटने के बजाए खुलने / बंद होने वाले ब्रैकेट स्वैप करते हैं, तो हम टिप्पणियों का उपयोग किए बिना इसे 8 बाइट्स में कर सकते हैं:

({}[{}])

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

— रिले
स्रोत
क्या यह अपरिभाषित व्यवहार दुरुपयोग है? मुझे नहीं लगता कि ब्रेन-फ्लैक विनिर्देश ऐसे कोष्ठक की अनुमति देता है।
— HighlyRadioactive
@TwilightSparkle #टिप्पणी शुरू होती है, इसलिए मूल संस्करण में कोष्ठक की उपेक्षा की जाती है।
— रिले
ओह हाँ मैं भूल गया था! लेकिन यह केवल रेन-फ्लैक में काम करता है (हालांकि यह आधिकारिक घुसपैठ है)। आपको शायद इसका उल्लेख करने की आवश्यकता होगी?
— HighlyRadioactive
@TwilightSparkle ने स्पष्टीकरण के लिए एक नोट जोड़ा। धन्यवाद।
— रिले
मजेदार छोटी चुनौती: क्या आप टिप्पणियों के बिना ऐसा कर सकते हैं यदि आप सिर्फ उलटने के बजाय कोष्ठक खोलने / बंद करने की अदला-बदली करते हैं?
— DJMcMayhem
4

मारियोलैंग , 22 बाइट्स

;:
=#
:)!
--
<(
"
[>
;

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

EOF के गिरने से पहले वह सिर्फ इनपुट करता है और नंबर को आउटपुट करता है

निरस्त किया गया:

;
>[
"
(<
--
!):
#=
:;

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

वह तब तक लूप करता है जब तक इनपुट वैल्यू 0 नहीं है और आउटपुट वैल्यू -input है, वह नंबर कहता है।

— डोरियन
स्रोत
4

आर , 23 बाइट्स

मैंने इसे टिप्पणी की चाल के बिना जाने का फैसला किया।

आगे

`+`=scan;""+-0;nacs=`+`

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

रिवर्स

`+`=scan;0-+"";nacs=`+`

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

आगे के संस्करण +में एक द्विआधारी ऑपरेटर काम कर रहा है, और -एक अपर ऑपरेटर है।

रिवर्स में +एकात्मक हो जाता है और -द्विआधारी होता है। तो स्कैन फ़ंक्शन तर्कों को लेता है: file=""जिसका अर्थ है स्टडिन और what=0, जो कि चूक भी हैं। इसलिए जब +एकात्मक होता है तो पहला तर्क दाईं ओर होता है, जब यह द्विआधारी होता है पहला तर्क बाईं तरफ होता है।

;nacs=`+`

कोड का हिस्सा वास्तव में कुछ भी उपयोगी नहीं है, इसलिए एक मायने में मेरा कोड टिप्पणी चाल का उपयोग करने की तुलना में वास्तव में बहुत अधिक वैध नहीं है।

— हारून हेमन
स्रोत
1
यह बहुत स्मार्ट (+1) है। हम अक्सर आर ऑपरेटरों को गोल्फ बाइट्स को पुनर्परिभाषित करते हैं, लेकिन मुझे लगता है कि यह पहली बार है जब मैंने +यूनिफ़ायर और बाइनरी दोनों के रूप में उपयोग करने के लिए पुनर्परिभाषित किया है। मुझे यह समझने में एक मिनट लगा कि यह कैसे किया गया ... किसी अन्य ऑपरेटर नाम ने काम नहीं किया होगा।
— रॉबिन राइडर
4

पर्ल 5 ( -p), 7 6 बाइट्स

-1 @primo को धन्यवाद

$_*=$#

TIO

एक टिप्पणी इनपुट में बदलाव नहीं करती है

#1-=*_$

इनपुट प्राप्त करें

$_*=-1#

TIO

— नहुएल
स्रोत
-1: $_*=$# टीआईओ । ध्यान दें कि #कार्यक्रम का बहुत अंतिम बाइट होना चाहिए, अन्यथा यह चर के रूप में व्याख्या किया जाएगा $#, नाम के साथ सरणी के अंतिम सूचकांक के बजाय <खाली>।
— प्रिमो
1
हालाँकि मुझे समझ में नहीं आता कि यह कैसे काम करता है क्योंकि प्रिंट करने की कोशिश $#या तो एक त्रुटि देती है (यदि # अंतिम वर्ण नहीं है) या कुछ भी नहीं
— नाहुएल फौइउल
केवल साथ काम करने लगता है -pया -n। मुझे संदेह है कि बॉयलरप्लेट के साथ कुछ करना है ...
— प्रिमो
2
@primo यह काम करता है क्योंकि कोड के बाद -p/-nजोड़ता है ;। जिसका अर्थ है कि $#वास्तव में $#;: सरणी का आकार@; । यदि आकार @;बदलता है, तो परिणाम अब सही नहीं है ( TIO )। वैसे भी, यह सुपर चालाक है, अच्छी तरह से किया! :)
— दादा
यह स्पष्टीकरण के साथ देखा जा सकता है perl -MO=Deparse -p <(echo -n '$_*=$#'), क्योंकि ऐसा लगता perl -MO=Deparse -pe '$_*=$#'है कि एक नई पंक्ति जोड़ता है
— नहुएल फोइउलुल
4

बैकहैंड , 6 5 बाइट्स

I@-Ov

इसे ऑनलाइन आज़माएं! इसे दोगुना करने की कोशिश करो!

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

स्पष्टीकरण:

बैकहैंड में पॉइंटर तीन कोशिकाओं पर टिक जाता है और सेल की सीमाओं से दूर उछलता है, जिसका अर्थ है कि सामान्य तर्क अतिव्यापी है। हालाँकि आप इस गति को कमांड vऔर ^कमांड के साथ जोड़ सकते हैं ।

मूल कार्यक्रम निर्देशों को निष्पादित करता है IO-@, जो संख्या के रूप में इनपुट है, संख्या के रूप में आउटपुट है, घटाना, समाप्त करना। जाहिर है कि घटाव बहुत ही कम है। कोड में ये हैं:

I@-Ov
^  ^    Reflect
  ^     Reflect again
 ^

उलटा कार्यक्रम निष्पादित करता है v-I-vO-@। vटिक के बीच सूचक कदम, और कम कर देता है -ढेर के नीचे, जो परोक्ष शून्य है से घटाता है। अतिरिक्त -आदेश कुछ नहीं करते हैं। कार्यक्रम की तरह निष्पादित करता है

vO-@I
v       Reduce pointer speed to 2
  -     Subtract zero from zero
    I   Get input as number and reflect off boundary
  -     Subtract input from zero
v       Reduce pointer speed to 1
 O      Output as number
  -     Subtract zero from zero
   @    Terminate
— जो राजा
स्रोत
3

आर , 14 बाइट्स

scan()#)(nacs-

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

एक पूर्ण कार्यक्रम जो एक संख्या को पढ़ता है, या एक संख्या को पढ़ता है और नकारता है। इनलाइन टिप्पणी द्वारा रिवर्स कार्यक्षमता सुरक्षित है

— निक केनेडी
स्रोत
आपके ब्रैकेट टिप्पणी किए गए भाग में गलत तरीके से हैं।
— आरोन हेमैन
@AaronHayman धन्यवाद!
— निक केनेडी
3

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

int#__bus__. 0

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

का उपयोग करता है intवर्ग के निर्माता और एक बिल्ट-इन छद्म निजी विधि।

— मैपलप्लियन
स्रोत
हुह। विशेषता अनिवार्य होने से पहले स्थान क्यों है?
— जो किंग
2
@JoKing 0.एक संख्या है, जो एक प्रतीक द्वारा पीछा किया जाता है के रूप में व्याख्या की जाएगी
— attinat
2

05AB1E , 2 बाइट्स

(I

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

औंधा

(    negates nothing
  I  pushes input

I    pushes input
  (  negates input
— jasanborn
स्रोत
इनपुट को केवल एक दिशा में नकारना माना जाता है, जैसा कि दूसरे में है। स्पष्ट रूप से, 1-वर्ण समाधान मान्य नहीं हो सकता।
— अड्म
मेरा बुरा, मैं गलत समझा
— जसनबॉर्न
2

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

-∘0

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

तुच्छ उत्तर। लौटाता है argया ¯arg।

10 बाइट्स गूंगा नहीं होने से बचा (धन्यवाद Adám)।

परिणामस्वरूप 3-बटर को अधिक फिटिंग फ़ंक्शन में बदल दिया।

— जे। सेले
स्रोत
वाह, यह तीन बाइट्स में तुच्छ रूप से किया जा सकता है!
— आदम
दिलचस्प बात यह है कि, आपके पास पहले से ही 3-बाइट का उत्तर है जो इसके विकल्प के रूप में एम्बेडेड है।
— आदम
@ एडम हाँ, मुझे पता था कि वहाँ एक सरल जवाब था। धन्यवाद।
— जे। सल्ल।
2

ट्यूरिंग मशीन भाषा , 39 बाइट्स

द पॉजिटिव

1 r - _ 0
0 l * * 0
0 - _ l 0
0 _ _ r 0

नकारात्मक

0 r _ _ 0
0 l _ - 0
0 * * l 0
0 _ - r 1

यह मेरे विचार से थोड़ा पेचीदा था, ज्यादातर इसलिए कि मुझे अपने 'कोडाइल' त्रुटियों के साथ चलने वाले कोड होने के अपने पूर्वाग्रहों से गुजरना पड़ा।

— ouflak
स्रोत
2

> <> , 5 4 बाइट्स

n-r0

-vविकल्प के साथ स्टैक आरंभीकरण का उपयोग करता है , अपने इनपुट चर को वहां रखें।

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

या फिर उलटफेर की कोशिश करें

व्याख्या

n       Prints whatever is on the stack as a number
 -      Subtract the top 2 elements on the stack.
        There aren't 2 elements, so it crashes.
  r0    Never gets executed

or reversed:

0       Push a 0 onto the stack
 r      reverse the stack (now 0, -v)
  -     Subtract top 2 elements and push result (0-v, ie negated)
   n    Print as number
        The code wraps around and executes again. 
        It crashes on the - as there is only one
        item on the stack: 0.
— steenbergh
स्रोत
2

ढेर बिल्लियों -mn , 2 बाइट्स

-X

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

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

व्याख्या

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

उलटा कार्यक्रम के लिए, आवेदन -mदेता है X-X। फिर, Xकुछ भी नहीं करता है, इसलिए कार्यक्रम प्रभावी रूप से बस है- , जो स्टैक के शीर्ष को नकारता है।

केवल अन्य 2-बाइट समाधान है -=, लेकिन यह लगभग समान है। फर्क सिर्फ इतना है कि= केवल बगल के ढेर के शीर्ष पर स्वैप , न कि पूरे ढेर पर।

लेकिन फिर से, उपयोग करना -mधोखा देने जैसा महसूस होता है, इसलिए नीचे एक समाधान है जो पूरी तरह से प्रतिबिंबित प्रोग्राम का उपयोग करता है।

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

:I<->I:

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

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

व्याख्या

पिछले उत्तर के विचार अभी भी लागू होते हैं : किसी भी मान्य समाधान को युग्मित वर्णों का उपयोग करने की आवश्यकता होती है और I। छह संभावित समाधान (टीआईओ लिंक में शामिल) सभी लगभग समान हैं। -और _इस कार्यक्रम में बराबर हैं, और उनके :द्वारा प्रतिस्थापित किया जा सकता है |या T(जो गैर-शून्य इनपुट के लिए भी ऐसा ही करते हैं और संयोग से शून्य इनपुट के लिए भी काम करते हैं)। मैंने इसे केवल इसलिए समझाया क्योंकि यह सबसे आसान है।

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

:    Swap the input with the -1 below.
I    Move the -1 one stack to the left and turn it into +1.
<    Move another stack left (without taking the value).
-    Negate the zero on top of that stack (i.e. do nothing).

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

उलटा कार्यक्रम है :I>-<I:। आइए देखें कि कैसे चीजें बदलती हैं:

:    Swap the input with the -1 below.
I    Move the -1 one stack to the left and turn it into +1.
>    Move one stack right, i.e. back onto the initial stack which still holds the input.
-    Negate the input.
<    Move back to the left where we've parked the 1.
I    Move that 1 back onto the initial stack and turn it back into a -1.
:    Swap the -1 below the negated input to act as an EOF marker.
— मार्टिन एंडर
स्रोत
2

बैच, 34 बाइट्स

@ECHO.%1 2>MER@
@REM>2 1%=-aa/TES@

इकोस ( ECHO.) इनपुट ( %1)। बाकी की पहली पंक्ति तकनीकी रूप STDERRसे नामक एक फ़ाइल में रीडायरेक्ट करती है MER@, लेकिन यह प्रभावशाली नहीं है।
दूसरी पंक्ति में टिप्पणी की गई है ( REM...)।

औंधा

@SET/aa-=%1 2>MER@
@REM>2 1%.OHCE@

एक अपरिभाषित चर ( ) के बराबर है जो इनपुट ( ) इनपुट ( ) से SET /aघटाना करने के लिए सेट कमांड ( ) के अंकगणितीय मोड का उपयोग करता है । फिर, पहली पंक्ति के बाकी तकनीकी रूप से नामक फ़ाइल पर रीडायरेक्ट करता है , लेकिन यह प्रभावशाली नहीं है। दूसरी पंक्ति में टिप्पणी की गई है ( )।-=%1a0 - inputSTDERRMER@
REM...

— Οurous
स्रोत
यह दिलचस्प लग रहा है। समझाने की परवाह?
— एडम
@ Adám ने एक स्पष्टीकरण जोड़ा, और यह भी महसूस किया कि मेरे पास पीछे की तरफ कार्यक्रम थे।
— अशुभ
2

ब्रेकीलॉग , 2 बाइट्स

&ṅ

बाईं ओर से ब्रैक्लिपॉग का तात्पर्य है इनपुट और दाएं से आउटपुट।
&बाईं ओर कुछ भी अनदेखा करता है और इनपुट को दाएं तरफ से गुजरता है।
ṅइसके प्रत्येक पक्ष को एक दूसरे के नकारात्‍मक संस्‍करणों के लिए विवश किया जाता है।

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

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