22

एक प्रोग्राम बनाएँ, जो इनपुट स्ट्रिंग को इनपुट स्ट्रिंग से शुरू होने वाले पैलिंड्रोम में परिवर्तित करता है। कार्यक्रम को स्वयं एक तालमेल होना चाहिए।

उदाहरण के लिए इनपुट: neverodप्रिंट करें neveroddoreven। आपको मल्टी-वर्ड, मल्टी-लाइन इनपुट भी संभालना चाहिए।

— tmp
स्रोत

2

यह इस सवाल से बहुत मिलता-जुलता है , सिवाय इसके कि हम जाँच के बजाय उत्पन्न कर रहे हैं। संभावना है कि एक ही चाल को कार्यक्रम को एक पैलेंड्रोम बनाने के लिए नियोजित किया जाएगा, हालांकि।

— Sp3000

2

मैं सवाल को पूरी तरह से समझ सकता हूं, लेकिन जवाब क्यों नहीं दिया गया?

— जॉन ड्वोरक

2

@JDDvorak मैं इसका अनुमान लगा रहा हूं क्योंकि यह टिप्पणियों को तालमेल बनाने के लिए उपयोग करता है, जो विशेष रूप से उस रणनीति को ठीक बनाता है। यह एक बहुत ही दिलचस्प तरीका नहीं है और विशेष रूप से कम से कम एक प्रश्न पर प्रतिबंध लगा दिया जाता है, जिसमें आवश्यक है कि कोडिनफ़ॉर्म कोड: codegolf.stackexchange.com/q/28190/15599 । Tomek, प्रोग्रामिंग पहेलियों और कोडगोल्फ में आपका स्वागत है। मैं वैसे भी upvoting कर रहा हूं ताकि आप हमारे सैंडबॉक्स तक पहुंचें meta.codegolf.stackexchange.com/q/2140/15599 हालांकि मैं आपको सलाह देता हूं कि आप एक दूसरे से पूछने से पहले कुछ सवालों के जवाब दें। इसके अलावा, पोस्टिंग से पहले इसी तरह के सवालों के लिए खोज करना याद रखें

— लेवल रिवर सेंट

क्या कार्यों की अनुमति है (पूरे कार्यक्रमों के बजाय)?

— नीमी

क्या हम उत्पन्न पालि के लिए एक सीमांकक का उपयोग कर सकते हैं? अर्थात neverod-> neverodadoreven( aबीच में)

— R>

26

दलयोग एपीएल, 6 4

⌽,,⌽

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

अन्य उपाय:

⌽,⊢⊢,⌽
⌽⊢⊢,⊢⊢⌽

व्याख्या

वे बस हैं:

{⌽((,⍵),(⌽⍵))}
{⌽((,⍵)⊢((⊢⍵),(⌽⍵)))}
{(⌽⍵)⊢((⊢⍵),((⊢⍵)⊢(⌽⍵)))}

मोनाडिक ,और ⊢स्ट्रिंग्स पर कुछ नहीं करता है। डायैडिक अवतलता ,है। डायैडिक ⊢अपना सही संचालन वापस करता है। और ⌽जाहिर है उलटा है।

— jimmy23013
स्रोत

1

ध्यान दें कि यह केवल Dyalog APL में काम करता है।

— फूज़लक्ल

22

piet 19x2 = 38

इनपुट स्वीकार करता है जब तक कि यह 0x00 से सामना नहीं करता है। समाप्त नहीं करता है, लेकिन उत्पादन सही होगा।

— captncraig
स्रोत

3

सममित: हाँ; पैलंड्रोमिक:?

— ब्लू

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

— फलों का

1

@EsolangingFruit हालांकि कोई यह तर्क दे सकता है कि एक पालिंद्रा के बराबर की छवि सेंट्रोसिमेट्रिक होनी चाहिए।

— जोनाथन फ्रेच

17

एपीएल, ९

⍞←Z,⌽,Z←⍞

स्पष्टीकरण:

       Z←⍞  ⍝ read a line from the keyboard, and store it in Z
      ,     ⍝ flatten into one-dimensional array (this has no effect here)
     ⌽      ⍝ reverse
   Z,       ⍝ concatenate Z to its reverse
⍞←         ⍝ explicit output (not necessary, but it makes it a palindrome)

— मारीनस
स्रोत

13

सीजेएम, 13 बाइट्स

qL;_-1%1-_;Lq

qL;                 "Read the input, Put an empty array on stack and pop that array";
   _-1%             "Now the string is on top, make a copy and reverse the copy";
       1-           "Remove occurrences of integer 1 from the reverse string. [no-op]";
         _;         "Copy the reversed string and pop it";
           Lq       "Put an empty array on stack and read the remaining input. Remaining";
                    "input will be empty as we already read whole of the input";

इसे यहाँ ऑनलाइन आज़माएँ

या ..

GolfScript, 9 बाइट्स

.-1%}%1-.

.                 "Input is already on stack. Make a copy";
 -1%              "Reverse the copy";
    }             "This marks the beginning of a super comment. Anything after this in the";
                  "code is a comment";
     %1-.         "no-op comment";

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

— अनुकूलक
स्रोत

मुझे लगता है कि आपने अपने "सुपर-कमेंट" के साथ गोल्फस्क्रिप्ट पार्सर में एक बग पाया है। ध्यान रहे, एक साधारण #टिप्पणी भी वहीं काम करेगी।

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

@IlmariKaronen मुझे नहीं, }उम्र के बाद से एक सुपर टिप्पणी के रूप में जाना जाता है :)

— ऑप्टिमाइज़र

8

सी ++, 162 बाइट्स

#include<cstdio>//
main(){int c=getchar();if(c>0)putchar(c),main(),putchar(c);}//};)c(rahctup,)(niam,)c(rahctup)0>c(fi;)(rahcteg=c tni{)(niam
//>oidtsc<edulcni#

सी, 117 बाइट्स

main(c){c=getchar();if(c>0)putchar(c),main(),putchar(c);}//};)c(rahctup,)(niam,)c(rahctup)0>c(fi;)(rahcteg=c{)c(niam

— tmp
स्रोत

1

भगवान दो स्लैश का आशीर्वाद दें

— Abr001am

7

हास्केल, 102 + 22 = 124 बाइट्स

a b fa=fa<|>b
fa=reverse>>=a
main=interact fa
niam=main
af tcaretni=niam
a=>>esrever=af
b>|<af=af b a

इसे Control.Applicativeस्कोप में मॉड्यूल के साथ चलाया जाना चाहिए , जिसे ghci init फाइल के जरिए सेट किया जा सकता है.ghci : :m Control.Applicative(-> 13: बाइट्स)।

कोई टिप्पणी की चाल, सिर्फ 7 कार्य जहां उनमें से 4 कभी नहीं कहा जाता है।

यदि फ़ंक्शन (कार्यक्रमों के बजाय) की अनुमति है:

हास्केल, 55 + 22 = 77 बाइट्स

a b fa=fa<|>b
f=reverse>>=a
a=>>esrever=f
b>|<af=af b a

उपयोग f "qwer"->"qwerrewq"

संपादित करें: पिछला संस्करण गलत था।

— nimi
स्रोत

3

अजगर, 11 बाइट्स

+z_z " z_z+

पायथ में, एक स्थान के साथ पूर्ववर्ती कुछ भी मुद्रित नहीं है। इसलिए हम केवल स्ट्रिंग के ऋणात्मक को जोड़ते हैं, एक स्थान रखते हैं, एक स्ट्रिंग शुरू करते हैं और बोली के बाईं ओर दर्पण करते हैं "

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

3

रूबी, ४४

s=gets p
s+=s.reverse||esrever.s=+s
p steg=s

स्टड से इनपुट के रूप में एक बहुस्तरीय स्ट्रिंग लेता है, उस स्ट्रिंग के रूबी प्रतिनिधित्व को इसके विपरीत करने के लिए आउटपुट करता है। दूसरी पंक्ति पर मृत कोड बाहर टिप्पणी करने के ||साथ बदलकर एक चरित्र ट्रिम कर सकते हैं #।

— histocrat
स्रोत

s=gets p! =p steg=s

— कैलकुलेटर

... सच है, मुझे नहीं पता कि मेरा क्या मतलब है।

— हिस्टोक्रेट २५'१६

3

जोल्फ, 9 बाइट्स

नई भाषा, गैर-प्रतिस्पर्धात्मक

यहाँ कोशिश करो

aη+i_i+ηa

स्पष्टीकरण: मैंने केवल जोल्फ को शुरू किया था और मुझे नहीं लगता कि मैं इसे ठीक से समझा रहा हूं।

aη         alert function, arity of the function can't be reduced by 1 so it stays at 1
  +i_i     concatenate the input with the reversed input
      +η   arity of the add reduced by 1, it just takes the following character (a)
        a  returns the input

— फूल जाती है
स्रोत

1

PPCG में आपका स्वागत है! मैंने आपका अन्य उत्तर देखा, और मैंने इस भाषा का उपयोग करते हुए आपकी सराहना की! यह मेरा अपना आविष्कार है, मुझे आशा है कि आप इसे पसंद करेंगे :) यह एक बहुत अच्छा समाधान है, बहुत अच्छा किया! जिस तरह से आपने ηसमाधान में इस्तेमाल किया , मुझे बहुत अच्छा लगा। आप म्यू को समाप्त करके दो बाइट्स बचा सकते हैं, जैसे a+i_i+a:। (जोल्फ के पास बाकी तर्कों को भरने के लिए निहित इनपुट भी है, लेकिन यह एक समस्या नहीं है क्योंकि केवल एक इनपुट एक समय में है।) मैं आपके मूल समाधान को उत्तर में रखूंगा, फिर भी।

— कॉनर ओ'ब्रायन

@ C @ O'Bᴏɴᴏʀ धन्यवाद! मैंने सिर्फ एक गोल्फ भाषा का चयन किया है जो बहुत डरावनी नहीं लगती है और इसमें कूद पड़ी है, मुझे यह समझ में आ रहा है। मैं यह पता लगाने की कोशिश कर रहा था कि η कहां से आया है और मुझे पता है कि यह मेरे शुरुआती बिंदु + i_i + को ठीक करने की कोशिश कर रहा था। जानकारी के लिए धन्यवाद!

— सूज गया

3

पॉवरशेल, 67

$args|%{$_+-join$_[$_.Length..0]}#}]0..htgneL._$[_$nioj-+_${%|sgra$

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

जैसा कि @mazzy ने सुझाव दिया था कि स्थिर रेंज का उपयोग करते समय कोड को 12 बाइट्स से छोटा किया जा सकता है। यह, हालांकि, इनपुट लंबाई को 9KBytes तक सीमित करता है। सैद्धांतिक रूप से 9MBytes संभव होगा, लेकिन यह कोड को काफी धीमा कर देगा।

$args|%{$_+-join$_[9kb..0]}#}]0..bk9[_$nioj-+_${%|sgra$

— जे। बर्गमैन
स्रोत

1

वैकल्पिक 67 बाइट्स:param($s)$s+-join$s[$s.Length..0]#]0..htgneL.s$[s$nioj-+s$)s$(marap

— mazzy

यदि इनपुट स्ट्रिंग की लंबाई कम है तो 9Kbytes तब $args|%{$_+-join$_[9Kb..0]}#}]0..bK9[_$nioj-+_${%|sgra$(55 बाइट्स)

— mazzy

2

फजी ऑक्टो गुआकामोल, 17 बाइट्स

_{एफओजी इस चुनौती से नया है, इसलिए यह गैर-प्रतिस्पर्धात्मक है।}

^dz''sjX@Xjs''zd^

19 बाइट्स में Alt समाधान:

^Czs''.jX@Xj.''szC^

वे दोनों इनपुट, डुप्लिकेट और रिवर्स लेते हैं, और स्टैक में शामिल होते हैं।

स्पष्टीकरण:

^dz''sj@js''zd^
^                # Get input
 d               # Duplicate ToS (input)
  z              # Reverse ToS
   ''            # Push empty string (for joining separator)
     s           # Move the empty string to the inactive stack
      j          # Join the active stack with the top of the inactive stack as the delimiter and push the result.
       X         # Print the ToS
        @        # End the program
        Xjs''zd^  # Backwards version of the beginning.

— Rɪᴋᴇʀ
स्रोत

इसके अलावा, नॉनकंपेटिंग: पी

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ उफ़। : P

— R

1

छोटेबड़े , ४०

|=||==>|=|=|=+|=>==||==>=|+=|=|=|>==||=|

मेरा पहला विचार ब्रेनफक था, लेकिन ब्रेसिज़ का मिलान करना असंभव है ... सौभाग्य से छोटे बीएफएफ में सरल प्रवाह नियंत्रण है।

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

टिप्पणी की:

|=|                        Retrieve a byte of input.
|                          Positive (opening) bracket.
   ==                      Output the byte.
   >                       Move the pointer in positive direction.
   |=|                     Retrieve a byte of input.
   =                       Switch direction to negative.
|                          Negative (closing) bracket.
=                          Switch direction.
+                          Increment byte to execute return loop.
|                          Opening bracket.
   =>                      Move the pointer in negative direction.
   ==                      Output the byte.
|                          Closing bracket.
|=|                        Output the null terminator.
|==>|=|=|=+|=>==|          ...and keep null terminating it just to be sure.

ध्यान दें कि यदि आप इसे 2 बिट निर्देशों में एन्कोड करते हैं, तो यह आकार को 10 बाइट्स में कटौती करता है (एक palindrome नहीं होगा)।

— Comintern
स्रोत

1

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

a=input()#
print(a+a[::-1])#([1-::]a+a)tnirp
#()tupni=a

मैंने एक समाधान खोजने की पूरी कोशिश की, जिसमें केवल एक ही लाइन का उपयोग किया गया था, लेकिन मेरे पास कोई भाग्य नहीं था।

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

a=input()#()tupni=a#
print(a+a[::-1])#([1-::]a+a)tnirp
#a=input()#()tupni=a

मेरा मूल प्रयास जिसमें हर पंक्ति एक पैलिंड्रोम है। मुझे नहीं लगता कि यह इस चुनौती के लिए आवश्यक है, लेकिन मैंने इसे सिर्फ मामले में शामिल किया है।

— Noomann
स्रोत

1

एक-पंक्ति लेकिन उससे भी लंबी (73, चूंकि lambdaइतनी लंबी है):print((lambda a:a+a[::-1])(input()))#)))(tupni()]1-::[a+a:a adbmal((tnirp

— no1xsyzy

बहुत अच्छा। मैं कम्बख्तों से कम परिचित हूं, लेकिन मैं धीरे-धीरे उनके आदी हो रहा हूं। साझा करने के लिए धन्यवाद।

— नोमेन

1

विटसी, 9 बाइट्स

z:Zr?rZ:z
z          Grab all string input from the command line arguments.
 :         Duplicate this stack.
  Z        Print all elements in this stack as a string.
   r       Reverse (reverses an empty stack).
    ?      Go right a stack.
     r     Reverse (reverses the input).
      Z    Print all elements in this stack as a string.
       :   Duplicate the stack (duplicates an empty stack).
        z  Grab all input from the command line (the command line arguments stack is already empty).

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

— एडिसन क्रम्प
स्रोत

1

Befunge , 37 बाइट्स

~:0`!#v_:,
  >:#,_@_,#:>  
,:_v#!`0:~

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

शीर्ष पंक्ति इनपुट के प्रत्येक वर्ण को धक्का देती है और प्रिंट करती है। दूसरी पंक्ति (इससे पहले @) स्टैक को रिवर्स में प्रिंट करती है, लेकिन हम _रीडिंग इनपुट खत्म होने पर -1 उत्पन्न करने के लिए कंटेस्टेंट में प्रवेश करते हैं। कोड के अन्य आधे (उन बदसूरत अनुगामी newlines सहित) स्रोत को एक पैलिंड्रोम बनाते हैं, लेकिन नेवर चलता है।

— लीनुस
स्रोत

1

सी # ( 33 32 + 1) * 2 = 68 66 बाइट्स

(।) के उपयोग के लिए 2 बाइट्स को बचाया

s=>s+s.Aggregate("",(a,b)=>b+a);//;)a+b>=)b,a(,""(etagerggA.s+s>=s

ओह अच्छा पुराना मेमना, तुम इसे पकड़ सकते हो

Func<string, string> f=<lambda here>

और फिर इसके साथ कॉल करें

f("neverod")

— hstde
स्रोत

1

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

;print$_=<>,~~reverse;m;esrever~~,><=_$tnirp;

बहुत सीधा, printइनपुट ( $_=<>) इसके बाद है reverse। reverseरिटर्न $_क्योंकि हम इसे स्केलर संदर्भ में उपयोग कर रहे हैं ~~। फिर हम लिपि के उलट, शून्य संदर्भ में, मिलान के रूप में m//उपयोग करते हैं ;।

यदि हम छापामार कर सकते हैं तो हमें एक पैलिंड्रोम नहीं बनाना होगा, esrever,><=_$tnirpहम कोड को 43 बाइट्स तक छोटा कर सकते हैं :

g.print$_=<>,reverse.m.esrever,><=_$tnirp.g

प्रयोग

echo -n 'neverod' | perl -e 'g.print$_=<>,reverse.m.esrever,><=_$tnirp.g'
neveroddoreven

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

25 बाइट्स कोड + 1 के लिए शामिल है -p।

$_.=reverse;m;esrever=._$

मुझे नहीं लगता कि यह मान्य है क्योंकि इसे -pध्वज की आवश्यकता है जो मुझे नहीं लगता कि आसानी से स्क्रिप्ट सामग्री में जोड़ा जा सकता है ताकि एक सच्चा तालमेल बनाया जा सके। ऊपर की तरह बहुत अधिक कॉल, इस तथ्य पर निर्भर करता है कि बंद करने के लिए पर्दे के पीछे (नए पर्ल्स पर -pभी) जोड़ता है ।;m//

प्रयोग

echo -n 'neverod' | perl -pe ';$_.=reverse;m;esrever=._$;'
neveroddoreven

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

0

अजगर, १५

 k k+ z_z +k k

शुरुआत में और अंत में अंतरिक्ष को नोटिस करें।

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

चूंकि सफेद स्थान को छोड़कर हर आउटपुट को दबा देता है +z_z, आप kएस और शाब्दिक को 0. 0. 1 2+ z_z +2 1या से बदल सकते हैं T Z+ z_z +Z T।

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

— Jakube
स्रोत

1

मेरे पास पाइथ में 11 एक है, जिसे मैंने अभी तक पोस्ट नहीं किया है। मुझे लगा कि आप इसे जरूर हराएंगे;)

— ऑप्टिमाइज़र

0

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

मैं "टिप्पणी चाल" का उपयोग नहीं कर रहा हूँ, लेकिन मैं बच गए उद्धरण चिह्न चाल lol का उपयोग कर रहा हूं।

"a\"};))''(nioj.)(esrever.)''(tilps.b(tacnoc.b nruter{)b(a noitcnuf";function a(b){return b.concat(b.split('').reverse().join(''));};"\a"

— स्टीव
स्रोत

4

मुझे नहीं लगता कि यह मायने रखता है; दो केंद्रीय चार्ट हैं ";। ;स्ट्रिंग के अंदर अंतिम चार के रूप में जोड़ना इसे ठीक करना चाहिए।

— ETHproductions

जैसा कि यह खड़ा है यह उत्तर अमान्य है। कृपया या तो इसे ठीक करें या इसे हटा दें।

— जोनाथन फ्रीच

0

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

p=>p+[...p].reverse().join``//``nioj.)(esrever.]p...[+p>=p

— ericw31415
स्रोत

0

PHP, 28 + 1 + 28 = 57 बाइट्स

<?=($x=$argv[1]).strrev($x);#;)x$(verrts.)]1[vgra$=x$(=?<

कमांड लाइन तर्क से इनपुट लेता है। बहु-शब्द के लिए उद्धरण, बहु-पंक्ति के लिए नई-नई पंक्तियों से बचें।

— टाइटस
स्रोत

0

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

s=input();print s+s[::-1]#]1-::[s+s tnirp;)(tupni=s

मैं हैरान हूँ कोई भी इस बारे में सोचा! उद्धृत इनपुट ( 'या ") की आवश्यकता है । यदि कार्यों की अनुमति थी, तो मैं इसके बजाय 37 बाइट्स के लिए कर सकता था:

lambda x:x+x[::-1]#]1-::[x+x:x adbmal

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

0

सी ++ 14, 152 116 बाइट्स

अनाम लैम्ब्डा के रूप में, sमाना जाता हैstring

[](auto s){decltype(s)r;for(auto c:s){r=c+r;}return s+r;}//};r+s nruter};r+c=r{)s:c otua(rof;r)s(epytlced{)s otua(][

पुराना समाधान:

[](auto s){auto r=s;for(auto p=s.rbegin()-1;++p!=s.rend();r+=*p);return r;}//};r nruter;)p*=+r;)(dner.s=!p++;1-)(nigebr.s=p otua(rof;s=r otua{)s otua(][

उपयोग:

auto f=[](auto s){decltype(s)r;for(auto c:s){r=c+r;}return s+r;};

main(){
 string a="123456789";
 cout << f(a) << endl;
}

— कार्ल नेफ
स्रोत

0

05AB1E , 5 बाइट्स

Â«q«Â

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

स्पष्टीकरण:

Â        # Bifurcate (short for Duplicate & Reverse) the (implicit) input
         #  i.e. "neverod" → "neverod" and "doreven"
 «       # Concat both together
         #  i.e. "neverod" and "doreven" → "neveroddoreven"
  q      # Exit the program (and implicitly output the concatted result)
   «Â    # No-ops

या वैकल्पिक रूप से:

R«q«R

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

जहां Rरिवर्स है, और «इनपुट को फिर से संक्षेप में ले जाता है।

नोट: अगर हमें neverodorevenइनपुट के लिए आउटपुट की अनुमति है neverod, जो अभी भी एक palindrome है, तो इसे 1 बाइट में किया जा सकता है बजाय palindromize बिलिन के साथ:

û

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

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

0

x86-64 विधानसभा (Microsoft x64 बुला सम्मेलन), 89 बाइट्स:

80 39 00 48 8B D1 4C 8B C1 74 0B 48 FF C2 49 FF C0 80 3A 00 75 F5 48 FF CA 8A 02 41 88 00 48 8B C2 48 FF CA 49 FF C0 48 3B C1 77 ED C3 ED 77 C1 3B 48 C0 FF 49 CA FF 48 C2 8B 48 00 88 41 02 8A CA FF 48 F5 75 00 3A 80 C0 FF 49 C2 FF 48 0B 74 C1 8B 4C D1 8B 48 00 39 80

disassembled:

 0000000000000000: 80 39 00           cmp         byte ptr [rcx],0
 0000000000000003: 48 8B D1           mov         rdx,rcx
 0000000000000006: 4C 8B C1           mov         r8,rcx
 0000000000000009: 74 0B              je          0000000000000016
 000000000000000B: 48 FF C2           inc         rdx
 000000000000000E: 49 FF C0           inc         r8
 0000000000000011: 80 3A 00           cmp         byte ptr [rdx],0
 0000000000000014: 75 F5              jne         000000000000000B
 0000000000000016: 48 FF CA           dec         rdx
 0000000000000019: 8A 02              mov         al,byte ptr [rdx]
 000000000000001B: 41 88 00           mov         byte ptr [r8],al
 000000000000001E: 48 8B C2           mov         rax,rdx
 0000000000000021: 48 FF CA           dec         rdx
 0000000000000024: 49 FF C0           inc         r8
 0000000000000027: 48 3B C1           cmp         rax,rcx
 000000000000002A: 77 ED              ja          0000000000000019
 000000000000002C: C3                 ret
 000000000000002D: ED                 in          eax,dx
 000000000000002E: 77 C1              ja          FFFFFFFFFFFFFFF1
 0000000000000030: 3B 48 C0           cmp         ecx,dword ptr [rax-40h]
 0000000000000033: FF 49 CA           dec         dword ptr [rcx-36h]
 0000000000000036: FF 48 C2           dec         dword ptr [rax-3Eh]
 0000000000000039: 8B 48 00           mov         ecx,dword ptr [rax]
 000000000000003C: 88 41 02           mov         byte ptr [rcx+2],al
 000000000000003F: 8A CA              mov         cl,dl
 0000000000000041: FF 48 F5           dec         dword ptr [rax-0Bh]
 0000000000000044: 75 00              jne         0000000000000046
 0000000000000046: 3A 80 C0 FF 49 C2  cmp         al,byte ptr [rax+FFFFFFFFC249FFC0h]
 000000000000004C: FF 48 0B           dec         dword ptr [rax+0Bh]
 000000000000004F: 74 C1              je          0000000000000012
 0000000000000051: 8B 4C D1 8B        mov         ecx,dword ptr [rcx+rdx*8-75h]
 0000000000000055: 48 00 39           add         byte ptr [rcx],dil
 0000000000000058: 80

ध्यान दें कि retनिर्देश के बाद का कोड 2Cअनुपलब्ध है, इसलिए यह मायने नहीं रखता कि यह बकवास है

— गोविंद परमार
स्रोत

0

जाप , 4 बाइट्स

êêêê

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

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

U.ê("ê".ê("ê"))  Transpiled to JS

       .ê("ê")   String.ê(string): true if `this` is palindrome
    "ê".ê("ê")   true (treated same as 1)
U.ê(          )  String.ê(number): palindromify
                   "abc"->"abccba" if `number` is odd, "abcba" otherwise
                 `true` is odd number, so we achieve the desired function

वैकल्पिक 4 बाइट्स

pwwp

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

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

U.p("w".w("p"))  Transpiled to JS
    "w".w(   )   Reverse of "w" ("p" is ignored)
U.p("w")         Append U.w(), which is reverse of U, to the right of U

— bubbler
स्रोत

0

बैकहैंड , 33 27 बाइट्स

iH~0}|{<:: oi]io ::<{|}0~Hi

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

बहुत सारे समाधानों के विपरीत, यह वास्तव में करता है में palindromised कोड का उपयोग !

स्पष्टीकरण:

i  0 |{      Get the first character and enter the loop
        :  o    Output the character while preserving it
              i  :     Get input and duplicate it
                   <{  Turn around
             ]         Increment the copy to check if EOF   
    }| <    Loop again if not EOF
  ~   If EOF, pop the extra copy of EOF
 H    Terminate, printing the contents of the stack.

कुल मिलाकर, अप्रकाशित निर्देश हैं:

       :   i  o :   |}0~Hi

— मजाक कर रहा है
स्रोत

पैलिंड्रोमिक पैलिंड्रोम जनरेटर

दलयोग एपीएल, 6 4

व्याख्या

piet 19x2 = 38

एपीएल, ९

सीजेएम, 13 बाइट्स

GolfScript, 9 बाइट्स

सी ++, 162 बाइट्स

सी, 117 बाइट्स

हास्केल, 102 + 22 = 124 बाइट्स

हास्केल, 55 + 22 = 77 बाइट्स

अजगर, 11 बाइट्स

रूबी, ४४

जोल्फ, 9 बाइट्स

पॉवरशेल, 67

फजी ऑक्टो गुआकामोल, 17 बाइट्स

छोटेबड़े , ४०

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

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

विटसी, 9 बाइट्स

Befunge , 37 बाइट्स

सी # ( 33 32 + 1) * 2 = 68 66 बाइट्स

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

प्रयोग

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

प्रयोग

अजगर, १५

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

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

PHP, 28 + 1 + 28 = 57 बाइट्स

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

सी ++ 14, 152 116 बाइट्स

05AB1E , 5 बाइट्स

x86-64 विधानसभा (Microsoft x64 बुला सम्मेलन), 89 बाइट्स:

जाप , 4 बाइट्स

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

वैकल्पिक 4 बाइट्स

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

बैकहैंड , 33 27 बाइट्स

स्पष्टीकरण: