फ़्लिपिग्ने लेटेसर अरोडन

33

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

आपका कार्य, यदि आप इसे स्वीकार करना चाहते हैं, तो एक प्रोग्राम लिखना है जो प्रत्येक शब्द के अंतिम दो अक्षर दिए गए स्ट्रिंग में है (इसलिए शब्द Thanskबदल जाता है Thanks)। एक शब्द अंग्रेजी वर्णमाला में दो या दो से अधिक अक्षरों का एक अनुक्रम होता है जो एक ही स्थान द्वारा सीमांकित होता है ।

  • आपके द्वारा इनपुट के रूप में प्राप्त किए जाने वाले वर्णों की सूची / सूची में केवल वर्णमाला वर्ण और रिक्त स्थान (ASCII [97 - 122], [65 - 90] और 32) होने की गारंटी है।

  • आप इनपुट ले सकते हैं और किसी भी प्रोग्रामिंग भाषा में किसी भी मानक विधि के माध्यम से आउटपुट प्रदान कर सकते हैं , जबकि ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

  • आउटपुट में एक अनुगामी स्थान और / या एक अनुगामी न्यूलाइन हो सकता है।

  • इनपुट में हमेशा केवल शब्द होंगे (और संबंधित व्हाट्सएप) और कम से कम एक शब्द शामिल होगा।

यह कोड-गोल्फ है, इसलिए प्रत्येक भाषा में कम से कम सबमिशन (बाइट्स में स्कोर) होता है!

परीक्षण के मामलों

ध्यान दें कि तार पठनीयता के लिए उद्धरण के साथ घिरे हैं।

इनपुट -> आउटपुट

"थान्सक" -> "धन्यवाद"
"Youer welcoem" -> "Youre welcome"
"यह एक सेब है" -> "थसी सी ना अपेल"
"Flippign Lettesr Aroudn" -> "फ़्लिपिंग लेटर्स अराउंड"
"tHe oDd chALlEneg wiht swappde lettesR" -> "teH odD chALlEnge with swapped letteRs"

या, परीक्षण सूट सुविधा के लिए, यहां इनपुट और उनके संबंधित आउटपुट अलग-अलग हैं:

Thansk
Youer welcoem
यह एक सेब है
फ़्लिपिग्ने लेटेसर अउरडन
tHe oDd chALlEneg wiht swappde lettesR

धन्यवाद
आपका स्वागत है
थसी सी ना अपेल
चारों ओर पत्र लहराते हुए
टीएचडी ओडीडी के साथ स्वेप्ट लेटेआरआर के साथ कोलज

शीर्षक के लिए DJMcMayhem का धन्यवाद । यह मूल रूप से CMC था ।

code-golf  string 
— मिस्टर एक्सकोडर
स्रोत
क्या हम शब्दों की एक सरणी का उत्पादन कर सकते हैं?
— झबरा
@ शगुन नहीं, आउटपुट एक स्ट्रिंग होना चाहिए (या डिफ़ॉल्ट रूप से वर्णों की एक सूची)
— श्री Xcoder
क्या हम प्रत्येक इनपुट पर अनुगामी स्थान का अनुरोध कर सकते हैं?
— FlipTack
@FlipTack को प्रारंभिक संस्करण में इसकी अनुमति दी गई थी , लेकिन मैंने किसी भी उत्तर को पोस्ट करने से पहले उस नियम को हटा दिया है। (आंशिक रूप से क्योंकि कुछ उपयोगकर्ताओं ने मुझे बताया कि मैं इसे बहुत आसान बना रहा हूं अन्यथा, और मैं उनसे सहमत हूं)। नहीं, इसकी अनुमति नहीं है।
— श्री एक्सकोडर
1
@ फ़ेबियन एक शब्द दो या दो से अधिक अक्षरों का एक क्रम है
— श्री Xcoder

जवाबों:

16

वी , 4 5 बाइट्स

òeXp

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

|| कर्सर को दर्शाता है

बफर शुरू होता है |w|ord and more wordsऔर कर्सर पहले वर्ण पर होता है।

रिकर्सिवली ò

eकिसी शब्द के nd पर जाएं

wor|d| and more words

Xकर्सर के बाईं ओर वर्ण निकालें

wo|d| and more words

pइसे अगले चरित्र पर देखें

wod|r| and more words

अंतर्निहित अंत ò, बफर के अंत तक अन्य शब्दों के लिए उसी प्रक्रिया को दोहराएं

— क्रिकटी लिथोस
स्रोत
2
कार्य के लिए :) सही भाषा
— DJMcMayhem
क्या आपका मतलब है "पुनरावर्ती" के बजाय "बार-बार"?
— 15
@NieDzejkob वी विकी òकमांड github.com/DJMcMayhem/V/wiki/Normal-Mode-Commands
— Kritii लिथो
10

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

Ḳœ?@€2K

पात्रों की सूची लेने और लौटाने की एक विवादास्पद कड़ी

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

कैसे?

Ḳœ?@€2K - Link: list of characters
Ḳ       - split at spaces
     2  - literal two
    €   - for €ach:
   @    -   with sw@pped arguments:
 œ?     -     nth permutation (the 2nd permutation has the rightmost elements swapped)
      K - join with spaces
— जोनाथन एलन
स्रोत
यह क्रमपरिवर्तन का एक अच्छा दुरुपयोग है। वैकल्पिक
— श्री एक्सकोडर
@ Mr.Xcoder Ḳ2œ?ЀKभी काम करता है और एक त्वरित का उपयोग करता है।
— डेनिस
7

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

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

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

नौकरी के लिए सबसे खराब भाषा :)

पठनीय थोड़ा अधिक पठनीय संस्करण:

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

    {
        {}
        <>

        (({}({}))[({}[{}])])

        (<>)
    }
    {}

    ({}<>)<>

}<>

(({}({}))[({}[{}])])

{

    ({}<>)
    <>
}<>
— DJMcMayhem
स्रोत
मुझे विश्वास नहीं हो रहा है कि यह ब्रेनफक संस्करण की तुलना में अधिक लंबा है ...
— प्योरफेरेट
@pureferret ब्रेन-फ्लैक ब्रेनफक की तुलना में अधिक लंबा होता है। ज्यादातर कारण यह प्रति आदिम कमांड के लिए दो बाइट्स की आवश्यकता होती है, जहां मस्तिष्क-फ्लैक को दो की आवश्यकता होती है।
— DJMcMayhem
7

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

(f=<<).words
f[a,b]=b:a:" "
f(x:r)=x:f r

इसे ऑनलाइन आज़माएं! उपयोग उदाहरण: (f=<<).words $ "abc xyz"पैदावार "acb xzy "।

— Laikoni
स्रोत
तो आप मुझे बता रहे हैं सबसे छोटा दृष्टिकोण दोनों दृष्टिकोण संयुक्त है? > _ <
— पूरी तरह से अमानवीय
6

अजगर ३ , 50 बाइट्स

print(*(w[:-2]+w[:-3:-1]for w in input().split()))

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

यह उत्तर पायथन 3 के प्रिंट के व्यवहार का दुरुपयोग करता है: उनके बीच एक ही स्थान के साथ कई तर्क मुद्रित होते हैं। बेशक, हम इसे केवल कई तर्क नहीं दे सकते क्योंकि हम नहीं जानते कि इनपुट में कितने शब्द होंगे। इसलिए हम स्पैट ऑपरेटर का उपयोग करते हैं । मूल रूप से

print(*[a,b,c])

बिल्कुल वैसा ही है जैसा कि

print(a,b,c)

गाली देना जो एक पूर्ण कार्यक्रम को एक फ़ंक्शन / लैम्ब्डा की तुलना में कम कर देता है जहां हमें उपयोग करना होगा ' '.joinया कुछ इसी तरह का होगा।

— DJMcMayhem
स्रोत
लगता है कि पायथन 2 लिखकर 2 बाइट बचाता है for w in input().split():print w[:-2]+w[:-3:-1],। पायथन 3 में, अंतिम दो पात्रों को निकालने से अच्छा काम होगा, print(*(''.join(a)+c+b for*a,b,c in input().split()))सिवाय इसके कि aउसे एक स्ट्रिंग में रीमेक करने की आवश्यकता हो।
— xnor
5

मैटलैब (R2016b), 51 50 बाइट्स

सहेजे गए 49 50 (!) @Giuseppe के लिए धन्यवाद बाइट्स।

function s(a),regexprep(a,'(\w)(\w)( |$)','$2$1 ')

और मेरा पिछला जवाब:

मैटलैब (R2016b), 100 बाइट्स

(बस इसके मज़े के लिए: पी)

function s(a),a=regexp(a,' ','split');for i=1:length(a),fprintf('%s ',a{i}([1:end-2 end end-1])),end

स्पष्टीकरण:

function s(a) % Defining as a function...
a=regexp(a,' ','split'); % Splits the input string at the spaces
for i=1:length(a) % Loops through each word
    fprintf('%s ',a{i}([1:end-2 end end-1])) % And prints everything with the last two characters swapped.
end
— थियागो ओलेनिक
स्रोत
1
एक वर्ण शब्द नहीं हो सकता है, क्योंकि एक शब्द को कम से कम दो वर्णों के रूप में परिभाषित किया गया है।
— ग्यूसेप 20
regexprepयहाँ काम करेगा ? कुछ पसंद है regexprep(a,'(\w*)(\w)(\w)','\1\3\2')?
— ग्यूसेप
द = यह। था। महाकाव्य! मुझे लगता है कि आपको यह उत्तर पोस्ट करना चाहिए, क्योंकि यह मेरी से बिल्कुल अलग है। केवल एक चीज यह है कि मतलाब मैचों का संदर्भ देता है $1, और \1ऐसा नहीं है regexprep(a,'(\w*)(\w)(\w)','$1$3$2')।
— थियागो ओलेनिक 20
1
आपको इसे एक अलग उत्तर के रूप में पोस्ट करना चाहिए / इस उत्तर में; यह देखना हमेशा अच्छा होता है कि क्या कोई रेगेक्स एक कड़ी चुनौती पर मदद करेगा या नहीं! इसके अलावा, मैं स्पष्ट रूप से MATLAB के रेगेक्स इंजन को नहीं समझता, इसलिए मेरे लिए इसका श्रेय लेना उचित नहीं होगा।
— ग्यूसेप
1
function s(a),regexprep(a,'(\w)(\w)( |$)','$2$1 ')अभी भी एक और बाइट कम है!
— ग्यूसेप
4

प्रोलोग (एसडब्ल्यूआई) , 60 बाइट्स

[A,B]+[B,A].
[A,B,32|U]+[B,A,32|Y]:-U+Y,!.
[A|U]+[A|Y]:-U+Y.

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

व्याख्या

पहले हम आधार मामले को परिभाषित करते हैं:

p([A,B],[B,A]).

इसका अर्थ है कि अंतिम दो अक्षर हमेशा स्वैप किए जाएंगे।

तब हम परिभाषित करते हैं कि क्या होता है अगर हम किसी स्थान के ठीक बगल में हैं:

p([A,B,32|U],[B,A,32|Y]):-p(U,Y),!.

यदि अंतरिक्ष से पहले अक्षरों को अदला-बदली से पहले दो तार मेल खाते हैं और यदि तार मेल खाते हैं तो शेष। हम तो !कटौती करने के लिए उपयोग करते हैं।

हमारा आखिरी मामला यह है कि अगर हम एक स्थान के बगल में नहीं हैं, तो पहले दो अक्षरों को मिलाने की जरूरत है।

p([A|U],[A|Y]):-p(U,Y).
— गेहूं का जादूगर
स्रोत
4

वोल्फ्राम भाषा , 117 बाइट्स

StringReplace[RegularExpression["\\b[[:alpha:]]{2,}\\b"]:>StringDrop[StringInsert["$0",StringTake["$0",{-1}],-3],-1]]

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

परीक्षण के तार के लिए आवेदन किया।

StringReplace[
  RegularExpression["\\b[[:alpha:]]{2,}\\b"] :> 
   StringDrop[StringInsert["$0", StringTake["$0", {-1}], -3], -1]] /@
 {"Thansk", "Youer welcoem", "This is an apple", 
  "Flippign Lettesr Aroudn", "tHe oDd chALlEneg wiht swappde lettesR"} // Column

Thanks
Youre welcome
Thsi si na appel
Flipping Letters Around
teH odD chALlEnge with swapped letteRs
— एडमंड
स्रोत
4
PPCG में आपका स्वागत है!
— स्टेडीबॉक्स
@Steadybox धन्यवाद।
— एडमंड
4

आर , 111 51 41 बाइट्स

@Giuseppe के सौजन्य से, एक रेगीक्स दृष्टिकोण जो मेरे पुराने तरीके को पानी से बाहर निकालता है।

cat(gsub("(.)(.)\\b",'\\2\\1',scan(,"")))
— rturnbull
स्रोत
1
रेगेक्स यहां बहुत अधिक कुशल हैं: इसे ऑनलाइन आज़माएं!
— ग्यूसेप
(ऐसा नहीं है कि मैं हिम्मत नहीं करता कि यह आर में शुद्ध स्ट्रिंग हेरफेर करने के लिए लेता है)
— Giuseppe
— Giuseppe
@Giuseppe वाह, अच्छा काम! मैंने उन्हें अपने उत्तर में संपादित कर लिया है, हालाँकि यदि आप अपना स्वयं का उत्तर देना चाहते हैं तो कृपया आगे बढ़ें!
— rturnbull
1
नहीं, इसके बारे में चिंता मत करो। मैंने एक और 10 बाइट्स को नीचे गिराया : एक और रेगेक्स अप्रोच, और अपने पुराने दृष्टिकोण का 70 बाइट
— Giuseppe
4

APL (Dyalog Classic) , 28 बाइट्स

1↓∊((¯2↓⊢),2↑⌽)¨' '(,⊂⍨⊣=,)⍞

⎕ML तथा ⎕IO दोनों हैं 1,

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

व्याख्या

  • ... (,⊂⍨⊣=,) ... स्प्लिट (सीमाओं को बनाए रखते हुए, और शुरुआत में सीमा को जोड़ते हुए) ...
  • ... ⍞ ... इनपुट ...
  • ... ' ' ... ... रिक्त स्थान पर।
  • ... ( ... )¨ ... फिर, उस के प्रत्येक तत्व के लिए:
    • ... , ... कॉनकैटनेट ...
    • ... (¯2↓⊢) ... ... पिछले दो को छोड़कर हर आइटम ...
    • ... 2↑⌽ ... ... पिछले दो तत्वों के रिवर्स के साथ।
  • 1↓∊ ... अंत में, सभी परिणाम के पहले तत्व को वापस करें।
— जाकारी
स्रोत
सभी लेकिन लौट पहले
— एडम
3

जे , 20 19 11 बाइट्स

इसका श्रेय @Bolce Bussiere को है

1&A.&.>&.;:

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

       &.;:      on words
    &.>          on each
  A.             apply the permutation
1&               number 1, swap the last two elements
— FrownyFrog
स्रोत
1
13 बाइट्स(1&A.&.>)&.;:
— बोल्से बूसियर
@BolceBussiere सही
— FrownyFrog
क्या आप एक स्पष्टीकरण जोड़ सकते हैं? आश्चर्य है कि अगर मैं अपने समाधान की शर्मनाक बाइट गिनती को कम करने के लिए इसे कश्मीर में पोर्ट कर सकता हूं!
— स्ट्रीटस्टर
3

एलिस , 24 बाइट्स

/0RR'.%$1\' o
\ix*o ne@/

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

व्याख्या

/...\' o
\.../

यह एक लूप बनाता है जहां लूप बॉडी एक रैखिक साधारण स्निपेट है और हम निष्पादित करते हैं ' o हर दो लूप पुनरावृत्तियों के बीच कार्डिनल मोड में । उत्तरार्द्ध केवल एक स्थान प्रिंट करता है।

ऑर्डिनल कोड की ज़िगज़ैग संरचना को अनफ़िल्टर्ड करते हुए, रैखिक लूप बॉडी वास्तव में इस तरह दिखती है:

iR*' %e10xRo.n$@

इसे तोड़ना:

i     Read all input. On subsequent iterations, this will push an empty string.
R     Reverse.
*     Join. On the first iteration, this joins the input to an implicit empty string,
      which does nothing. On subsequent iterations, it will join the empty string to
      the word on top of the string, thereby getting rid of the empty string.
' %   Split around spaces. On the first iteration, this will split the input
      into individual words. On subsequent iterations, this does nothing.
e10   Push "10".
x     Use this to permute the (reversed) word on top of the stack. In
      particular, the word is rearranged with the same permutation that is
      required to sort the string "10", which means the first two letters
      get swapped (which correspond to the last two letters of the actual
      word).
R     Reverse the swapped word.
o     Print it.
.n$@  If there are no words left on the stack, terminate the program.
— मार्टिन एंडर
स्रोत
बस ध्यान दिया जाता है कि अक्षर स्वैप h~Zचार के बजाय तीन बाइट्स ( ) में किया जा सकता है e10x, लेकिन मैं लेआउट को समायोजित करने का एक तरीका नहीं देख रहा हूं कि वास्तव में उस के साथ एक बाइट को बचाएं।
— मार्टिन एंडर
2

ब्रेनफक , 109 100 बाइट्स

संपादित करें: एक अक्षर शब्दों को संभालना नहीं है

,[>++++[-<-------->],]>+[-<[>++++[<++++++++>-]<[->>+<<]<]<<[->>+<<]>[[-<+>]>]<<[>+>+>]-<]>>>>>>>[.>]

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

एक अनुगामी स्थान प्रिंट करता है

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

,[>++++[-<-------->],] Puts input on the tape and subtracts 32 from each character
                       This separates each word

>+[- Start the loop
   <[>++++[<++++++++>-]<[->>+<<]<] Add 32 to each letter of the word
                                   Skip this on the first iteration for the last word

   <<[->>+<<]>[[-<+>]>] Swaps the last two letters of the word
   <<[>+>+>]- If there is another word to the left continue loop
              Also set up to add a space to the end of the word
 <] End loop
 >>>>>>>[.>] Print the modified string

पिछला संस्करण, 109 बाइट्स

,[>++++[-<-------->],]>+[-<[>++++[<++++++++>-]<[->>+<<]<]<<[[->>+<<]>[[-<+>]>]<<[<]]>[>]<[>+>+>]-<]>>>>>>[.>]

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

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

PHP , 119 107 बाइट्स

संपादित करें: पूरी तरह से अमानवीय के लिए धन्यवाद 

<?php foreach(explode(" ",trim(fgets(STDIN)))as$w)echo substr($w,0,strlen($w)-2).strrev(substr($w,-2))," ";

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

— Zerquix18
स्रोत
1
क्या आप $wordएक एकल वर्ण चर नाम नहीं बना सकते ?
— अशुभ
@totallyhuman यप! मैंने पूर्ण संस्करण लिखा और फिर उसे संकुचित कर दिया, लेकिन उस पर ध्यान नहीं दिया। धन्यवाद।
— Zerquix18
PHP ओपन टैग आपको 6 बाइट्स की बचत के जवाब में छोड़ा जा सकता है।
— डैनियल डब्लू।
मुझे आश्चर्य है कि अगर fgets(STDIN)छोड़ा जा सकता है या इसके द्वारा प्रतिस्थापित किया जा सकता है $x, जैसे कि सभी उत्तर उनके उत्तरों के लिए इनपुट की गणना नहीं करते हैं
— डैनियल डब्लू।
trim()अनावश्यक होना चाहिए।
— टाइटस
1

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

foldr(%)" "
a%(b:' ':r)=b:a:' ':r
a%s=a:s

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

एक अनुगामी स्थान के साथ आउटपुट।

बार-बार ' ':rबेकार लग रहा है। लेकिन a%(b:t@(' ':r))=b:a:tएक ही लंबाई है और a%(b:t)|' ':_<-t=b:a:tएक बाइट लंबी है।

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

f(a:b:t)|t<"A"=b:a:f t|1>0=a:f(b:t)
f e=e

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

— XNOR
स्रोत
1

sed , 20 17 + 1 (-r) = 18 बाइट्स

s/(.)(.)\b/\2\1/g

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

— Noskcaj
स्रोत
TIO लिंक आपके पोस्ट किए गए कोड से मेल नहीं खाता है। TIO लिंक कुछ बाइट्स लंबा है।
— Xcali
— व्हाट्स
आप निकाल सकते हैं |$। यह कुछ नहीं कर रहा है। (इसके लिए आपको वह करने की ज़रूरत है (.)(.)(\b|$)जिसकी आपको आवश्यकता होगी , लेकिन यह आवश्यक नहीं है क्योंकि \bपहले से ही स्ट्रिंग के अंत से मेल खाता है।)
— जॉर्डन
वूप्स, मतलब से छुटकारा पाने के लिए। धन्यवाद,
— नोसकज
1

PHP, 65 बाइट्स

PHP 7.1 (या बाद में) की आवश्यकता है

for(;$s=$argv[++$i];$s[-1]=$s[-2],$s[-2]=$c,print"$s ")$c=$s[-1];

अलग कमांड लाइन तर्क के रूप में वाक्य लेता है। साथ चलाना -nr।

एक ही तार पर काम करना, 77 + 1 बाइट्स :

foreach(explode(" ",$argn)as$s){$c=$s[-1];$s[-1]=$s[-2];$s[-2]=$c;echo"$s ";}

साथ पाइप के रूप में चलाएँ -nR।

... या उन्हें ऑनलाइन आज़माएं ।

— टाइटस
स्रोत
1

जावा 8, 35 बाइट्स

s->s.replaceAll("(.)(.)\\b","$2$1")

पोर्ट ऑफ @TaylorScott की Google शीट जवाब , के बाद मैं दो बाइट्स golfed। संपादित करें: मुझे लगता है कि यह अब मेरे दो गोल्फ बाइट्स के बाद नील के रेटिना उत्तर का एक बंदरगाह है ।

स्पष्टीकरण:

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

s->                           // Method with String as both parameter and return-type
   s.replaceAll("(.)(.)       //  Replace any two characters,
                       \\b",  //  with a word-boundary after it (space or end of String)
                "$2$1")       //  With the two characters swapped
— केविन क्रूज़सेन
स्रोत
1

Google शीट, 33 बाइट्स

बेनामी वर्कशीट फ़ंक्शन जो सेल से इनपुट लेता है A1और कॉलिंग सेल को आउटपुट देता है

=RegExReplace(A1,"(.)(.)\b","$2$1

-2 बाइट्स ओवर के इस्तेमाल के लिए @ केविनक्रूजसेन को धन्यवाद(.)(\w)

— टेलर स्कॉट
स्रोत
अगर मैं गलत नहीं हूँ तो दोनों (\w)को गोल्फ दिया जा सकता है (.)। \bपहले से ही केवल शब्दों के लिए देखो करने के लिए एक संकेत है। (हालांकि पूरी तरह से निश्चित नहीं है, लेकिन यह जावा में काम करता है।)
— केविन क्रूज़सेन
@ केविनक्रूजसेन - आप बिल्कुल सही हैं, यह हो सकता है। धन्यवाद!
— टेलर स्कॉट
1

जावास्क्रिप्ट (Node.js) , 38 36 32 बाइट्स

s => s.replace (/ (।) (?) (! $) / g, "$ 2 $ 1") 
s=>s.replace(/(.)(.)\b/g,"$2$1")

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

RegExp दृष्टिकोण शिष्टाचार @Giuseppe (हालांकि मैंने इसे स्वतंत्र रूप से सोचा था), केवल एक स्थान द्वारा अलग किए गए शब्दों को मानते हुए

-2 केवल 1 स्थान पर विचार करने और अनुगामी स्थान जोड़ने के लिए

-4 धन्यवाद @ शगुन

— शायरु असकोतो
स्रोत
कोई फर्क नहीं पड़ता कि क्या अधिक स्थान हैं, मुझे लगता है
— l4m2
@ l4m2 लेकिन यदि अधिक स्थान हैं तो यह 38 के लिए बन जाएगा s=>s.replace(/(.)(.)( +|$)/g,"$2$1$3")।
— शायरु असकोतो
@ l4m2 BTW मेरा मूल उत्तर थाs=>s.replace(/(.)(.)(\s|$)/g,"$2$1$3")
— शायरु असकोतो
ab abc abcd abcde abcdef क्या ab_, bc_, cd_, de_, ___, ef_,___
— l4m2
1
F=s=>s.replace(/(.)(.)(?!\w)/g,"$2$1")वही लंबाई
— l4m2
1

के (ओके) , 23 22 बाइट्स

" "/{x@prm[!#x]1}'" "\

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

उदाहरण:

" "/{x@prm[!#x]1}'" "\"Hello World"
"Helol Wordl"

स्पष्टीकरण:

1 बाइट को बचाने के लिए FrownyFrog के समाधान का पोर्ट ।

मैं इस पर वापस आता हूँ।

" "/{prm[x]1}'" "\ / the solution
              " "\ / split input on " "
    {       }'     / apply lambda to each
     prm[x]        / permute input x
           1       / and take the 2nd result
" "/               / join with " "

पिछला समाधान:

  • " "/-2{(x_y),|x#y}'" "\ 23 बाइट्स
— streetster
स्रोत
1

05AB1E , 7 बाइट्स

#vy`sðJ

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

-1 मैजिक ऑक्टोपस Urn को धन्यवाद ।

एक अनुगामी स्थान को प्रिंट करता है।

— आउटगोल्फर को एरिक करें
स्रोत
यह 11 बाइट्स हैं
— डैनियल डब्ल्यू।
2
@DanFromGermany नहीं, 05AB1E में एक कोड पेज है जिसमें इसे 8 बाइट्स के रूप में दर्शाया जा सकता है।
— एरिक आउटरीफायर
क्या आप 8 बाइट्स में प्रस्तुत कार्यक्रम चला सकते हैं?
— डैनियल डब्लू।
@DanFromGermany हाँ, 05AB1E दुभाषिया 05AB1E एन्कोडिंग में एक फ़ाइल से इस प्रोग्राम को चला सकता है।
— एरिक आउटफोलर
1
@MagicOctopusUrn यह एक सूची नहीं है, हालांकि, इसके बाद है `।
— एर्गेल आउटफर
0

SNOBOL4 (CSNOBOL4) , 136 119 बाइट्स

	I =INPUT
B	I SPAN(&LCASE &UCASE) . Y ARBNO(' ') =:F(O)
	Y RPOS(2) REM . Z =REVERSE(Z)
	O =O Y ' '	:(B)
O	OUTPUT =O
END

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

एक अनुगामी स्थान के साथ प्रिंट। आपको पता है कि आपने कुछ गलत किया है जब एक भाषा स्ट्राइन्ग ओरिएंटेड और सिंबल लैंग्वेज के लिए एक बैरोनियम है और आपका कोड ब्रेन-फ्लैक से अधिक लंबा है :( अब यह थोड़ा बेहतर है।

लाइन खाली स्ट्रिंग के साथ Bलेता है Iऔर बदल देता है (alphabetic characters saved as Y)(some number of spaces)।

निम्न पंक्ति के अंतिम 2 वर्ण निकालता है Yके रूप मेंZ करने और बदलने वाला उन्हें Zउलट है, तो अगली पंक्ति संयोजित करता O, Yऔर इसमें एक अंतरिक्ष चरित्र।

अंत में, यह प्रिंट करता है जब Iलाइन में आवश्यक पैटर्न से मेल नहीं खाता है B।

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