StringgnirtSStringgnirtSStringgnirtS

42

यहां आपके लिए अपेक्षाकृत सरल चुनौती है।

लंबाई की एक स्ट्रिंग को देखते हुए एन , उत्पादन स्ट्रिंग आगे, तो पीछे की ओर है, तो आगे है, तो पीछे की ओर ... आदि एन बार। उदाहरण के लिए, यदि आपका इनपुट था

Hello!

आपको आउटपुट चाहिए:

Hello!!olleHHello!!olleHHello!!olleH

आप वैकल्पिक रूप से एक अनुगामी न्यूलाइन भी आउटपुट कर सकते हैं।

आपका सबमिशन पूर्ण प्रोग्राम या फ़ंक्शन हो सकता है, और आप किसी भी उचित प्रारूप में इनपुट और आउटपुट ले सकते हैं । उदाहरण के लिए, आप IO को STDIN / STDOUT से ले सकते हैं, एक फाइल आदि से तर्क और रिटर्न वैल्यू, आप सुरक्षित रूप से मान सकते हैं कि इनपुट स्ट्रिंग खाली नहीं होगी, और इसमें केवल मुद्रण योग्य ASCII होगा। आपको एक ही लाइन पर नए स्ट्रिंग को आउटपुट करना होगा । इसलिए, उदाहरण के लिए, यदि अंतिम उदाहरण के लिए आउटपुट था

Hello!
!olleH
Hello!
!olleH
Hello!
!olleH

यह एक वैध समाधान नहीं होगा !

यहाँ कुछ और परीक्षण मामले हैं:

Input:
a
Output:
a

Input:
abcd
Output:
abcddcbaabcddcba

Input:
OK!
Output:
OK!!KOOK!

Input:
4815162342
Output:
4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184

Input:
PPCG
Output:
PPCGGCPPPPCGGCPP

Input:
42
Output:
4224

लीडरबोर्ड

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

  1. सभी भाषाओं में से सबसे छोटा उत्तर, और

  2. प्रत्येक व्यक्तिगत भाषा में सबसे छोटा जवाब।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

कोड स्निपेट दिखाएं

code-golf  string  code-golf  math  geometry  data-structures  repeated-transformation  code-golf  number  random  code-golf  math  rational-numbers  code-golf  ascii-art  animation  code-golf  ascii-art  number  code-golf  math  number  code-golf  data-structures  code-golf  string  parsing  code-golf  array-manipulation  random  permutations  code-golf  string  code-golf  parsing  code-golf  string  quine  code-golf  string  parsing  comment  code-golf  string  counting  natural-language  code-golf  string  decision-problem  code-golf  math  code-challenge  metagolf  test-battery  code-golf  string  code-golf  math  number  arithmetic  source-layout  code-golf  number  primes  decision-problem  code-golf  math  arithmetic  code-golf  date  code-golf  string  cryptography  code-golf  code-golf  chess  board-game  code-golf  geometry  grid  puzzle-solver  set-partitions  code-golf  number  natural-language  code-golf  ascii-art  code-golf  math  code-golf  string  ascii-art  kolmogorov-complexity  code-golf  string  natural-language  code-golf  game  board-game  tic-tac-toe  code-golf  ascii-art  hexagonal-grid  code-golf  string  comment  code-golf  internet  code-golf  sorting  code-golf  kolmogorov-complexity  unicode  code-golf  tips  code-golf  string  natural-language  code-golf  string  kolmogorov-complexity  source-layout  hello-world  code-golf  string  kolmogorov-complexity  counting  natural-language  code-golf  random  quine  code-golf  string  math  bitwise  code-golf  permutations  code-golf  string  code-golf  arithmetic 
— DJMcMayhem
स्रोत
अपने उदाहरण में, कि नहीं होना चाहिए olleH, नहीं elloH?
— अरनौद
2
@Downgoat नहीं, आपको उसी प्रारूप में इनपुट और आउटपुट लेना होगा जैसा कि युक्ति वर्णन करती है।
— DJMcMayhem
4
शीर्षक StringgnirtSStringgnirtirttringgnirtS होना चाहिए ?
— लुइस मेंडो
2
@carusocomputing यह नहीं होगा: "आप सुरक्षित रूप से मान सकते हैं कि इनपुट स्ट्रिंग खाली नहीं होगी, और इसमें केवल मुद्रण योग्य ASCII होगा।"
— मार्टिन एंडर
1
en.wikipedia.org/wiki/ASCII#Printable_characters आह, यह नहीं जानता था कि ASCII का एक अच्छा परिभाषित उपसमूह था। मैंने मुद्रण योग्य की कल्पना करने के लिए \ t, \ n, आदि को शामिल किया ...
— मैजिक ऑक्टोपस Urn

जवाबों:

22

विम, 39 , 34 कीस्ट्रोक्स

:se ri
Y:s/./<C-r>"/g
<C-o>qqgJC<C-r>"<esc>gJ@qq@q

5 बाइट्स @Lynn की बदौलत बच गए!

यहाँ इसका लाइव होने का एक gif है: (ध्यान दें कि यह gif पिछले संस्करण का है क्योंकि मेरे पास अभी तक रिकॉर्ड करने का समय नहीं है)।

यहाँ छवि विवरण दर्ज करें

और यहाँ एक विवरण दिया गया है कि यह कैसे काम करता है:

:se ri                  "Turn 'reverse indent' on.
Y                       "Yank this line
:s/./<C-r>"/g           "Replace every character on this line with the register
                        "We just yanked followed by a newline
<C-o>                   "Jump to our previous location
     qq                 "Start recording in register 'q'
       gJ               "Join these two lines
         C              "Delete this line, and enter insert mode
          <C-r>"<esc>   "Paste the line we just deleted backwards 
gJ                      "Join these two lines
  @q                    "Call macro 'q'. This will run until we hit the bottom of the buffer.
    q                   "Stop recording.
     @q                 "Start our recursive macro

एक साइड नोट पर, Yएक अतिरिक्त न्यूलाइन को पकड़ता है, जो आमतौर पर एक अप्रिय विशेषता है। यह शायद पहली बार है जब इसने वास्तव में कई बाइट्स बचाए हैं!

— DJMcMayhem
स्रोत
2
इसके बजाय :%s/\n<cr>, आप v{gJतीन बाइट्स को बचाने के लिए कर सकते हैं ।
— लिन
2
एक VIM जवाब ?! यह आपकी ओर से एक उत्तम दर्जे का कदम है।
— मैजिक ऑक्टोपस उर्फ़
@ लिन टिप के लिए धन्यवाद! मैंने कुछ अलग करने की कोशिश की और बदले में 5 रन बनाए।
— DJMcMayhem
यह मानता है कि @qशुरू में खाली है, है ना? या @qरिकॉर्डिंग को रोकने से पहले कुछ मनमाना होगा। (यह मुझे मेरे पसंदीदा विम ट्रिवियम की ओर ले जाता है, जिसके साथ मैं आया हूं: हर कोई जानता है कि विम को छोड़ना उतना ही आसान है :q<CR>, लेकिन आप अपनी सभी फाइलों को कैसे बंद और सहेजते हैं? आसान: बस qqqqqZZ@qq@q!)
— wchargin
@wchargin हाँ, यह @qखाली होने की आवश्यकता है। सिर्फ इसके :wqaबजाय क्यों नहीं ? यह भी पता है कि विम में भग्न कैसे उत्पन्न किया जाए? qqqqq<C-w>v<C-w>n@qq@q: डी
— DJMcMayhem
18

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

f=lambda s,i=0:s[i:]and s+f(s[::-1],i+1)

एक पुनरावर्ती कार्य। sकाउंटर iकी लंबाई से अधिक होने तक इनपुट स्ट्रिंग को रिवर्स के फ़ंक्शन के लिए प्रस्तुत करता है s।

— XNOR
स्रोत
वाह। मैं बस के बारे में 56 बाइट अजगर जवाब प्रस्तुत करने के लिए किया गया था, haha
— DJMcMayhem
@DJMcMayhem यह भी lambda s:(len(s)*(s+s[::-1]))[:len(s)**2]एक बाइट से धड़कता है।
— जोनाथन एलन
मैंने इसे प्राप्त कर लिया है, f = lambda s : ''.join([s[((-1)**(i//len(s)) <= 0)*(len(s)-1)+(-1)**(i//len(s))*(i%len(s))] for i in range(len(s)*len(s))])लेकिन यह 136 बाइट्स के अनुसार है sys.sizeof, दिलचस्प रूप से यह उसी आकार का है जैसेf = lambda s : ''.join([s[::1] if i%2 else s for i in range(len(s))])
— Carel
12

ब्रेन-फ्लैक , 418 378 228 बाइट्स

यह मेरी ब्रेन-फ्लैक कृति है। यह अच्छी तरह से गोल्फ नहीं हो सकता है लेकिन चुनौती सबसे कठिन है जो मैंने कभी भी सामना किया है।

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

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

व्याख्या

यह स्पष्टीकरण अब थोड़ा पुराना हो गया है लेकिन यह अभी भी कार्यक्रम को समझाने का एक अच्छा काम करता है।

यह स्पष्टीकरण मेरी नियमित स्पष्टीकरण प्रक्रिया से थोड़ा अलग है। मैं यह बताने जा रहा हूं कि मैं इस परिणाम के बारे में कैसे आया ताकि परिणाम को क्रम से समझा सकूं। ये रहा:

बेलन

समस्या पर काम करने के बाद मैं थोड़ा बहुत इस कोड के साथ आया:

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

यह कोड (जहाँ n कुछ संख्या के लिए शाब्दिक है। उदा ()()) आइटम को स्टैक के शीर्ष पर ले जाएगा और इसे n चरणों में ले जाएगा। स्टैक ऊंचाई के रूप में n के साथ यह एक स्टैक "रोल" करेगा। यानी शीर्ष आइटम को स्टैक के निचले भाग में ले जाएं। यहां देखिए यह कैसे काम करता है:

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

(n[()])

हम तब तक लूप करते हैं जब तक कि यह संख्या एक के साथ लूप के शून्य रखने वाले ट्रैक तक नहीं पहुंच जाती ()।

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

हर बार जब हम लूप लेते हैं तो हम टॉप आइटम को उठाते हैं और आइटम को दूसरे स्टैक के नीचे ले जाते हैं। यह अपनी जगह पर शीर्ष पर नंबर डालता है।

({}<({}<>)<>>)

अब हमें बस उन नंबरों को डालने की जरूरत है जिन्हें हम वापस ले आए हैं। हम ऑफ स्टैक पर स्विच करते हैं और लूप द्वारा किए गए रन की संख्या को धक्का देते हैं।

(...<>)

जब तक यह शून्य तक नहीं पहुंच जाता तब तक हम नई पुश संख्या को घटाते हैं। हर बार हम एक नंबर पीछे हटते हैं।

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

रिवर्स

मैंने अगली बार एक पूर्ण स्टैक रिवर्स बनाने के लिए रोल को संशोधित किया:

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

एक बार फिर एन रिवर्स की गहराई का प्रतिनिधित्व करता है। यही कारण है कि स्टैक पर शीर्ष एन आइटम उलट हो जाएंगे। यह काम किस प्रकार करता है:

रिवर्स सिर्फ एक काल्पनिक लिपटे रोलर है। हम केवल एक बार प्रत्येक बार रोल की गहराई में वृद्धि करते हुए स्टैक एन के शीर्ष पर रोल करते हैं।

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

डुप्लिकेट

जगह-जगह नकल मुश्किल है। वास्तव में मुश्किल है। के बाद मुझे पता चला कि कैसे स्टैक को रिवर्स करने के लिए यह अभी भी दोहराव एल्गोरिथ्म के साथ आने के लिए बहुत प्रयास किया।

यह रहा:

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

इसका एक बड़ा सा है, लेकिन यहाँ यह कैसे काम करता है:

N को पुश करके प्रारंभ करें। n डुप्लिकेट की गहराई है। हम दो कोष्ठक भी खोलते हैं। ये हमें फिर से इसकी आवश्यकता होने तक गुंजाइश में n के मूल्य को संग्रहीत करने की अनुमति देते हैं।

(((n)<

अगली बार हम प्रत्येक बार स्टैक के शीर्ष मान को दो बार ऑफ स्टैक पर धकेलते हैं। यह स्टैक पर प्रत्येक संख्या के लिए प्रारंभिक डुप्लिकेट बनाता है।

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

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

इसलिए हम ऑफस्टैक पर जाते हैं और शुरुआत में हमारे द्वारा सहेजे गए किसी एक ns को याद करते हैं।

<>>)

हम एन बार लूप करते हैं।

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

हर बार हम एक कॉपी को मेनस्टैक में स्थानांतरित करते हैं।

({}<>)<>

और एक प्रति को ढेर के नीचे रोल करें। (यह मानता है कि इस डुप्लिकेट को स्टैक साफ नहीं करने के साथ शुरू करने के लिए ऑफस्टैक खाली था)

([][()])ROLLER

एक बार जो किया जाता है, हमने मूल को दो समूहों में विभाजित किया है "मूल" और ऑफ़स्टैक पर एक प्रतिलिपि (प्रतिलिपि वास्तव में रिवर्स है)। इसलिए हम कॉपी को मुख्य स्टैक पर ले जाते हैं और हम इसके साथ हो सकते हैं।

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

कंकाल का कार्यक्रम

अब जब मैंने कार्यक्रम के सभी टुकड़े कर दिए हैं, तो मुझे उन्हें एक फ्रेम में सम्मिलित करना होगा।

फ्रेम डुप्लिकेट का उपयोग करते हुए स्टैक की ऊंचाई की तुलना में पाठ को दोगुना करता है।

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

और फिर n ^ 2-n से 0 तक प्रारंभिक स्टैक ऊंचाई की घटती हुई वृद्धि में स्टैक को उलट देता है।

(({}))
{
 (({}[()])<
  ({}<>)<>(({}))({<({}[()])><>({})<>}{})<>{}<>
  ({}<({}<>)<>>)<>({}<>)
  ({}<
   REVERSE
  >)
 >)
}{}{}
— गेहूं का जादूगर
स्रोत
5
गजब का। आप हमेशा मेरे दिमाग को उड़ाते हैं कि यह भाषा क्या कर सकती है! : डी
— DJMcMayhem
10

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

,Ṛṁ

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें।

@ माल्टीसेन को एक बाइट धन्यवाद दिया ।

व्याख्या

,Ṛṁ  Input: string S
 Ṛ    Reverse S
,     Join S with reverse of S. Makes a list [S, rev(S)]
  ṁ   Mold [S, rev(S)] to len(S) by repeating elements cyclically
      Return and print implicitly as a string
— मील की दूरी पर
स्रोत
1
मोल्ड की आवश्यकता नहीं हैL
— माल्टीसेन
@ माल्टीसेन वाह धन्यवाद, क्या आप जानते हैं कि स्रोत कोड से या अनुभव से
— मील
अनुभव से, मुझे जेली का पता नहीं है, लेकिन मुझे लगता है कि मोल्ड एक गैर-संख्या पर क्या करेगा, क्योंकि जेली वास्तव में
— ओवरलोड्स
मोल्ड वास्तव में केवल पुनरावृत्तियां लेता है, लेकिन यह पूर्णांक को पहले सीमा में रखता है।
— डेनिस
1
हाँ, मैंने साँचे को रेशे के रूप में माना है इसलिए मैंने बस आदतन इसे एक नंबर दिया है। जेली में इतने साफ सुथरे छोटे व्यवहार होते हैं, जैसे कैसे एक तार की एक सरणी स्वचालित रूप से एक संघनित स्ट्रिंग के रूप में आउटपुट होती है
— मील
9

PHP, 54 52 बाइट्स

(49 बाइट्स, लेकिन अगर स्ट्रिंग में '0' शामिल हो तो काम न करें)

for(;($a=$argv[1])[$i++];)echo$i%2?$a:strrev($a);

(52 बाइट्स)

<?=str_pad('',strlen($a=$argv[1])**2,$a.strrev($a));

(54 बाइट्स)

for(;$i++<strlen($a=$argv[1]);)echo$i%2?$a:strrev($a);
— क्रिप्टो
स्रोत
मैं पूरी तरह से भूल गया str_pad। अच्छा है!
— टाइटस
6

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

->(s){s.reverse!.gsub(/./){s.reverse!}}

मैं रूबी को चूसता हूँ। गोल्फ की मदद की सराहना की है।

रूबी इसके लिए एक बहुत अच्छी भाषा है .reverse!

व्याख्या

मैं उम्मीद कर रहा था कि यह कुछ सरल होगा:

s.gsub(/./){s.reverse!}

लेकिन बॉयलरप्लेट / चुनौती प्रतिबंध के कारण यह अधिक लंबा है।

क्या s.reverse!बहुत उपयोगी है। s.reverse!मूल रूप से है s = s.reverse!, जिसका अर्थ है कि यह भी परिवर्तन करता है s।

कार्यक्रम का प्रत्येक भाग नीचे वर्णित है:

->(s){             # Lambda with argument s
      s.reverse!   # Reverse `s` see above for details
      .gsub(/./)   # Replace every character with...
      {s.reverse!} # the input reversed!

इसके बारे s.reverse!में महान बात यह है कि हर बार मूल्यांकन किया जाता है कि स्ट्रिंग का फ़्लिप हो जाता है। तो यह स्ट्रिंग की जगह लेता है। sसंशोधित किया गया है!

— Downgoat
स्रोत
-pझंडे के साथ आप 4 बाइट्स बचा सकते हैं:$_.reverse!;gsub(/./){$_.reverse!}
— जॉर्डन
@ जोर्डन पर मुझे .chompहालांकि ज़रूरत नहीं होगी $_? यह इस समय
— न्यूलाइन
यदि आप कुछ ऐसा नहीं करते हैं, ruby -pe '$_.reverse!;gsub(/./){$_.reverse!}' < file.txtजहां file.txtअनुगामी न्यूलाइन के बिना एक लाइन कहां है: वी एनीवेज, यदि आप ऐसा नहीं करने का निर्णय लेते हैं, तो आपको लैम्ब्डा पर पैरेंस की आवश्यकता नहीं है, इसलिए ->sकाम करता है
— वैल्यू इंक
@ValueInk, यदि आप इसे पाइप करते हैं, तो आप फ़ाइल के बिना नया-नया इनपुट प्रदान कर सकते हैं। या आप इसे मैन्युअल रूप से टाइप कर सकते हैं, बस एंटर न करें: i.stack.imgur.com/6luxM.png
— manatwork
1
आपको लंबोदर के तर्क के आसपास कोष्ठक की आवश्यकता नहीं है। इसके अलावा, मुझे लगता है कि आप विस्मयादिबोधक बिंदुओं में से एक को हटा सकते हैं:s.gsub(/./){s.reverse!.reverse}
— m-chrzan
6

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

के लिए +2 शामिल है -lp

STDIN पर इनपुट दें:

rev.pl <<< Hello!

rev.pl:

#!/usr/bin/perl -lp
s%.%s/.?/chop/eg;$`%eg

हैरानी की बात है कि यह बिलिन reverseऑपरेटर का उपयोग नहीं करता है । यह नाम अभी बहुत लंबा है, सभी समाधान जिनके बारे में मैं सोच सकता reverseथा वे कम से कम 1 बाइट अधिक लंबे हैं।

— टन हास्पेल
स्रोत
एक समाधान है कि एक अंतर्निहित की तुलना में कम बाइट्स लेता है खोजने के लिए upvoted
— MilkyWay90
6

जे, 13 8 बाइट्स

मीलों तक 5 बाइट्स बचाए!

#;@$];|.

यह निम्नलिखित क्रियाओं के साथ एक 5-ट्रेन है:

# ;@$ ] ; |.

आंतरिक कांटा ](पहचान), ;(लिंक), और |.(रिवर्स) से बना है। का निरीक्षण करें:

   (| ; |.) 'Hello!'
+------+------+
|Hello!|!olleH|
+------+------+

बाहरी दो क्रियाएं बाकी ट्रेन बनाती हैं। #इस मामले में, तर्क का आकार, यानी लंबाई। इन्हें जोड़ने वाली क्रिया है ;@$, या ravelओवर reshape। का निरीक्षण करें:

   # 'Hello!'
6
   6 $ (] ; |.) 'Hello!'
+------+------+------+------+------+------+
|Hello!|!olleH|Hello!|!olleH|Hello!|!olleH|
+------+------+------+------+------+------+
   ; 6 $ (] ; |.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   6 ;@$ (] ; |.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   (# ;@$ (] ; |.)) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   (# ;@$ ] ; |.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   (#;@$];|.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH

पुराना हल।

[:,|.^:(i.@#)

काफी सरल। |.यह रिवर्स है, और ^:पावर कंजंक्शन है, जो दोहराता है कि यह बाएं (दाहिने हाथ) # बार है। जब सही तर्क एक क्रिया है, उस क्रिया को तर्क पर कहा जाता है। इस मामले में सही क्रिया शून्य ( i.) से लेकर लंबाई ( #) तक होती है। जब किसी सरणी में उठाया जाता है, तो मध्यवर्ती परिणाम रखे जाते हैं। जरूरत है कि सभी के साथ सरणी समतल करना है ,।

इंटरमीडिएट के परिणाम

   (i.@#) 'Hello!'
0 1 2 3 4 5
   |.^:0 1 2 3 4 5 'Hello!'
Hello!
!olleH
Hello!
!olleH
Hello!
!olleH
   |.^:(i.@#) 'Hello!'
Hello!
!olleH
Hello!
!olleH
Hello!
!olleH
   ([:,|.^:(i.@#)) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
— कोनोर ओ ब्रायन
स्रोत
आप एक बाइट को लंबाई में बॉक्सिंग करके बचा सकते हैं<@#
— मील
एक साफ-सुथरा 8 बाइट वाला घोल, #;@$];|.जो शुरुआती और उल्टे-सीधे बॉक्सों को बंद कर देता है, बॉक्सिंग स्ट्रिंग्स को फिर से आकार देता है और उन्हें एक साथ रेज़ करता है
— मील
@ मीलों वाह, यह बहुत साफ है।
— कॉनर ओ'ब्रायन
5

जावास्क्रिप्ट (ईएस 6), 59 50 बाइट्स

9 बाइट्स हेडी और हंट्रो के लिए धन्यवाद।

f=(s,n=1)=>s[n]?s+f([...s].reverse().join``,n+1):s

पुनरावर्ती कार्य।

स्ट्रिंग को उल्टा करने से आकार का लगभग आधा हिस्सा लगता है ( 25 22 बाइट्स!) ...
उसके लिए कोई देशी तरीका क्यों नहीं है?

— टाइटस
स्रोत
1
आप s[n]?...इनडीड का उपयोग कर सकते हैंn<s.length?...
— हेडी
1
[...s]s.split``
— हंट्रो
yea 36 बाइट्स आदर्श रूप सेf=(s,n=1)=>n==1?s:s+s.reverse(),n-1)
— caub
गैर पुनरावर्ती एक है f=(s,n=1)=>Array.from({length:n},(_,i)=>i%2?s.reverse():s).join``)कि सीमा के लिए कुछ बेहतर कार्य के साथ भी बेहतर होगा
— caub
@ ऑब: SyntaxError: Unexpected token )जेएस का कोई मूल स्ट्रिंग प्रत्यावर्तन नहीं है। SyntaxError: Invalid or unexpected tokenआपके दूसरे सुझाव के लिए। वह ब्राउज़र किस काम में आता है?
— टाइटस
4

मिंकोलंग , 17 बाइट्स:

$oId$z$Dz[rz[O]].

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

व्याख्या

$o                   Read in whole input as characters
  Id                 Push the length of stack and duplicate
    $z               Pop top of stack and store in register (z)
      $D             Pop top of stack (n) and duplicate whole stack n-1 times
        z[     ]     z times, do the following:
          r          Reverse the stack
           z[O]      z times, pop the top of stack and output as character
                .    Stop.
— एलेंडिया स्ट्राटन
स्रोत
4

8088 असेंबली, आईबीएम पीसी डॉस, 29 28 बाइट्स

इकट्ठे, xxdडंप:

00000000: d1ee ac48 938a cbfc 518a cbf7 da78 01fd  ...H....Q....x..
00000010: acac b40e cd10 e2f9 59e2 ecc3            ........Y...

अनुपलब्ध सूची:

D1 EE       SHR  SI, 1          ; point SI to DOS PSP (080H) 
AC          LODSB               ; load input string length into AL 
48          DEC  AX             ; remove leading space from length counter 
93          XCHG BX, AX         ; save input length to BL 
8A FB       MOV  BH, BL         ; string output counter in BH 
        S_LOOP: 
FC          CLD                 ; set direction forward 
8A CB       MOV  CL, BL         ; reset char counter in CL 
F7 DA       NEG  DX             ; flip DX to toggle fwd/back output 
78 01       JS   C_START        ; if positive, go forward 
FD          STD                 ; otherwise go backwards 
        C_START: 
AC          LODSB               ; adjust SI to first/last char
        C_LOOP: 
AC          LODSB               ; load next char into AL
B4 0E       MOV  AH, 0EH        ; PC BIOS tty output function
CD 10       INT  10H            ; write char to console
E2 F9       LOOP C_LOOP         ; continue looping through chars
FE CF       DEC  BH             ; decrement string count loop
75 EC       JNZ  S_LOOP         ; if not zero, continue loop
C3          RET                 ; exit to DOS

स्टैंडअलोन पीसी डॉस निष्पादन कार्यक्रम। कमांड लाइन के माध्यम से इनपुट स्ट्रिंग, आउटपुट कंसोल है।

यहाँ छवि विवरण दर्ज करें

— 640KB
स्रोत
3

हास्केल, 40 36 32 बाइट्स

m s=take(length s^2)$cycle$s++reverse s

उदाहरण:

*Main> m "Hello!"
"Hello!!olleHHello!!olleHHello!!olleH"

यहां तक ​​कि कम (डेमियन के लिए क्रेडिट):

q s=zip(s>>[s,reverse s])s>>=fst

s >> [s, रिवर्स s] चक्र ["abc", "cba", ...] जो सही आकार के लिए ज़िपित है और fstMap'ped with fst

— michi7x7
स्रोत
2
q s=zip(s>>[s,reverse s])s>>=fst
— डेमियन
3
या एक ही आकार के साथ एक बिंदु:(>>=fst).(iterate reverse>>=zip)
— डेमियन
3

पर्ल 6 ,  31  30 बाइट्स

{[~] (|($_,.flip)xx*)[^.chars]}

एक बाइट का दुरुपयोग करके बचाएं .ords, जो अध्यादेशों की सूची लौटाता है, फिर एक सीमा बनाने के लिए इसे संक्षेप में बदल दें।

{[~] (|($_,.flip)xx*)[^.ords]}

स्पष्टीकरण:

# bare block lambda with implicit parameter ｢$_｣
{
  # reduce using string concatenation operator ｢~｣
  [~]

  (
    # create a Slip
    |(
      # of the input, and its string reverse
      $_, .flip

    # list repeated infinitely
    ) xx *

  # get the values in the range from 0 up-to and excluding
  # the number of characters ｢0 ..^ +$_.ords｣
  )[ ^.ords ]
}

उपयोग:

my &code = {[~] (|($_,.flip)xx*)[^.ords]}

say code 'a'; # a
say code 'abcd'; # abcddcbaabcddcba
say code 'OK!'; # OK!!KOOK!
say code 4815162342; # 4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184
— ब्रैड गिल्बर्ट b2gills
स्रोत
3

विम + कोर्यूटिल्स, 32 कीस्ट्रोक्स

आपके पास कभी बहुत अधिक विम उत्तर नहीं हो सकते हैं।

qqYv:!rev
Pjq@=len(@")
@q2dkv{gJ

व्याख्या

qq               " Start recording macro
Y                " Yank (copy) line
v:!rev<CR>       " Reverse line with coreutils rev command
Pj               " Paste yanked line above this line
q                " Stop recording
@=len(@")<CR>@q  " Playback macro once for each character
2dk              " Delete last 3 lines
v{gJ             " Join lines
— जॉर्डन
स्रोत
1
Coreutils के साथ? यह बेइमानी है! : पी
— क्रिश्चियन रोंडेउ
3

MATL, 13 12 8 बाइट्स

सभी तत्वों को धकेलता है, अंत में जोड़ता है।

td"tP]&h

td"  ]     %For loop over string length - 1 due to diff
   tP      %Push copy of string, reverse
      &h   %Concatenate entire stack horizontally

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

पुराने संस्करणों:

पूरी तरह से अलग दृष्टिकोण, के आधार पर fprintf:

t"t1$0#YDP]x

t"        ]   % For loop over string
  t           % Duplicate string for printing:
   1$0#YD     % `fprintf` with 1 input, 0 output (i.e., to screen).
         P    % Reverse
           x  % Empty stack to prevent implicit output

टेम्प्लेट स्ट्रिंग को उलटने के आधार पर संस्करण

ttd"wPtbYc]Dx

t                 %Duplicate input, to create 'accumulator' string 
                  % (alongside the input string which will serve as 'template'
 td               %Duplicate input, diff to get an stringof size input-1
   "       ]      %For loop over size n-1 string (consumes diff'd string)
     wP           %Get 'template' string on top of stack, and reverse
       tb         %Duplicate template string, and switch with 'accumulator' string
         Yc       %Concatenate template string with accumulator. 
            Dx   %Display top element, delete template string to prevent implicit disp
— Sanchises
स्रोत
मुझे का चतुर उपयोग पसंद है td!
— DJMcMayhem
@DJMcMayhem धन्यवाद! मेरे पास tnq:"पहले स्पष्ट था , लेकिन tn:"एक कोड गंध का एक सा है (देखें यह मैटलैब गोल्फिंग टिप) इसलिए मुझे लगा कि tnq:यह अधिक कॉम्पैक्ट भी हो सकता है।
— सेंचुरी
3

स्काला, 73 72 71 बाइट्स

def f(s:String)=for(i<-1 to s.length){print(if(i%2>0)s else s.reverse)}

कोड गोल्फिंग में यह मेरा पहला प्रयास है, इसलिए मुझे यकीन है कि अनगिनत सुधार हुए हैं।

अपडेट करें:

कोष्ठक को हटाकर 1 बाइट को घेरे।

सुझाव के लिए विनाशकारी तरबूज के लिए धन्यवाद, एक बाइट से मुंडा।

— Himself12794
स्रोत
मैं स्केला पता नहीं है, लेकिन आप बदल सकते हैं i%2==1करने के लिए i%2>0?
— विनाशकारी नींबू
@DestructibleWatermelon के बारे में सोचा नहीं था, हाँ मैं कर सकता हूँ
— खुद को 12794
3

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

Ap\:\;.#u/\:qqsoq(?;u.q..$u<../pB@u:\.....\(?q..s..p

एक घन पर:

      A p \
      : \ ;
      . # u
/ \ : q q s o q ( ? ; u
. q . . $ u < . . / p B
@ u : \ . . . . . \ ( ?
      q . .
      s . .
      p . .

यह एक मजेदार था; अभी भी इस से बाहर निकलने के लिए बाइट्स हैं, लेकिन यह निश्चित रूप से काम करेगा।

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

स्पष्टीकरण:

का इनपुट ABC

  • /A: उत्तर में जाएं और सभी इनपुट में पात्रों के रूप में पढ़ें; -1सबसे नीचे होगा
  • p\;.: -1स्टैक से निकालें
  • u# : स्ट्रिंग लंबाई (स्टैक पर वस्तुओं की संख्या) को धक्का दें
  • \:\:qq : स्ट्रिंग की लंबाई को दो बार डुबोएं, दो प्रतियों को स्टैक के नीचे तक धकेलें

  • पाश:

    • soq(?/<u : स्टैक के ऊपर स्वैप, स्टैक के ऊपर ouptut, ASCII के रूप में, नीचे से ऊपर (अक्षर) को पुश करें, स्टैक के शीर्ष को घटाएं, यदि सही नहीं किया गया है, तो आईपी को सही जगह पर ले जाएं।
    • लूप के अंत में, स्टैक जैसा दिखेगा C B A 3 3 0

  • ;u : स्टैक के पॉप टॉप C B A 3 3

  • B : रिवर्स स्टैक 3 3 A B C
  • p( : नीचे से ऊपर और नीचे की ओर बढ़ें 3 A B C 2
  • ?यदि शीर्ष शून्य है, तो सीधे जाएं @और समाप्त करें
  • अन्य
    • psq:uq : ऊपर से नीचे की ओर ले जाएँ, ऊपर की ओर स्वैप करें और ऊपर से नीचे की ओर जाएँ और ऊपर से नीचे जाएँ 3 2 A B C 3
    • $u : छोड़ें u
    • < हमें वापस पाश में डालता है।

दुभाषिया

— ग्यूसेप
स्रोत
यहाँ एक 24 बाइट्स है। एक ही सामान्य तर्क थोड़ा संकुचित।
— मिकी
@ मिक्की मुझे गोल्फ के 28 बाइट्स के लिए क्रेडिट लेने के बारे में बुरा लगेगा। इसे स्वयं पोस्ट करें!
— ग्यूसेप
3

C (gcc) , 88 87 85 83 68 66 83 82 78 बाइट्स

-1 सीटिंग के लिए धन्यवाद

पुराना संस्करण

p,q;f(char*s){p=q=1;for(char*m=s--;*m;s[p+=q]*p?:(m++,p+=q=-q))putchar(s[p]);}

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

छोटा संस्करण (थोड़ा टूटा हुआ)

केवल टिप्पणियों में ASCII द्वारा 76 बाइट दृष्टिकोण पर रीफिंग , और मेरे ट्वीक के उनके बाइट से -1 बाइट।

संपादित करें: यह संस्करण थोड़ा टूट गया है कि यह मानता है कि प्रत्येक स्ट्रिंग एक NULL बाइट से पहले है, जो हमेशा सच नहीं होता है। (लिंक में आखिरी टेस्ट केस देखें)। अब के लिए 83 बाइट संस्करण के लिए फिर से शुरू।

f(char*s){for(char*n=s-1,k=1;*s++;k=-k)for(;*(n+=k);)putchar(*n);}

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

— gastropner
स्रोत
67
— एएससीआईआई-केवल
@ ASCII- केवल 68 कुछ ट्विकिंग के साथ संभव है।
— गैस्ट्रोपनर
: P यह 67 है lol @gastropner
— केवल
@
— ASCII-
@ ASCII- केवल दुख की बात है कि कुछ मामलों में काम नहीं करने के लिए छोटा संस्करण निकला।
— गैस्ट्रोपनर
2

जावा, 127 111 88 बाइट्स

(s,r)->{for(int i=0;i++<s.length();)r+=i%2<1?new StringBuffer(s).reverse():s;return r;};

अनगढ़ परीक्षण कार्यक्रम

    public static void main(String[] args) {
    BiFunction<String, String, String> func = (s, r) -> {
        for (int i = 0; i++ < s.length();) {
            r += i % 2 < 1 ? new StringBuffer(s).reverse() : s;
        }
        return r;
    };
    System.out.println(func.apply("Hello!", ""));
}
— शॉन वाइल्ड
स्रोत
यह कुछ और गढ़ा जा सकता है: (s,r)->{for(int i=0;i++<s.length();)r+=i%2<1?s:new StringBuffer(s).reverse();return r;};( 88 बाइट्स )। इसके अलावा, मैं निर्दिष्ट करूंगा कि यह जावा 8. है
— केविन क्रूज़सेन
ना, यह मान लेना ठीक है कि उनका जावा का नवीनतम संस्करण उपयोग कर रहा है।
— शॉन वाइल्ड
@KevinCruijssen Java 7 को अब और ($ $ $ के साथ) समर्थित नहीं किया गया है । हमें जावा का संस्करण निर्दिष्ट नहीं करना चाहिए। इसके अलावा, यदि आप जावा 7 के रूप में लिखते हैं, तो अधिकांश उत्तर जावा 1.1 या 1.2 में लिखे जा सकते हैं। तो क्या आपको सबसे कम संस्करण नहीं लिखना चाहिए जिसके साथ यह काम करता है? यदि इस उत्तर में कोड जावा 7 अनुरूप था, तो यह जावा 1.2 अनुपालन होगा, और ... अब भी जावा 8 में काम करेगा।
— ओलिवियर ग्रेजायर
2

आर, 53 बाइट्स

मान लेता है कि इनपुट प्रत्येक वर्ण के लिए स्पेस-या न्यूलाइन-अलग है।

cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")

कुछ परीक्षण मामले:

> cat(rep(c(i<-scan(,""),rev(i)),len=length(i)^2),sep="")
1: h e l l o !
7: 
Read 6 items
hello!!ollehhello!!ollehhello!!olleh

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: a
2: 
Read 1 item
a

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: a b c d
5: 
Read 4 items
abcddcbaabcddcba

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: O K !
4: 
Read 3 items
OK!!KOOK!

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: 4 8 1 5 1 6 2 3 4 2
11: 
Read 10 items
4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: P P C G
5:    
Read 4 items
PPCGGCPPPPCGGCPP

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: 4 2
3: 
Read 2 items
4224
— rturnbull
स्रोत
2

PowerShell v2 +, 57 बाइट्स

param($a)-join(1..($x=$a.length)|%{($a[$x..0],$a)[$_%2]})

स्ट्रिंग की लंबाई या उन्हें उल्टा करने का कोई वास्तविक साफ तरीका नहीं है, इसलिए यह बहुत लंबा है।

इनपुट लेता $aसे, छोरों 1को $a.length(में संग्रहीत $xबाद में उपयोग के लिए)। प्रत्येक पुनरावृत्ति हम किसी इनपुट $aया अनुक्रमणिका में अनुक्रमित $a[$x..0]( या , उलट) का उपयोग करते हैं, इस आधार पर कि हमारा इनपुट नंबर विषम / सम है [$_%2]। ये सभी -joinएक ही स्ट्रिंग बनाने के लिए एक साथ parens और ed में संक्षिप्त हैं । यह पाइपलाइन पर छोड़ दिया गया है, और आउटपुट निहित है।

PS C:\Tools\Scripts\golfing> .\stringgnirts.ps1 'TimmyD'
TimmyDDymmiTTimmyDDymmiTTimmyDDymmiT
— AdmBorkBork
स्रोत
2

जावा, 151 बाइट्स

public static void r(String s){String t = new StringBuffer(s).reverse().toString();for(int i=0;i<s.length();i++){System.out.print(((i%2==1)?t:s));}}

}

Ungolfed:

public static void r(String s) {
    String t = new StringBuffer(s).reverse().toString();
    for(int i = 0; i < s.length();i++) {
        System.out.print(((i % 2 == 1) ? t : s));
    }
}

— हर्ब वोल्फ
स्रोत
1
नमस्ते, PPCG में आपका स्वागत है! सबसे पहले मैं जावा में गोल्फिंग के लिए टिप्स के माध्यम से पढ़ना चाहूंगा । आपके कोड के लिए, कुछ चीजें हैं जो अभी भी गोल्फ हो सकती हैं: आप public staticअपने तरीके से पहले हटा सकते हैं । आप बीच के रिक्त स्थान को निकाल सकते हैं t=new StringBuffer। आप अनावश्यक कोष्ठक और कोष्ठक को हटा सकते हैं। और तुम से मॉड्यूल की जांच स्वैप कर सकते हैं ==1करने के लिए <1(जो के बराबर है ==0गैर ऋणात्मक संख्याओं के लिए)। इसके अलावा, आप i++for-loop के अंदर अंतिम उपयोग के लिए जा सकते हैं ।
— केविन क्रूज़सेन
6
तो कुल मिलाकर यह हो जाता है: void r(String s){for(int i=0;i<s.length();)System.out.print(i++%2<1?s:new StringBuffer(s).reverse()+"");}( 105 बाइट्स )
— केविन क्रूज़सेन
2

सी #, 94 बाइट्स

using System.Linq;string R(string n)=>string.Concat(n.SelectMany((c,i)=>1>i%2?n:n.Reverse()));

LINQ आयात के लिए विधि + 18 बाइट्स के लिए 76 बाइट्स।

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

using System.Linq; // Required for LINQ extension methods.

string R(string n) => 
    string.Concat( // Concatenate the following chars into a single string
        n.SelectMany( // Enumerate each char in n, flattening the returned IEnumerable<char>'s into a single IEnumerable<char>
            /*IEnumerable<char> Lambda*/(/*char*/ c, /*int*/ i) => // i = index in n
                1 > i % 2 // Check if i is even or odd
                    ? n // if i is even, add n to the concat
                    : n.Reverse() // else reverse n and concat that
        )
    )
;
— दूध
स्रोत
2

ऑक्टेव, 39 35 बाइट्स

@(x)[x'+~x;flip(x'+~x),''](1:end/2)

f('Hello!')
ans = Hello!!olleHHello!!olleHHello!!olleH

स्पष्टीकरण:

@(x)            % Take x as input, inside apostrophes 'Hello!'
x'+~x           % Create a mesh of the ASCII-code of the input letters
                % For input `bcd` this will be:
                %    98    98    98
                %    99    99    99
                %   100   100   100
;flip(x'+~x)   % Concatenate vertically to create:
                %    98    98    98
                %    99    99    99
                %   100   100   100
                %   100   100   100
                %    99    99    99
                %    98    98    98
___,'']         % Short cut to convert ASCII-code to characters
(1:end/2)       % Display the first half of this array of letters, as a
                % horizontal string

लुइस के लिए धन्यवाद 4 बाइट्स बचाए। सहेजे गए एक बाइट के ~xबजाय 0*x(कार्य करता है क्योंकि x के सभी तत्व गैर-शून्य हैं। सहेजे गए दो बाइट्स के flipबजाय flipud(मुझे नहीं पता flipथा कि अस्तित्व में है)।

— स्टीवी ग्रिफिन
स्रोत
2

बैश + उपयोग-लिनेक्स, 68 58 53 बाइट्स

y=$1;for((i;i<${#1};i++)){ echo -n $y;y=`rev<<<$y`;}

व्याख्या

forपाश के साथ दो बातें :

  • forलूप लिखने का एक जाहिरा तौर पर अनजाना तरीका है जहां एक doऔर doneघुंघराले ब्रेसिज़ के साथ कीवर्ड की जगह लेता है {और }। पहले ब्रैकेट के बाद की जगह आवश्यक है, और अंत में अर्धविराम भी आवश्यक है।
  • यह पता चला है कि "सी-स्टाइल" forलूप्स में, आप उपयोग करने के i;बजाय केवल प्रारंभिक कर सकते हैं i=0;।
  • ${#1}स्थिति का हिस्सा i < ${#1}हमारे इनपुट की लंबाई (पहला पैरामीटर $1) को संदर्भित करता है । सामान्य तौर पर, आप ${#foo}स्ट्रिंग के आकार को पुनः प्राप्त करने के लिए उपयोग कर सकते हैं $foo।

इसके अतिरिक्त:

  • rev उपयोग में उपकरण-लाइनक्स है जो एक स्ट्रिंग को उलट देता है।
  • हमें नई खबरों से छुटकारा पाने के लिए -nझंडे को पास करना होगा echo।
  • अभिव्यक्ति rev<<<$yको यहां स्ट्रिंग कहा जाता है ( यह प्रासंगिक tldp.org पृष्ठ देखें ), जो चर $yको मानक इनपुट के पास देता है rev।
— फ्रेम
स्रोत
कृपया अपने कुछ ज्ञान की व्याख्या करें। इसके अलावा, शायद प्रतिध्वनि से पहले की जगह हटाने योग्य हो सकती है, मैं हालांकि बैश पर जानकार नहीं हूँ
— रोहन झुनझुनवाला
@ रोहन झुनझुनवाला ने कुछ चीजों को स्पष्ट करने में मदद करने के लिए उत्तर के बारे में थोड़ा स्पष्टीकरण दिया। इसके अलावा: जब छोड़ते हुए doऔर doneएक में कीवर्ड forपाश, आप वास्तव में है की जरूरत है कि अंतरिक्ष!
— फ्रेम
+1 अब अच्छा लग रहा है। मैंने onlly टिप्पणी की क्योंकि आपके कोड ने एक स्वचालित कम गुणवत्ता वाला ध्वज खींचा था। कोड-ओनली आंसर मिलेंगे ऑटो को हरी झंडी
— रोहन झुनझुनवाला
y=$1;for((;i<${#1};i++)){ printf $y;y=`rev<<<$y`;}... बाइट के एक जोड़े को बचाया
— लूटपाट
2

जाप , 11 बाइट्स

ê1 pUÊ ¯Uʲ
ê1          // Append the reverse of the input to the input,
   pUÊ      // then repeat it input length times
       ¯Uʲ // and finally trim to length input length squared.

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

— लीख
स्रोत
1
— झबरा
@ शैगी मैंने इसका उपयोग करने की कोशिश की, लेकिन मेरे जीवन के लिए, मैं इसे लटका नहीं सकता। : पी उदाहरण के लिए बहुत बहुत धन्यवाद, हालांकि!
— नाइट
क्षमा करें, गलत लिंक पोस्ट किया गया, यह वास्तव में 6 बाइट्स है ।
— झबरा
— ओलिवर
1
@ शैगी मुझे बुरा नहीं लगेगा, और यह नित के जवाब से काफी अलग है। इसके लिए जाओ यार।
— ओलिवर
2

05AB1E , 7 बाइट्स

vDR}v}J

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

उस पर काम करना जारी रखेंगे। मुझे वास्तव में इसका "v}" हिस्सा पसंद नहीं है, शायद वहाँ एक बाइट बचा सकता है।

व्याख्या

vDR}v}J

v         ; Iterates through each character
 D        ; Duplicate top of stack
  R       ; Push top of stack reversed
   }      ; end for loop
   v}     ; same as other v, effectively pops top of stack off
     J    ; Join everything together
— मल्टी
स्रोत
1
vÂ}\J 5 बाइट्स आपके कोड के समान हैं, लेकिन उन बिलिनों के साथ जिन्हें आप ढूंढ रहे थे। :)ÂBifurcate (डुप्लिकेट और रिवर्स के लिए छोटा है, जो वास्तव में आप क्या कर रहे हैं)। \ स्टैक पर शीर्ष आइटम हटाता है।
— केविन क्रूज़सेन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.