58

आवश्यकताएँ:

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

उदाहरण:

इनपुट:

Quick brown fox
He jumped over the lazy dog

आउटपुट:

god yzal eht revo depmuj eH
xof nworb kciuQ

सबसे छोटी जीत।

लीडरबोर्ड:

var QUESTION_ID=242,OVERRIDE_USER=61563;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

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

code-golf string

— थॉमस ओ
स्रोत

5

क्या आप मानक पुस्तकालय कार्यों जैसे PHPstrrev

— मिंग-तांग

क्या आउटपुट को इनपुट के अंतिम न्यूलाइन को अंत के बजाय शुरुआत में रखने की अनुमति है?

— जॉय एडम्स

@ जॉय एडम्स, हां, यह बिल्कुल इनपुट को दोहराने चाहिए।

— थॉमस ओ

53

आपका उदाहरण कुछ गलत है। आपके इनपुट का उल्टा होगा ƃop ʎzɐʃ ǝɥʇ ɹǝʌo pǝdɯnɾ ǝH xoɟ uʍoɹq ʞɔınΌ:; -पी

— निंजाल

मुझे केवल वर्णों का समर्थन करने की आवश्यकता है जो कोड को निष्पादित करने वाले सिस्टम में इनपुट कर सकते हैं?

— गोल्डन रेशियो

25

गोल्फस्क्रिप्ट - 3 वर्ण

-1%

obfuscated संस्करण भी 3 वर्ण है

0(%

यहाँ बताया गया है कि % कैसे काम करता है

— gnibbler
स्रोत

9

हम कभी भी गोल्फस्क्रिप्ट के साथ प्रतिस्पर्धा कैसे कर सकते हैं ??

— थॉमस ओ

12

@Thomas: FlogScript का उपयोग करके, मुझे लगता है। किसी भी मामले में, यदि आप एक तुच्छ कार्य पोस्ट करते हैं, तो समाधानों को समान रूप से तुच्छ होने की अपेक्षा करें। और अगर यह पायथन में तीन विधि कॉल लेता है, अगर सिर्फ गोल्फस्क्रिप्ट में तीन वर्ण हो सकते हैं।

— जॉय

1

@ थोमस: क्षमा करें, यह स्पष्ट नहीं था। यह देखते हुए कि कुछ सदस्यों ने पहले से ही इस बारे में बहुत गर्म चर्चा की थी कि यह प्रतीत होता है कि कोई हास्य नहीं था, यहाँ भी ऐसा ही मानना अनुचित नहीं था।

— जॉय

3

@ जॉय यह अधिक विनम्र निराशा थी क्योंकि गोल्फस्क्रिप्ट अप्रशिक्षित आंख को शोर की तरह लगता है।

— थॉमस ओ

36

तो दूसरा एक अपवित्र है, लेकिन पहला नहीं है। पकड़ लिया।

— C0deH4cker

44

बैश - -

tac|rev

tacrevवर्ण क्रम को उलट देता है , जबकि वर्ण क्रम को उलट देता है।

— marcog
स्रोत

चलो बस अगले कदम और उर्फ कि एक पत्र पत्र आदेश के लिए जाओ! alias z='tac|rev'

— डैनियल स्टैंडेज

18

@ डिनियल मैक्रो को परिभाषित करने के लिए संकलक झंडे का उपयोग करने के समान है, यानी कोड गोल्फ की भावना के खिलाफ।

— mar

मेरे पास rev|tacउसी स्कोर के लिए था - केवल यह कहने के लिए एक नोट जोड़ना कि यह किसी पॉश शेल के लिए काम करता है, न कि सिर्फ बैश के लिए।

— टॉबी स्पाइट

35

ब्रेनफक, 10 अक्षर

,[>,]<[.<]

इतनी सरल भाषा के लिए अच्छी मात्रा में उत्तर देता है।

— केविन ब्राउन
स्रोत

2

डीएनए हर समय अपने आदेश को उलट देता है, इसलिए हो सकता है कि आपने जो कुछ देखा है उसमें जानकारी और गणना की प्रकृति के बारे में कुछ मौलिक हो। मैं इस समाधान के दौरान rosalind.info पर शेल वन-लाइनर्स के साथ समस्याओं को हल करते हुए आया।

— ixtmixilix

9

@ixtmixilix यह वास्तव में केवल स्टैक और चीजों को उलटने के बारे में कुछ मौलिक कहता है।

— क्रंचर

23

सी, 37 बाइट्स

main(_){write(read(0,&_,1)&&main());}

— विलक्षण
स्रोत

कूल, लेकिन यह मेरे लिए काम नहीं करता है।

— जॉय एडम्स

@ जॉय एडम्स: इसे यहाँ आज़माएँ ।

— क्विक्सोटिक

आह, मुझे अनुकूलन के बिना संकलन करना था।

— जॉय एडम्स

21

हास्केल - 21

main=interact reverse

— Konstantin
स्रोत

3

न केवल छोटा, बल्कि पूरी तरह से मुहावरेदार भी :)

— हमार

16

पायथन, 41 40 बाइट्स

import sys;print sys.stdin.read()[::-1]

41 -> 40 - कार्यक्रम के अंत में हटा दिया अर्धविराम।

शायद अनुकूलित किया जा सकता है!

— थॉमस ओ
स्रोत

काश, मेरे पास PowerShell ;-)

— जॉय

6

मार्टियन लोग, हमेशा उपयोगी। [:: - १]

— वोक

1

तो print raw_input()[::~0]]? यह अभी भी पायथन 2 हैprint

— कैलकुलेटरफ्लीन

यहाँ एक कोड गोल्फ प्रविष्टि प्रारूपण टिप है। हमेशा आपने इस प्रारूप में प्रोग्राम को जिस भाषा में लिखा है, उसे लिखें:# Language Name, Character/Byte Count

— dorukayhan

15

पैनकेक स्टैक , 342 316 बाइट्स

Put this nice pancake on top!
[]
Put this  pancake on top!
How about a hotcake?
If the pancake is tasty, go over to "".
Put this delightful pancake on top!
[#]
Eat the pancake on top!
Eat the pancake on top!
Show me a pancake!
Eat the pancake on top!
If the pancake is tasty, go over to "#".
Eat all of the pancakes!

यह मानता है कि इनपुट एक शून्य चरित्र ( ^@कमांडलाइन पर) द्वारा समाप्त हो गया है । उदाहरण रन, दुभाषिया का उपयोग करते हुए :

Put this nice pancake on top!
[]
Put this  pancake on top!
How about a hotcake?
If the pancake is tasty, go over to "".
Put this delightful pancake on top!
[#]
Eat the pancake on top!
Eat the pancake on top!
Show me a pancake!
Eat the pancake on top!
If the pancake is tasty, go over to "#".
Eat all of the pancakes!
~~~~~~~~~~~~~~~~~~~~~~~~
Hello, World!^@
!dlroW ,olleH

— जस्टिन
स्रोत

12

एपीएल, २

⊖⍞

या CircleBar QuoteQuad अगर अक्षर के माध्यम से नहीं आते हैं, तो बस अर्थ है: रिवर्स कीबोर्ड चरित्र इनपुट।

— jpjacobs
स्रोत

अपनी बाइट-गिनती को रोकें! तुम भी जरूरत नहीं है ⍞। ⌽एक पूर्ण अनाम फ़ंक्शन है जिसे असाइन और उपयोग किया जा सकता है f←⌽ f 'The quick brown fox':।

— अदि

^^^^ विजेता ^^^^

— CalculatorFeline

@ एन input: ठीक है, कल्पना ने स्टड से इनपुट प्राप्त करने के लिए कहा, न कि एक स्ट्रिंग शाब्दिक से :)

— jpjacobs

@jpjacobs आम PPGC प्रथा उन भाषाओं के लिए स्टडिन के बजाय इनलाइन तर्क देने की अनुमति देती है जो स्टैड का समर्थन नहीं करती हैं (या जिसके लिए यह अप्राकृतिक है) स्टैडिन।

— एडम

11

पर्ल - 23

print scalar reverse <>

— एंड्रयू
स्रोत

6

आप तीसरे स्थान को हटा सकते हैं।

— तिमवी

6

वास्तव में, print"".reverse<>केवल 17 वर्ण है। और पर्ल 5.10+ के साथ आप sayइसके बजाय का उपयोग करके दो और चार्ट बचा सकते हैं print।

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

4

मुझे पता है कि यह बहुत पुराना है, लेकिन आप यह भी कर सकते हैं: print~~reverse<>16 वर्णों के लिए

— डोम हेस्टिंग्स

5

@DomHastings और पर्ल के साथ 5.10+, say~~reverse<>क्या काम करेगा? 14 चरस।

— टाइमटेक

10

रूबी - 19 अक्षर

puts$<.read.reverse

— Nemo157
स्रोत

10

सी - 47 अक्षर

main(c){if(c=getchar(),c>=0)main(),putchar(c);}

ध्यान दें कि यह O (n) स्टैक स्पेस का उपयोग करता है। इसे ऑनलाइन आज़माएं!

— जॉय एडम्स
स्रोत

अद्भुत!

— st0le 16

1

बस आपका विचार है लेकिन इससे 2-3 महत्वपूर्ण स्ट्रोक की बचत होती है:main(c){(c=getchar())>0&&main(),putchar(c);}

— क्विक्सोटिक

2

क्या सी, मल के रूप में संख्याओं का मूल्यांकन करता है? यदि हां, तो c>=0बन सकता है~c

— साइओस

9

विंडोज पॉवरशेल, ५३ ५४

-join($x=[char[]]($($input)-join'
'))[($x.count)..0]

2011-01-30 (54) - पहला प्रयास

2011-01-30 (53) - इनलाइन लाइन ब्रेक मजेदार हैं।

2011-01-3- (52) - इनबिल्ड वैरिएबल असाइनमेंट भी।

— एक छोटा सा सिक्का
स्रोत

-join($a="$args")[$a.Length..0]अपने आप ही प्रदान किए गए उदाहरण के लिए काम करने लगता है, मेरे पास विंडोज़ के साथ चलने वाली crlfलाइनब्रेक के साथ कोई समस्या नहीं है - psv2 के बारे में निश्चित नहीं है या जब आप यह लिखा था, तो आपने जो भी उपयोग किया था।

— colsw

@ConnorLSW: कि स्टड से भी नहीं पढ़ता है। और $inputएक एन्यूमरेटर पैदावार रेखा है, इसलिए आप इसे इस तरह से स्ट्रिंग नहीं कर सकते।

— जॉय

8

पर्ल 5.1, 14

say~~reverse<>

— Timtech
स्रोत

8

बेफुंज -93 - 11x2 (22 अक्षर)

>~:0`v >:v
^    _$^,_@

इस दुभाषिया का उपयोग करके परीक्षण किया गया ।

— MiffTheFox
स्रोत

19

क्या आप वाकई अपने कीबोर्ड पर रैंडम कीज़ नहीं दबाते हैं?

— थॉमस ओ

@Thomas - क्या आप सुनिश्चित हैं कि आपने लिंक किए गए दुभाषिए का उपयोग करने की कोशिश नहीं की है? यह वेब-आधारित है, यदि आप कुछ भी डाउनलोड करने के बारे में चिंतित हैं।

— MiffTheFox

4

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

— थॉमस ओ

1

हमेशा नहीं : पी

— ताली

7

बाइनरी लैम्ब्डा कैलकुलस - 9 बाइट्स

16 46 80 17 3E F0 B7 B0 40

स्रोत: http://ioccc.org/2012/tromp/hint.html

— C0deH4cker
स्रोत

BLC सीखने के लिए कोई अच्छी जगह जानिए? यह ऐसी मजेदार भाषा लगती है!

— चरण

1

@ यदि आप तर्क सिद्धांत की मात्रा को संभाल सकते हैं तो यह उपयोगी लगता है: tromp.github.io/cl/LC.pdf

— C0deH4cker

6

विखंडन , 16 14 12 बाइट्स

DY$\
?
[Z~K!

व्याख्या

नियंत्रण प्रवाह Dएक डाउन- (1,0)एटम परमाणु के साथ शुरू होता है। ?STDIN, एक समय में एक चरित्र से पढ़ता है, पढ़ने के चरित्र कोड और करने के लिए ऊर्जा के लिए बड़े पैमाने पर की स्थापना 0। एक बार जब हम ईओएफ को हिट करते हैं, ?तो इसके बजाय ऊर्जा को सेट करेंगे 1। [एक पर परमाणु पुनर्निर्देश Zस्विच। जब तक हम पात्रों को पढ़ रहे हैं, ऊर्जा होगी 0, इसलिए परमाणु ऊपर की ओर से विक्षेपित होता है Z। हम परमाणु को क्लोन करते हैं, ?रीडिंग इनपुट रखने के लिए एक कॉपी को वापस लाते हैं। हम करने के लिए अन्य प्रतिलिपि की ऊर्जा बढ़ाने के 1साथ $और ढेर पर धक्का K। तो इनपुट लूप यह है:

DY$\
?
[Z K

जब ऊर्जा 1ईओएफ के कारण होती है , तो Zइसके बजाय परमाणु सीधे गुजरने देगा और 0फिर से ऊर्जा को घटाएगा । ~ऊर्जा को और घटाता है -1। स्टैक से नकारात्मक ऊर्जा पॉप के साथ परमाणु , इसलिए हम पात्रों को विपरीत क्रम में पुनः प्राप्त कर सकते हैं और उनके साथ प्रिंट कर सकते हैं !। अब ध्यान दें कि ग्रिड टॉरॉयडल है, इसलिए परमाणु एक ही पंक्ति के बाएं किनारे पर फिर से दिखाई देता है। याद रखें कि हमने पुश किए गए परमाणुओं की ऊर्जा को पहले बढ़ाया था $, इसलिए परमाणुओं में अभी 1पिछले उत्पादन की तरह ऊर्जा है ?और फिर से सीधे गुजरेंगे Z। EOF के बाद का रास्ता इसलिए है

?
[Z~K!

निचली पंक्ति पर यह लूप तब तक जारी रहता है जब तक कि स्टैक खाली न हो जाए। जब ऐसा होता है, तो परमाणु वापस से परावर्तित Kहो जाता है और उसकी ऊर्जा सकारात्मक हो जाती है ( +1)। ~Decrements यह एक बार फिर (बाईं ओर ले जाना) है, ताकि हम अब मारा Zगैर सकारात्मक ऊर्जा के साथ। यह परमाणु को नीचे की ओर धकेलता है, जैसे कि वह Yजहाँ संग्रहीत होता है, उसके पच्चर में समाप्त होता है , और क्योंकि वहाँ अधिक गतिमान परमाणु नहीं होते हैं, इसलिए कार्यक्रम समाप्त हो जाता है।

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

योग्य क्यों यह मुझे Minecraft की याद दिलाता है?

— उज्ज्वल

वाह, और मुझे लगा कि भाषा के नमूनों में मेरा कार्यान्वयन 16 वर्णों में सबसे छोटा था। प्रभावशाली!

— C0deH4cker

6

> <>, ₁₆ 14 बाइट्स

-2 बाइट्स @ जोकिंग द्वारा

दो साल (!) बाद में, पड़ाव के लिए तर्क के इर्द-गिर्द घूमकर अतिरिक्त -1 को इनपुट पढ़ने से हटा देता है।

i:0(7$.
0=?;ol

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

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

मुख्य अंतर यह है कि मेरा उत्तर इनपुट की तुलना 0 से करता है, और यदि यह कम है (यानी कोई इनपुट नहीं है - iरिटर्न -1 है तो कोई इनपुट नहीं है) यह (1,7) से कूदता है, यदि नहीं, (0) 7)। यदि यह पूर्व में कूदता है, तो यह शीर्ष मूल्य (-1) को पॉप करता है और प्रिंट लूप शुरू करता है। यदि यह बाद में कूदता है, तो यह इनपुट लूप जारी रखता है।

11 बाइट्स, एक त्रुटि के साथ बाहर निकलता है

@JoKing के सौजन्य से

i:0(7$.
~o!

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

मेरा मानना है कि यह अब मेटा सर्वसम्मति के माध्यम से मान्य है।

पिछला उत्तर (14 बाइट्स)

i:0(7$.
~ol0=?;!

— गोभी
स्रोत

2

एक त्रुटि के साथ समाप्त होने से -5 बाइट्स । अन्यथा -2 बाइट्स (खाली इनपुट पर त्रुटियां)। इसके अलावा खाली इनपुट पर मूल त्रुटियां, जो o;

— जो राजा

1

@JoKing oभाग पर अच्छी पकड़ ; उस समय ध्यान नहीं दिया। और बचाने के लिए धन्यवाद। अंतिम -1 से छुटकारा पाने के लिए शून्य की तुलना का चतुर उपयोग।

— कोल

1

हम्म, वास्तव में यह बस के रूप में अच्छी तरह से 13 बाइट्स के लिए काम करता है (विश्वास नहीं कर सकता मैं का आसान स्वैप याद 0=?करने के लिए ?!)

— जो राजा

@JoKing -1 बाइट ? चरित्र 0 के बाद स्टैक टॉप की जाँच करता है, तो लंबाई के साथ तुलना की आवश्यकता नहीं है, बस एल।

— पेलिकन

@TealPelican हाँ, मैंने अपनी दूसरी टिप्पणी

— जो किंग

5

PHP - 38 17 अक्षर

<?=strrev(`cat`);

— अरनौद ले ब्लांक
स्रोत

क्या है cat??

— Xanderhall

1

@Xanderhall शायद से पढ़ता हैstdin

— Pavel

5

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

<!]T[!>

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

एक ही बाइट गिनती के लिए विकल्पों का एक गुच्छा है, जिनमें से अधिकांश अनिवार्य रूप से समान हैं कि वे कैसे काम करते हैं:

व्याख्या

एक छोटा ढेर बिल्लियों प्राइमर:

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

अब वास्तविक कार्यक्रम के लिए:

<    Move the tape head one stack left (onto an empty stack).
!    Bitwise NOT of the implicit zero on top, giving -1.
]    Move back to the original stack, taking the -1 with the tape head.
     We're now back to the original situation, except that we have a -1
     on top.
T    Reverse the stack down to the -1 at the bottom. One of the reasons
     we needed to move a -1 on top is that T only works when the top of
     the stack is nonzero. Since the first byte of the input could have
     been a null-byte we need the -1 to make sure this does anything at
     all.
[    Push the -1 to the stack on the left.
!    Bitwise NOT, turning it back into 0 (this is irrelevant).
>    Move the tape head back onto the original stack.

अन्य सभी 7-बाइट समाधानों को खोजने के लिए Sp3000 ने अपनी पाशविक बल खोज को निर्धारित किया, इसलिए यहां कुछ विकल्प दिए गए हैं:

<]!T![>
>![T]!<
>[!T!]<

ये तीन वैरिएंट अनिवार्य रूप से एक ही हैं, सिवाय इसके कि वे अलग-अलग होते हैं जब बिटवाइज़ की गणना नहीं होती है और क्या हम बाईं ओर या दाईं ओर खाली स्टैक का उपयोग करते हैं।

<]T!T[>
>[T!T]<

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

<*ITI*>

यह भिन्न संस्करण *(XOR 1) के बजाय का उपयोग करता है !, ताकि यह शून्य में बदल जाए +1, और Iएक सशर्त धक्का है जो सकारात्मक मूल्यों और दाएं, नकारात्मक मूल्यों को छोड़ देता है, और उन्हें किसी भी मामले में नकार देता है (जैसे कि हम अभी भी एक साथ समाप्त होते हैं -1जब हम मुठभेड़ करते हैं तो मूल स्टैक के शीर्ष पर T), इसलिए यह अंततः मूल <!]T[!>समाधान के समान काम करता है ।

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

4

PHP, 82 29 24 29 28 वर्ण

<?=strrev(fread(STDIN,2e9));

82 -> 29: उलट जाने पर नई लाइन वर्ण संरक्षित होता है strrev।
29 -> 24: शॉर्टकट सिंटैक्स का उपयोग करता है अब
24 -> 29: अब एक पंक्ति के बजाय सभी लाइनों को पढ़ता है

— केविन ब्राउन
स्रोत

एक समस्या: fgets(STDIN)केवल पहली पंक्ति पढ़ता है।

— कृपया

अब सभी लाइनों को पढ़ने के लिए कोड अपडेट किया गया है।

— केविन ब्राउन

सिवाय आपके पास 1000 वर्णों की एक कृत्रिम सीमा है

— अनाम कायर

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

— केविन ब्राउन

4

बेगुंज -98 - 11 10

#v~
:<,_@#

(Cfunge के साथ परीक्षण किया गया)

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

~#,

जिस तरह से यह काम करता है वह बार-बार स्टैक पर इनपुट पढ़ता है ( ~) एक बार में एक चरित्र, ऊपर कूद ( #) अल्पविराम। जब ईओएफ पहुंच जाता है, तो ~रिफ्लेक्टर के रूप में कार्य करता है और पीसी पलट जाता है, बार-बार ,उछलते हुए ( #) हिलाने पर एक चरित्र ( ) को पॉपअप और आउटपुट करता है ।

— जुगनू
स्रोत

यहाँ एक छोटा संस्करण (10 वर्ण) है: पंक्ति 1: #v~पंक्ति 2 :<,_@#:। मज़ेदार है कि उपयोग करने से jइसमें सुधार नहीं होता है।

— जस्टिन

@Quincunx इस तरह के निहित नकार के रूप में आईपी दिशा का उपयोग करते हुए, चतुर है।

— फायरफली

4

पायथ - 3 5 4 बाइट्स

तो, मूल 3-चार संस्करण ने लाइन क्रम को उल्टा नहीं किया, बस लाइनें। मैं तब इस 5-चार संस्करण के साथ आया था:

_jb.z

मैंने 1 बाइट को @ परिणाम के लिए @FryAmTheEggman के लिए धन्यवाद बचाया:

_j.z

लाइव डेमो।

स्पष्टीकरण:

  .w  read all the input into a list of strings
 j    join (j) by using a newline character
_     reverse the result
      Pyth implicitly prints the result on an expression

मूल (गलत) समाधान:

यह तकनीकी रूप से मायने नहीं रखता है क्योंकि Pyth को 2014 में बनाया गया था, लेकिन यह अभी भी साफ-सुथरा है कि इसे GolfScript के साथ बांधा गया है।

#_w

स्पष्टीकरण:

#    loop while no errors
  w  read a line of input (throws an error on end-of-file or Control-C)
 _   reverse the input line
     Pyth implicitly prints the result on an expression

— kirbyfan64sos
स्रोत

2

कल्पना से मेल नहीं खाता, दुर्भाग्य से - लाइनों के क्रम को भी उल्टा करने की आवश्यकता है।

— DLosc

Fk_.z_kमुझे यकीन है कि किसी को इससे कुछ कम मिल सकता है, लेकिन मुझे यही मिला है।

— gcq

@gcq मेरा एक छोटा संस्करण है (5 वर्ण), लेकिन मुझे इसे संपादित करने का मौका नहीं मिला है।

— kirbyfan64sos

@DLosc फिक्स्ड! मैंने अभी-अभी सारा इनपुट पढ़ा, न्यूलाइन्स के माध्यम से ज्वाइन किया, और उलटा किया।

— kirbyfan64sos

@FryAmTheEggman आह, हाँ! उस बारे में पता नहीं था जब मैंने कुछ महीने पहले यह पोस्ट किया था।

— kirbyfan64sos

4

क्यूबिक्स , ९ by बाइट्स

इस गोल्फ के लिए मार्टिन एंडर को बहुत धन्यवाद:

w;o@i.?\

इसे ऑनलाइन देखें!

यह निम्नलिखित घन बन जाता है ( >प्रारंभिक निर्देश सूचक इंगित करता है):

      w ;
      o @
> i . ? \ . . . .
  . . . . . . . .
      . .
      . .

कार्यक्रम का पहला चरण सभी इनपुट लेना है। iस्टैक पर इनपुट के 1 बाइट डालता है। जब तक इनपुट समाप्त ?नहीं हो जाता w, तब तक आईपी को दाईं ओर मोड़ता है, क्यूब के चारों ओर लपेटता है जब तक कि वह नहीं पहुंचता , जो इसे वापस भेजता है i।

जब इनपुट खत्म हो जाता है, ?तो आउटपुट लूप में प्रवेश करते हुए, IP को उत्तर की ओर बनाता है:

o: स्टैक के शीर्ष पर वर्ण प्रिंट करें
w: दाईं ओर पॉइंटर को 'साइडस्टेप' करें
;: उस चरित्र को पॉप करें जो अभी-अभी छपा था
\: आईपी को दर्शाते हैं, इसे पूर्व में भेजते हैं
?: यदि प्रिंट करने के लिए छोड़े गए हैं, तो दाएं मुड़ें, वापस लूप में।

अंतिम समय ?मारा जाता है, जब स्टैक पर कुछ भी नहीं छोड़ा जाता है, तो इसके बजाय आईपी आगे जारी रहता है:

i: इनपुट का एक बाइट लें। यह होगा-1 जब इनपुट समाप्त हो गया हो।
\: आईपी को प्रतिबिंबित करें, इसे उत्तर में भेजकर:
@: कार्यक्रम समाप्त करें।

9 बाइट का घोल

..o;i?@!/

इसे ऑनलाइन देखें!

घन रूप में:

      । ।
      ओ;
> मैं? @! /। । ।
  । । । । । । । ।
      । ।
      । ।

पहला वर्ण iएनकोडर किया गया है , जो इनपुट का एक कोडकोड लेता है। यदि कोई इनपुट नहीं बचा है, तो यह है -1।

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

आउटपुट लूप सरल है। o;टीओएस आउटपुट और पॉप। पहली बार जब यह चलाया जाता है, -1तो स्टैक के ऊपर होता है, लेकिन एक चरित्र में मैप नहीं होता है और इसलिए इसे अनदेखा किया जाता है। /बाईं ओर जाने के लिए आईपी को दर्शाता है, जहां उसका सामना होता है !@- जो स्टैक खाली होने पर प्रोग्राम को समाप्त कर देता है। अन्यथा, आईपी जारी रहता है, ?फिर से मारता है - क्योंकि स्टैक खाली नहीं है, टीओएस एक चारकोड होना चाहिए, जो सभी सकारात्मक ^{1 हैं} , इसलिए यह आईपी को सही बनाता है और आउटपुट लूप जारी रखता है।

¹ दोनों समाधान यह मानते हैं कि इनपुट में शून्य बाइट्स नहीं होंगे।

— FlipTack
स्रोत

4

05AB1E, 1 बाइट

आर इनपुट को उलट देता है।

— penalosa
स्रोत

1

05AB1E :) का उपयोग करने के लिए धन्यवाद। आपको ,अंत में ज़रूरत नहीं है , क्योंकि स्टैक के शीर्ष को स्वचालित रूप से मुद्रित किया जाता है जब कुछ भी नहीं मुद्रित होता है।

— अदनान

@ अदनान टिप के लिए धन्यवाद।

— पेनालॉसा

4

वम्पस , 12 बाइट्स

i=)!4*0.l&o@

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

मार्टिन के जवाब ने वम्पस के त्रिकोणीय ग्रिड नियंत्रण को अच्छी तरह से दिखाया, लेकिन मुझे लगा कि मैं इस चुनौती को वन-लाइनर के साथ आजमाऊंगा।

समझने में आसान संस्करण (एक बाइट लंबा) है:

i=)!8*0.;l&o@

जो इस तरह काम करता है:

[Input loop]
i        Read a byte of input (gives -1 on EOF)
=)!      Duplicate, increment then logical not (i.e. push 1 if EOF, else 0)
8*       Multiply by 8 (= x)
0        Push 0 (= y)
.        Jump to (x, y), i.e. (8, 0) if EOF else (0, 0) to continue input loop 

[Output]
;        Pop the extraneous -1 at the top from EOF
l&o      Output <length of stack> times
@        Terminate the program

अब आइए गोल्फ संस्करण पर एक नज़र डालें, जो बीच में अलग है:

i=)!4*0.l&o@

गोल्फ संस्करण ;बाहरी 1 को पॉप करने के लिए एक स्पष्ट आदेश की आवश्यकता नहीं होने से एक बाइट बचाता है । ईओएफ पर, यह कार्यक्रम (4, 0)इसके बजाय कूदता है (8, 0)जहां यह 4*0.फिर से निष्पादित होता है - इस समय को छोड़कर, बाहरी -1 शीर्ष पर है! यह हमारे लिए कूदने का कारण बनता है (-4, 0), जो कि लपेटने के कारण (8, 0)इस ग्रिड के लिए समान है , हमें वह मिल रहा है जहां हम एक ही समय में बाहरी मूल्य का उपभोग करना चाहते हैं।

— Sp3000
स्रोत

4

वम्पस , 13 11 बाइट्स

)?\;l&o@
=i

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

व्याख्या

चूंकि वम्पस एक स्टैक-आधारित भाषा है, इसलिए मूल विचार यह है कि स्टैटिन को स्टैडिन को पढ़ें और फिर पूरे स्टैक को ऊपर से नीचे तक प्रिंट करें। यहां दिलचस्प हिस्सा ग्रिड के माध्यम से नियंत्रण प्रवाह है।

नियंत्रण प्रवाह को समझने के लिए, हमें वास्तविक त्रिकोणीय ग्रिड लेआउट को देखने की जरूरत है:

आईपी पूर्व में जा रहे ऊपरी बाएँ कोने में शुरू होता है। हम देख सकते हैं कि बाईं ओर छह कोशिकाओं के समूह के माध्यम से एक लूप है, और एक शाखा से \। जैसा कि आप उम्मीद कर सकते हैं, लूप सभी इनपुट को पढ़ता है, और अंत में रैखिक अनुभाग STDOUT पर परिणाम लिखता है।

आइए पहले लूप देखें। पहले )?\लूप का हिस्सा नहीं होने के कारण यह सोचने में अधिक समझ में आता है कि वास्तविक लूप शुरुआत में है i। तो यहाँ प्रारंभिक बिट है:

)   Increment an implicit zero to get a 1.
?\  Pop the 1 (which is truthy) and execute the \, which reflects the IP
    to move southwest.

फिर लूप शुरू होता है:

i   Read one byte from STDIN and push it to the stack (or -1 at EOF).
    Note that Wumpus's grid doesn't wrap around, instead the IP reflects
    off the bottom edge.
=   Duplicate the byte we've read, so that we can use it for the condition
    later without losing it.
)   Increment. EOF becomes zero (falsy) and everything else positive (truthy).
?\  If the incremented value is non-zero, execute the \ again, which 
    continues the loop. Otherwise (at EOF), the \ is skipped and the
    IP keeps moving east.

यह रैखिक खंड को अंत में छोड़ता है:

;   Get rid of the -1 we read at EOF.
l   Push the stack depth, i.e. the number of bytes we've read.
&o  Print that many bytes.

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

3

PHP - 44 अक्षर

<?=strrev(file_get_contents('php://stdin'));

— ircmaxell
स्रोत

3

पर्ल

print scalar reverse for reverse(<STDIN>);

— हंटर
स्रोत

3

विखंडन , 20 15 बाइट्स

KX$ \
!
SR?J%
~

एल्गोरिथ्म मार्टिन के समान है, लेकिन कार्यान्वयन में काफी भिन्नता है।

यह काम किस प्रकार करता है

सब कुछ शुरू होता है R, जो द्रव्यमान 1 और ऊर्जा 0 के साथ एक पूर्ववर्ती परमाणु जारी करता है।

मारने पर ?, एक इनपुट चरित्र परमाणु के द्रव्यमान के रूप में सहेजा जाता है, और ऊर्जा 0 पर छोड़ दी जाती है जब तक कि स्टड ईओएफ वापस नहीं करता है, जिस स्थिति में ऊर्जा 1 हो जाती है।

Jविखंडन की छलांग कमान है, और एक परमाणु को अपनी वर्तमान ऊर्जा के बराबर कई कोशिकाओं को आगे बढ़ाता है, परमाणु को 0 ऊर्जा के साथ छोड़ देता है। अभी के लिए, हमारे परमाणु में 0 ऊर्जा है और इस कमांड को अनदेखा करता है।

हम फिर हड़ताल करते हैं %, जो एक स्विच है। साथ 0 से अधिक ऊर्जा, हमारे परमाणु नीचे निर्देशित किया जाएगा (जैसे कि एक से परिलक्षित \, दर्पण), लेकिन क्योंकि हम वास्तव में 0 ऊर्जा है, हम विपरीत दर्पण से ऊपर की तरफ भेजा जाता है /।

हमारा परमाणु तब तक जारी रहता है जब तक कि वह एक दूसरा दर्पण नहीं गिरा देता, \इस बार उसे छोड़ते हुए निर्देशित करता है।

हम परमाणु की ऊर्जा को 1 के साथ बढ़ाते हैं $, और Xपरमाणु की नकल करने के लिए उपयोग करते हैं। एक प्रति पर वापस करने के लिए प्रतिबिंबित करेगा $आदेश (2 ऊर्जा के साथ कि प्रति छोड़कर) और अन्य प्रतिलिपि, ढेर करने पर आगे बढ़ा दिया जाएगा K।

जब तक यह %स्विच को फिर से हिट नहीं करता तब तक हमारी प्रतिबिंबित प्रति यात्रा पीछे से आती है । अब जब हमारे पास एक सकारात्मक ऊर्जा है, तो हम प्रतिबिंबित करते हैं जैसे कि हमने एक \दर्पण मारा था , अगले पर बोर्ड के चारों ओर लपेटता है Sऔर हमारी ऊर्जा को 1 तक घटाता है।

Sआदेश 1 ऊर्जा की खपत हमारे दिशा संरक्षित करने के लिए होगा। अगर हमारे पास कोई ऊर्जा नहीं होती, तो परमाणु ऐसे डिफ्लेक्ट हो जाता, जैसे \दर्पण से टकराकर नीचे की ओर। इसके बजाय, हम फिर से दाईं ओर जाते हैं और अधिक इनपुट उठाते हैं ?और चक्र दोहराता है।

एक बार जब हमारा परमाणु ईओएफ तक पहुंच जाता है, तो ?कमांड परमाणु में 1 ऊर्जा स्टोर करेगा। इस प्रकार, जब हम Jइस समय कमांड को हिट करते हैं, तो हम %स्विच पर पूरी तरह से छोड़ देते हैं और S0 ऊर्जा के साथ स्विच पर उतर जाते हैं ।

अब, चूंकि हमारी ऊर्जा को कूदने में खपत किया गया था, इसलिए हमारी दिशा स्विच द्वारा संरक्षित नहीं है S, लेकिन हम नीचे की ओर निर्देशित हैं। फिर हम अपनी ऊर्जा को -1 के साथ ~कमांड के साथ घटाते हैं और बोर्ड के चारों ओर लपेटते हैं। जब एक नकारात्मक ऊर्जा के साथ मारा जाता है, तो Kकमांड एक धक्का देने के बजाय एक परमाणु को पॉप करता है। हम अपने नए पॉपअप परमाणु के साथ आउटपुट करते हैं !, और Sस्विच को बायपास करने के लिए उस परमाणु की 1 ऊर्जा का उपयोग करते हैं , और चक्र पूरा होता है।

यदि स्टैक Kखाली था, तो हमारे परमाणु की ऊर्जा उपेक्षित होती है (परिणामस्वरूप +1 ऊर्जा) और इसे वापस ~कमांड पर प्रतिबिंबित किया जाता है , इसे ऊर्जा के साथ छोड़ दिया जाता है। 0. Sफिर से मारने पर , हम सही पर विक्षेपित होते हैं, जब तक कि ?मारा नहीं जाता। चूंकि ईओएफ पहुंच गया है, ?परमाणु को नष्ट कर देता है और कार्यक्रम को समाप्त कर देता है।

— BrainSteel
स्रोत

3

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

,)";@
:".(

आम तौर पर, भूलभुलैया कार्यक्रमों को मेज़ से मिलता-जुलता माना जाता है, लेकिन मैं इसमें लूप को इतनी मजबूती से संपीड़ित करने में सक्षम था, कि कोड एक ही ब्लॉक (कमरा?) के रूप में समाप्त हो गया। यहाँ थोड़ा विस्तारित संस्करण है जो नियंत्रण प्रवाह का पालन करना आसान बनाता है:

,""")""""""";""@
"   "   "   "
:""""   ."""(

,STDIN से एक बार में एक बाइट पढ़ता है जब तक कि यह EOF से टकराकर वापस नहीं लौटता -1। )वेतन वृद्धि इस मान ताकि हम कुछ प्रत्येक पढ़ने बाइट और शून्य EOF पर के लिए सकारात्मक मिलता है। :डुप्लिकेट प्रत्येक बाइट पढ़ें।

एक बार जब हम ईओएफ से टकराते हैं, तो निर्देश सूचक दूसरे लूप में पहुंचता है, जहां यह बार-बार एक मूल्य ;(शुरुआत में ईओएफ, बाद में प्रत्येक बाइट की दूसरी प्रति) के साथ अलग हो जाता है, फिर अगले मूल्य को घटाता है (और इसके साथ प्रिंट करता है .। उस दूसरी प्रति (जो हमेशा सकारात्मक है) के कारण हम जानते हैं कि आईपी शीर्ष पर राइट-टर्न लेगा और इस लूप में जारी रहेगा।

सभी बाइट्स प्रिंट होने के बाद स्टैक के शीर्ष पर फिर से शून्य होता है और आईपी सीधे आगे बढ़ता रहता है @और प्रोग्राम समाप्त होता है।

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

TheNumberOne और Sp3000 को टोपी की एक टिप, जिनके स्वयं के प्रयासों ने इस अत्यधिक संपीड़ित समाधान को खोजने में बहुत मदद की।

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

स्टडआउट पर रिवर्स स्टड और जगह

गोल्फस्क्रिप्ट - 3 वर्ण

बैश - -

ब्रेनफक, 10 अक्षर

सी, 37 बाइट्स

हास्केल - 21

पायथन, 41 40 बाइट्स

पैनकेक स्टैक , 342 316 बाइट्स

एपीएल, २

पर्ल - 23

रूबी - 19 अक्षर

सी - 47 अक्षर

विंडोज पॉवरशेल, ५३ ५४

पर्ल 5.1, 14

बेफुंज -93 - 11x2 (22 अक्षर)

बाइनरी लैम्ब्डा कैलकुलस - 9 बाइट्स

विखंडन , 16 14 12 बाइट्स

व्याख्या

> <>, 16 14 बाइट्स

-2 बाइट्स @ जोकिंग द्वारा

11 बाइट्स, एक त्रुटि के साथ बाहर निकलता है

@JoKing के सौजन्य से

पिछला उत्तर (14 बाइट्स)

PHP - 38 17 अक्षर

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

व्याख्या

PHP, 82 29 24 29 28 वर्ण

बेगुंज -98 - 11 10

पायथ - 3 5 4 बाइट्स

स्पष्टीकरण:

मूल (गलत) समाधान:

स्पष्टीकरण:

क्यूबिक्स , ९ by बाइट्स

9 बाइट का घोल

05AB1E, 1 बाइट

वम्पस , 12 बाइट्स

वम्पस , 13 11 बाइट्स

व्याख्या

PHP - 44 अक्षर

पर्ल

विखंडन , 20 15 बाइट्स

यह काम किस प्रकार करता है

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

> <>, ₁₆ 14 बाइट्स