सरल स्ट्रिंग प्रतिबिंब

26

चलो एक स्ट्रिंग में एक चरित्र के प्रतिबिंब को परिभाषित करके शुरू करते हैं :

बिना किसी रिक्त स्थान वाले अलग-अलग लोअरकेस वर्णमाला के साथ एक स्ट्रिंग को देखते हुए जैसे कि abcdefg, स्ट्रिंग में एक अक्षर का प्रतिबिंब cइसे स्थानांतरित करने के बिना (किसी भी अन्य पत्र के आदेश को बदलने के बिना) स्ट्रिंग में एक नए स्थान पर इस तरह से कि मूल रूप से अक्षरों की संख्या इसके दाईं ओर अब इसके बाईं ओर अक्षरों की संख्या है।

इस प्रकार, पत्र का एक प्रतिबिंब cमें abcdefgहोगा abdecfg। स्पष्टीकरण: के दाईं ओर 4 पत्र थे cऔर अब, के बाईं ओर 4 पत्र हैं c।

कुछ और उदाहरण:

चरित्र eको दर्शाते हुए, myfriendस्ट्रिंग का निर्माण करेंगेmyefrind

चरित्र aको दर्शाते हुए, axyzस्ट्रिंग का निर्माण करेंगे xyza।

चरित्र bको दर्शाते हुए, abcस्ट्रिंग का निर्माण करेंगे abc।

चरित्र dको दर्शाते हुए, dस्ट्रिंग का निर्माण करेंगे d।

चरित्र eको दर्शाते हुए, efस्ट्रिंग का निर्माण करेंगे fe।

अधिक जानकारी के लिए या कुछ परीक्षण मामलों को आज़माने के लिए, यहाँ एक (कुछ लंबा) कार्यक्रम है जो मैंने C ++ में लिखा है।

चुनौती

अलग लोअरकेस अक्षरों के साथ एक स्ट्रिंग को देखते हुए, प्रत्येक वर्ण के माध्यम से वर्णानुक्रम में जाएं और इसे स्ट्रिंग में "प्रतिबिंबित" करें।

स्पष्टता: स्ट्रिंग में अक्षर से होते हैं a-z, कोई रिक्त स्थान नहीं होते हैं, अक्षर अद्वितीय होते हैं, और स्ट्रिंग कम से कम 1 अक्षर लंबा और अधिकतम 26 अक्षर लंबा होता है।

उदाहरण

इनपुट: dcba। आउटपुट: dcba।

कारण: सबसे पहले, aइसे प्रतिबिंबित करें क्योंकि यह स्ट्रिंग में वर्ण है जो वर्णमाला में जल्द से जल्द आता है। आपको मिलेगा adcb। फिर, bजैसा कि वर्णमाला में आता है , उसे प्रतिबिंबित करें badc। फिर, cपाने के लिए प्रतिबिंबित करें cbad, और फिर dपाने के लिए dcba।

इनपुट: myface। आउटपुट: fyecma।

संकेत: आदेश में अक्षरों के माध्यम से जाओ a, c, e, f, m, y।

इनपुट: a। आउटपुट: a।

इनपुट: acb। आउटपुट: bac।

इनपुट: cwmfjordbankglyphsvextquiz। आउटपुट: ieabhqzugdltkfnvpjxsormycw।

स्कोरिंग

  • इनपुट और आउटपुट किसी भी सुविधाजनक विधि द्वारा दिया जा सकता है ।
  • या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
  • मानक खामियों को मना किया जाता है।
  • यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।
  • पोस्टिंग के बाद ~ 100 घंटे स्वीकार करना।

वर्तमान विजेता

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

code-golf  string 
— NL628
स्रोत
2
किसी ने मुझे अंतर्दृष्टि दे सकता है कि क्या यह पहेली ठीक है? यह मेरा दूसरा यहाँ है (मेरी पहली बंद विषय के रूप में बंद किया गया था ... जो)। मैंने इसे वास्तव में पूरा करने की कोशिश की, लेकिन मुझे यकीन नहीं है कि मुझे कुछ याद आ रहा है। मैं वास्तव में इस एसई में सुधार करना और मज़े करना चाहता हूं! धन्यवाद दोस्तों: D
— NL628
6
यह अच्छा लग रहा है। मैं कुछ लंबे उदाहरण दे सकता हूं (विशेष रूप से, यह पहले उदाहरण अनुभाग के लिए अच्छा हो सकता है कि जो प्रतीत होता है किनारे के मामलों की तुलना में अधिक प्रस्तुत करें)।
— फलन
1
स्पष्टीकरण का अनुरोध: " अक्षर अद्वितीय हैं " का अर्थ है कि प्रत्येक अक्षर इनपुट में केवल एक बार होता है, क्या यह सही है?
— GPS
4
क्या हम लोअरकेस के बजाय अपरकेस में इनपुट और आउटपुट ले सकते हैं?
— केविन क्रूज़सेन
5
@ NL628 वैसे, यदि आप इसे पोस्ट करने से पहले एक चुनौती पर अंतर्दृष्टि प्राप्त करना चाहते हैं, तो इसे सैंडबॉक्स में पोस्ट करें ।
— एर्ग आउटफोलर

जवाबों:

8

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

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

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

चुनौती विनिर्देश में वर्णित प्रतिबिंबों के अलावा, यह कोड भी स्ट्रिंग को ठीक 26 बार उलट देता है। इससे अंतिम आउटपुट पर कोई प्रभाव नहीं पड़ता है।

# Push 26
<>((((()()()){}){}()){})

# Do 26 times:
{(({}[()])<

  # Subtract 122 from counter to get negative lowercase letter
  ({}[(((((()()()()()){}){}){})()){}{}])

  # For each character in string:
  <>{

    # Keep a copy of pivot letter on the third stack
    <>(({})<

    # Move next letter to other stack and compare to pivot
    ({}<>({}<>))

    # If letters are equal:
    ((){[()](<{}>)}{}){

      # Keep current letter separate from this transformation
      {}(<({}<

      # While keeping a copy of current stack height:
      ([]<

        # Move all letters to one stack
        <>{({}<>)<>}<>

      >)

      # Move a number of letters equal to old stack height back
      {({}[()]<({}<>)<>>)}{}

      >)>)

    }{}>)<>

  }

  # Destroy pivot letter
  <>{}<>

>)}

# Switch stack for output
<>
— Nitrodon
स्रोत
1
वाह यह बहुत ही अद्भुत है। मैं इसे समझ भी नहीं सकता: O +1
— NL628
7

05AB1E , 20 17 बाइट्स

{vð.øy¡€á€gsJ£yý

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

व्याख्या

पहले पुनरावृति के लिए उदाहरण के साथ myface

{v                  # for each char y in sorted input
  ð.ø               # surround current string with spaces
                    # STACK: ' myface '
     y¡             # split at current letter
                    # STACK: [' myf', 'ce ']
       ۇ           # remove non-letters
                    # STACK: ['myf','ce']
         €g        # get the length of each string in the pair, reversed
                    # STACK: ['myf','ce'], [2,3]
            sJ      # join the pair back to a string
              £     # split into 2 pieces of the calculated sizes
                    # STACK: ['my','fce']
               yý   # join on the current char y
                    # STACK: 'myafce'

स्ट्रिंग को प्रत्येक पुनरावृत्ति के साथ रिक्त स्थान के साथ घेर लिया गया है क्योंकि स्ट्रिंग के पहले या अंतिम अक्षर को विभाजित करने के परिणामस्वरूप एक लंबाई -1 सूची होगी अन्यथा मर्ज में वह अक्षर शामिल नहीं होगा।

— Emigna
स्रोत
1
17 बाइट्स?!? !! अद्भुत..आपके लिए सिर्फ एक बाइट द्वारा एमनेटिक पिटाई कर रहा है: पी
— एनएल 628
1
मम्म ... वाह, केवल एक चीज जिसे मैं देख सकता था, वह रिक्त स्थान के साथ घेर को हटा रही है। अजीब लगता है कि हम उस के लिए एक और विकल्प नहीं मिल सकता है।
— मैजिक ऑक्टोपस Urn
1
@MagicOctopusUrn: यह सबसे छोटा तरीका है जिसे मैंने पहले या अंतिम चरित्र के विभाजन से निपटने के लिए पाया है। यह हालांकि उसके लिए बहुत सारे बाइट्स की तरह महसूस करता है
— Emigna
5

पायथ, 18 16 19 16 बाइट्स

VSQ=QXx_QN-QNN)Q

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

व्याख्या

VSQ=QXx_QN-QNN)Q
VSQ           )       For each character (N) in the sorted input (Q)...
          -QN         ... remove the character from Q...
      x_QN            ... get the reflected position...
     X       N        ... insert N...
   =Q                 ... and save the result into Q.
               Q      Output the final result.
वाह 16 बाइट्स? मैं उत्थान करूंगा, लेकिन दुख की बात है कि मैं अपनी दैनिक मतदान की सीमा तक पहुंच गया हूं। 6 घंटे में करेंगे: P
— NL628
4

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

मुझे यह याद दिलाने के लिए कि फल उनके तर्क को संशोधित करके वापस आ सकते हैं, के लिए एसॉलंगिंग फल के लिए धन्यवाद। 

lambda x:[x.insert(len(x)+~x.index(i),x.remove(i)or i)for i in sorted(x)]

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

वर्णों की सूची के रूप में इनपुट लेता है।

— मजाक कर रहा है
स्रोत
3
वाह मैंने C ++ और पायथन 3 में भी एक उत्तर लिखा। मेरे पायथन 3 का उत्तर आपके लिए दो बार ठीक था ... +1
— NL628
3

रेटिना 0.8.2 , 61 बाइट्स

$
a
{`(.)(.*)\1$
$2$.`$*_$1$1
+`(.)_(_*.)
$2$1
}T`_l`l!`.$
!

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

$
a

पर पाश शुरू करो a।

{`(.)(.*)\1$
$2$.`$*_$1$1

यदि इनपुट में वर्तमान अक्षर है, तो _मूल स्थिति का प्रतिनिधित्व करने वाले स्ट्रिंग के साथ इसे अंत तक ले जाएं ।

+`(.)_(_*.)
$2$1

प्रत्येक _अक्षर को एक वर्ण पर वापस ले जाने के लिए।

}T`_l`l!`.$

पत्र में वृद्धि। zइसे बदलने के बाद यह !कुछ भी मेल नहीं खाता है और लूप समाप्त होता है।

!

हटाएं !।

— नील
स्रोत
3

जावा 8, 140 96 92 88 87 85 बाइट्स

s->{for(char c=9;++c>0;){int i=s.indexOf(c);if(i>=0)s.add(s.size()+~i,s.remove(i));}}

-44 बाइट्स @TFeld के पायथन 2 उत्तर का एक पोर्ट बनाते हैं ।
-6 बाइट्स @ OlivierGrégoire को धन्यवाद ।

नया बनाने के बजाय इनपुट सूची को संशोधित करता है।

स्पष्टीकरण:

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

s->{                     // Method with ArrayList<Character> parameter and no return-type
  for(char c=9;++c>0;){  //  Loop over all characters known
                         //  (except for the first 9 unprintables)
    int i=s.indexOf(c);  //   Index of the character, or -1 of it isn't present
    if(i>=0)             //   If the current character is present in the List
      s.add(s.size()+~i,s.remove(i));}}
                         //    Change the position of this character to index `l-i-1`,
                         //    (where `l` is the size of the input-List)
— केविन क्रूज़सेन
स्रोत
1
— ओलिवियर ग्रेगोइरे
1
@ ओलिवियरग्रेगायर धन्यवाद। और 1 से अधिक लूपिंग केवल वर्णमाला वर्णों से अधिक है। :)
— केविन क्रूज़सेन
2
ठीक है, अगर आप उस सड़क पर जाते हैं, तो for(char c=9;++c>1;)बेहतर है ;-)
— ओलिवियर ग्रेजायर
@ OlivierGrégoire आह, charजैसे भी चारों ओर लपेटता है Integer.MAX_VALUE + 1 == Integer.MIN_VALUE.. स्मार्ट!
— केविन क्रूज़सेन
@ ओलिवियरग्रेयर sएक एरियरिस्ट है, इसलिए indexOfसामान्य प्रकार का होगा T(जो Characterइस इनपुट सूची के लिए है)।
— केविन क्रूज़सेन
3

जावास्क्रिप्ट, 85 80 79 बाइट्स

-6 बाइट्स @DanielIndie को धन्यवाद

a=>[...a].sort().map(i=>a.splice(s=a.indexOf(i),1)&&a.splice(a.length-s,0,i))&&a

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

— फल तोड़ना
स्रोत
यह नहीं है "संकलन" एक एक स्ट्रिंग है और आप
— बंटवारे का
@DanielIndie इनपुट को Jo King के Python समाधान की तरह वर्णों के एक सरणी के रूप में पारित किया जाना चाहिए।
— फल
— डैनियलइंडी
आप उस फ़ंक्शन से कुछ भी वापस नहीं करते हैं, या इसे प्रिंट नहीं करते हैं
— डैनियलइंडी
@DanielIndie फ़ंक्शंस अपने तर्कों को संशोधित करके वापस आ सकते हैं।
— फल
2

लाल , 96 94 बाइट्स

2 बाइट्स केविन क्रूज़सेन की बदौलत बच गए 

func[x][foreach c sort copy x[i:(length? x)+ 1 - index? find x c insert at replace x c""i c]x]

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

अधिक पठनीय:

f: func[x][
    foreach c sort copy x[                  ; for each symbol in the sorted input
       i: (length? x) + 1 - index? find x c ; find its index and reflect it 
       insert at replace x c "" i c         ; remove it by replacing it with an empty char 
                                            ; and insert the symbol at its new index   
    ]
    x                                       ; return the transformed string
]
— गैलेन इवानोव
स्रोत
1
आप को बदलने के द्वारा 2 बाइट्स बचा सकते हैं find x c replace x c""insert at x i cकरने के लिए find x c insert at replace x c""i cएक से छुटकारा पाने के xऔर अंतरिक्ष।
— केविन क्रूज़सेन
@ केविन क्रूज़सेन धन्यवाद, केविन, यह अब बहुत बेहतर है!
— गैलेन इवानोव
2

आर , 73 72 69 बाइट्स

function(s){for(x in sort(s))s=append(s[x!=s],x,match(x,rev(s))-1);s}

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

इनपुट और आउटपुट एक वेक्टर वर्ण।

— किरिल एल।
स्रोत
ew, cएक चर नाम के रूप में उपयोग कर रहा है ? यह भयानक है, यहां तक ​​कि कोड गोल्फ के लिए भी!
— Giuseppe
खैर, मैं स्पष्ट रूप से इसे बदल सकता हूं, लेकिन मैं यह देखकर वास्तव में हैरान हूं कि यह यहां किसी को भी परेशान कर सकता है। मैं वास्तव में अप्रयुक्त बिल्ट-इन के बजाय चर नामों (जैसे ) के cलिए कुछ अर्थों को संरक्षित करने को प्राथमिकता देता हूं char।
— किरिल एल।
ठीक है, जब एक सुधार की तलाश में (जो, मैंने नहीं किया) मैंने खुद को उपयोग करने की कोशिश की c, और यह भयानक था जब मैं समझ नहीं पाया कि क्या हो रहा है। मैं आमतौर पर उपयोग Kया kया यहाँ तक कि Cबस ऐसे ही समस्याओं से बचने के लिए, लेकिन मैं पूरी तरह समझ गया। appendनौकरी के लिए सही उपकरण है।
— Giuseppe
ओह, मैं देख रहा हूं, इसके बारे में खेद है, भविष्य में इस तरह के "जाल" को स्थापित करने से बचने की कोशिश करेंगे।
— किरिल एल।
2

जाप , 23 22 बाइट्स

¬n rÈ+S kY iYJ-XbY)x}U
¬n                     // Split the input into chars and sort it.
   r                }U // Then reduce the result with initial value of the input.
    È+S                // Append a space for replacing edge cases and
        kY             // remove the current char from the string.
           iY          // Insert it back
             J-XbY     // at the calculated index,
                  )x   // and remove the unnecessary space once we're done.

ओलिवर के लिए धन्यवाद एक बाइट को बचाया ।
इसे ऑनलाइन आज़माएं!

— लीख
स्रोत
1
अच्छा है। आप बदल सकते हैं ,Éके साथJ
— ओलिवर
@ ओलिवर बहुत बहुत धन्यवाद, मैं अभी भी हर बार डिफ़ॉल्ट चर का उपयोग करना भूल जाता हूं, यह बहुत आसान है।
— लीख
1

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

s#c|(h,_:t)<-span(/=c)s,(v,w)<-splitAt(length t)$h++t=v++c:w|1<2=s
f s=foldl(#)s['a'..]

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

f s=foldl(#)s['a'..]         -- fold the function '#' into all characters from 'a'
                              -- with the starting value of the input string s
s#c=                          -- in each step (s: result so far, c: next char)
   (h,_:t)<-span(/=c)s        -- let 'h' be the substring before 'c' and
                              -- 't' the substring after 'c'. the pattern match
                              -- fails if there's no 'c' in 's'
   (v,w)<-splitAt(length t)$h++t
                              -- split the string 'h++t' at index length of t
   =v++c:w                    -- return 'v' followed by 'c' followed by 'w'
   |1<2=s                     -- if there's no 'c' in 's', return 's' unchanged
— nimi
स्रोत
यह रुकता क्यों है? एक अनंत सूची में गुना नहीं होना चाहिए एक अनंत लूप? यह नहीं होना चाहिए f s=foldl(#)s['a'..'z']?
— user1472751
1
@ user1472751: ['a'..]अनंत नहीं है, क्योंकि Charवर्ग से संबंधित है Bounded। के साथ एक सूची ..]के Boundedमूल्यों पर रुक जाता है maxBound। प्रयास करें: print [False ..]।
— nimi
1

SNOBOL4 (CSNOBOL4) , 132 128 बाइट्स

	DEFINE('I(I)')
I	U =&LCASE
N	U LEN(1) . K REM . U	:F(RETURN)
	I ARB @S K	:F(N)
	I K =
	I ARB . L RPOS(S) REM . R
	I =L K R	:(N)

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

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

	I =INPUT			;* read input
	U =&LCASE			;* alias for lowercase letters (it started out as uppercase)
N	U LEN(1) . K REM . U	:F(O)	;* set K to the next lowercase letter, and when empty, goto O
	I ARB @S K	:F(N)		;* set S to the number of letters before K, or goto N
	I K =				;* remove K
	I ARB . L RPOS(S) REM . R	;* set R to the last S characters of I and L to the others
	I =L K R	:(N)		;* recombine the string and goto N
O	OUTPUT =I			;* print new string
END
— ग्यूसेप
स्रोत
1

जेली ,  12  11 बाइट्स

W;ṢḟṁUṣ¥jʋ/

पात्रों की एक सूची को स्वीकार करने और वर्णों की सूची को वापस करने वाला एक विचित्र लिंक।

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

कैसे?

W;ṢḟṁUṣ¥jʋ/ - Link: list of characters V  e.g. "myface"  ...i.e. ['m','y','f','a','c','e']
W           - wrap V in a list                 ["myface"]
  Ṣ         - sort V                           ['a','c','e','f','m','y']
 ;          - concatenate                      ["myface",'a','c','e','f','m','y']
          / - reduce with:
         ʋ  -   last four links as a dyad:
            -   (i.e. start with "myface" on the left and 'a' on the right 
            -         2nd iteration has that result on the left and 'c' on the right
            -         and so-forth)            e.g. left = myface, right = 'a'
   ḟ        -     filter out (right from left)      "myfce"
       ¥    -     last two links as a dyad:
     U      -       upend left                      "ecafym"
      ṣ     -       split at occurrences of right   ["ec","fym"]
    ṁ       -     mould (ḟ(x,y)) like (Uṣ¥(x,y))    ["my","fce"] 
         j  -   join with right                   "myafce"
— जोनाथन एलन
स्रोत
ठीक है, यह एक बहुत कुछ और सब कुछ बर्बाद कर देता है ...
— NL628
1
वैसे मुझे लगता है कि जेली के लिए क्या है - मैं डेनिस (जेली के निर्माता) से अपेक्षा करता हूं कि वह एक छोटे को प्रस्तुत करे!
— जोनाथन एलन
Lol बहुत ही अद्भुत है: P लेकिन मैं b / c को अपडाउन नहीं कर सकता / सकती हूं, मैंने अपना दैनिक वोट काउंट किया..rip
— NL628
1
... मुझे लगता है कि ḟ(फ़िल्टर आउट) के उपयोग से बाइट को बचाने का एक तरीका हो सकता है, लेकिन मैंने अभी तक इसे प्रबंधित नहीं किया है।
— जोनाथन एलन
1
ऐसा लगता है, समय-वार, यह हे (n लॉग एन) इनपुट की लंबाई में है क्योंकि यह पहले पायथन का उपयोग करता है sortedऔर फिर कम पुनरावृत्तियों में जुड़ता है, जो कम जटिल ऑपरेशन (चंचलता, विभाजित सूचकांकों में विभाजित, जुड़ते हुए, उलटते हुए) दिखाई देते हैं )। - और पायथन sortedहै O (n log n)।
— जोनाथन एलन
1

सी (क्लैंग) , 164 162 बाइट्स

y,n,a,b,c,p,i;f(char*s,l){for(i=0;p=0,++i<123;p<l&&(y=s[p],n=l+~p,a=p+1,b=p,n<p&&(a=n,b=n+1),c=l+~(2*(n<p?n:p)),memmove(s+b,s+a,c),s[n]=y))while(s[p]^i&&p<l)p++;}

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

f() चार-तरफा इनपुट स्ट्रिंग और इस सरणी की लंबाई को पैरामीटर के रूप में लेता है और जगह में आवश्यक प्रतिबिंब करता है।

callf() सुंदर छपाई करता है।

क्रेडिट

-2 बाइट्स। @Kevin। धन्यवाद

— GPS
स्रोत
1
आप 2 बाइट को बचाने के लिए स्थान को char *sबदल सकते हैं और बदल सकते हैं । i=96i=9
— केविन क्रूज़सेन
अच्छी पकड़ .. हम से शुरू करने की जरूरत नहीं है a। धन्यवाद
— जीपीएस
— सीलिंगकैट
1

एपीएल + विन, 63 बाइट्स

इनपुट स्ट्रिंग के लिए संकेत

l←s[⍋⎕av⍳s←,⎕]⋄⍎∊(⍴s)⍴⊂'s←(n←⌽~s=↑l)\s~↑l⋄((~n)/s)←↑l⋄l←1↓l⋄'⋄s

स्पष्टीकरण:

l←s[⍋⎕av⍳s←,⎕] sort characters into alphabetical order

⍎∊(⍴s)⍴⊂'....' create an implicit loop for each character

s←(n←⌽~s=↑l)\s~↑l⋄((~n)/s)←↑l do the relection for first character in l

l←1↓l drop the first character in l

s display the result

⋄ statement separator
— ग्राहम
स्रोत
1

पर्ल , 74 70 बाइट्स

84 80 बाइट्स जिसमें यूनिक्स फिल्टर के रूप में इनवोकेशन शामिल है

for$c(a..z){if($p=1+index$_,$c){substr$_,$p-1,1,"";substr$_,-$p,0,$c}}

$ echo -e 'dcba\nmyface\na\nacb\ncwmfjordbankglyphsvextquiz' |
> perl -pE'for$c(a..z){if($p=1+index$_,$c){substr$_,$p-1,1,"";substr$_,-$p,0,$c}}'
dcba
fyecma
a
bac
ieabhqzugdltkfnvpjxsormycw
— हाइनेक-पीची- विचोडिल
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.