एक आउल-एडोकफ चुनौती

Question

इनपुट

रेंज में ASCII वर्णों से मिलकर एक गैर-खाली फेरबदल स्ट्रिंग ।$[32..126]$

उत्पादन

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

[a-zA-Z]इनपुट स्ट्रिंग में प्रत्येक अक्षर के लिए ( बाएं से दाएं):

• यदि पत्र ऊपरी स्थिति में है, तो बाईं ओर एक स्थिति से पहले सभी वर्णों को घुमाएं
• यदि पत्र निचले मामले में है, तो इससे पहले कि एक स्थिति से दाईं ओर सभी वर्णों को घुमाएं

उदाहरण

इनपुट: "Cb-Ad"

• पहला अक्षर " C " है। हमें बाईं ओर एक रोटेशन करना चाहिए, लेकिन इस " सी " से पहले कोई चरित्र नहीं है । इसलिए, घूमने के लिए कुछ भी नहीं है।
• अगला अक्षर " बी " है। हम " सी " को दाईं ओर घुमाते हैं । क्योंकि यह एक एकल पात्र है, इसे अपरिवर्तित छोड़ दिया जाता है।
• वर्ण " - " किसी भी रोटेशन को ट्रिगर नहीं करता है, क्योंकि यह एक पत्र नहीं है।
• अगला अक्षर " ए " है। हम " Cb- " को बाईं ओर घुमाते हैं , जो " bC Ad" देता है
• चौथा और अंतिम अक्षर एक " डी " है। हम " b-CA " को दाईं ओर घुमाते हैं , जो " Ab-C d" देता है

इसलिए, अपेक्षित आउटपुट " Ab-Cd " है।

नियम

• आप इनपुट को एक स्ट्रिंग के रूप में या वर्णों के एक सरणी के रूप में ले सकते हैं - जो आपकी भाषा के आधार पर एक ही चीज़ हो सकती है या नहीं भी हो सकती है।
• आप स्ट्रिंग के बजाय वर्णों की एक सरणी भी आउटपुट कर सकते हैं।
• यह ogl-edocf कोड-गोल्फ है

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

"cbad" -> "abcd"
"ACBD" -> "ABCD"
"Cb-Ad" -> "Ab-Cd"
"caeBDF" -> "aBcDeF"
"aEcbDF" -> "abcDEF"
"ogl-edocf" -> "code-golf"
"W o,ollelrHd!" -> "Hello, World!"
"ti HIs SSta ET!" -> "tHis IS a tEST!"

Answer 1

पायथ, 21 20 बाइट्स

VQ=k+.>k-}NG}Nr1GN)k

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

व्याख्या

VQ=k+.>k-}NG}Nr1GN)k
VQ                )      For each N in the input...
     .>k                 ... rotate k (initially '')...
        -}NG}Nr1G        ... by (N is lowercase) - (N is uppercase)...
    +            N       ... then append N...
  =k                     ... and update k.
                   k     Output the result.

Comments

आप .U2 मान से इनपुट को कम करने के लिए उपयोग कर सकते हैं । यह आपको =kशुरू से ही छोड़ देता है , और )kअंत से इनपुट और प्रिंटिंग दोनों निहित हैं। पूरा कार्यक्रम: .U+.>b-}ZG}Zr1GZ- लिंक

— सोक

Answer 2

पायथन 2 , 100 98 95 बाइट्स

f=lambda s,p='':s and f(s[1:],[p[x:]+p[:x]+s[0]for x in[s[0].isupper()-s[0].islower()]][0])or p

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

Answer 3

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

ØẠŒHċ€ḅ-N⁸ṙ;ð/

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

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।

कैसे?

ØẠŒHċ€ḅ-N⁸ṙ;ð/ - Link - list of characters
             / - reduce by:
            ð  -   a dyadic chain:  1st call is f(L=1stCharacter, R=2ndCharacter)
               -                    ...then calls are f(L=previousResult, R=nextCharacter)
ØẠ             -     alphabet characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
  ŒH           -     split in half = ["ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz"]
     €         -     for each:
    ċ          -       count occurrences (of R)
               -                          e.g.: 'W' -> [1,0]; 'c' -> [0,1]; '@' -> [0,0]
      ḅ-       -     convert from base -1             -1             1             0
        N      -     negate                            1            -1             0
         ⁸     -     chain's left argument (i.e. L)
          ṙ    -     rotate left by (the negate result)
           ;   -     concatenate R

Comments

मैं जेली को अच्छी तरह से नहीं जानता, लेकिन इस मामले में भी Iऐसा नहीं करना चाहिए ḅ-? यह यहां काम करने लगता है , लेकिन आपके कोड में नहीं। मैं थोड़ा उलझन में हूँ क्यों। इसके अलावा, क्या पूरी सूची को जेली में स्टैक के लिए अलग किए गए आइटम के रूप में धकेलने का आदेश है (प्रतीक्षा करें, जेली एक स्टैक-आधारित भाषा नहीं है, क्या यह है ..)? उस स्थिति में एक साधारण घटाव का उपयोग किया जा सकता है और अगर मैं गलत नहीं हूँ, तो आपको भी नकारात्मक की आवश्यकता नहीं होगी (मेरे 05AB1E उत्तर में अंतिम संपादन के समान)।

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

Iएक सूची देता है - ŒṘ एक पूर्ण प्रतिनिधित्व देखने के लिए जोड़ें । तो ØẠŒHċ€IṪN⁸ṙ;ð/काम करेगा।

— जोनाथन एलन

आह ठीक है, यह समझ में आता है। स्पष्टीकरण के लिए धन्यवाद। अच्छा जवाब btw, पहले से ही कल इसे upvoted। :)

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

Answer 4

05AB1E , 18 17 16 14 बाइट्स

õsvy.uy.l-._y«

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

स्पष्टीकरण:

õ            # Start with an empty string
 sv          # Loop over the characters `y` of the input
   y.u       #  Check if `y` is an uppercase letter (1 if truthy; 0 if falsey)
   y.l       #  Check if `y` is a lowercase letter (1 if truthy; 0 if falsey)
      -      #  Subtract them from each other
       ._    #  Rotate the string that many times (-1, 0, or 1) toward the left
   y«        #  Append the current character `y` to the string
             # (And implicitly output the string after the loop)

Answer 5

K4 , 43 33 बाइट्स

समाधान:

""{.q.rotate[-/y in'.Q`A`a;x],y}/

उदाहरण:

q)k)""{.q.rotate[-/y in'.Q`A`a;x],y}/"Cb-Ad"
"Ab-Cd"
q)k)""{.q.rotate[-/y in'.Q`A`a;x],y}/"ogl-edocf"
"code-golf"
q)k)""{.q.rotate[-/y in'.Q`A`a;x],y}/"ti HIs SSta ET!"
"tHis IS a tEST!"

स्पष्टीकरण:

इनपुट स्ट्रिंग पर Iterate, पिछले आउटपुट को 1, -1 या 0 से घुमाते हुए यह सूची "A-zA-Z" पर निर्भर करता है।

""{.q.rotate[-/y in'.Q`A`a;x],y}/ / the solution
""{                            }/ / iterate (/) over, starting x as ""
                             ,y   / append y to
   .q.rotate[             ;x]     / rotate x by ...
                    .Q`A`a        / the lists "a..z" and "A..Z"
               y in'              / y in each (') alphabet?
             -/                   / subtract (-) over (/)

टिप्पणियाँ:

• 05AB1E समाधान से प्रेरणा के साथ -10 बाइट्स

Answer 6

> <> , 45 43 बाइट्स

ii:2+7$.::&"`{"@)@(*?}"@["&::&@)@(*?{&!
ror

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

तथ्य यह है कि> <> स्टैक रोटेशन में मदद करता है, लेकिन पत्र के मामले की जांच करने के लिए नहीं है।

स्पष्टीकरण:

i    Get first inputted character
 i   Get second. This is to prevent errors from rotating an empty stack
  :2+7$.      Jump to the second line if that was EOF
        ::&   Create copies of the input and store one in the register
           "`{"@)@(*     Check if the char is lower case
                    ?}   If so rotate the stack
                      "@["&::&@)@(*?{   Rotate the other way if uppercase
                                     &  Push the new char
                                      ! Skip the first i instruction
Skip to the second line on EOF
ro      Reverse the stack and output
r r     Cancel out the first reverse
 o      Output the rest of the stack

Answer 7

हास्केल , 101 91 बाइट्स

^{-10 बाइट्स कर्टिस बेचटेल के जवाब से प्रेरित ( लो-केस अक्षर के लिए '@'<c,c<'['ओवर elem c['A'..'Z']रेंज और तदनुसार) का उपयोग करें।}

g(x:y)=foldl((<>pure).(!))[x]y
x@(a:b)!c|'`'<c,c<'{'=last x:init x|'@'<c,c<'['=b++[a]|0<1=x

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

स्पष्टीकरण / अनलॉक्ड

ऑपरेटर (!)एक गैर-खाली स्ट्रिंग लेता है, xजिस पर हम एक पैटर्न और एक चरित्र का मिलान कर सकते हैं:

x@(a:b) ! c
  | '`' < c, c < '{' = last x : init x  -- rotate x to the right by one
  | '@' < c, c < '[' = b ++ [a]         -- rotate x to the left by one
  | otherwise = x                       -- keep x as is

अब हम इनपुट के पहले वर्ण से शुरू करते हुए, इनपुट की पूंछ को बाईं ओर से दाईं ओर कम कर सकते हैं:

\b a -> b!a ++ [a]

Answer 8

हास्केल , 122 92 बाइट्स

सुझावों के लिए BWO को धन्यवाद! मैंने अपने मूल उत्तर की तुलना में थोड़ा अलग दृष्टिकोण अपनाकर बहुत बचत की।

l@(a:b)!c|'`'<c,c<'{'=last l:init l++[c]|'@'<c,c<'['=b++[a,c]|0<1=l++[c]
f(c:s)=foldl(!)[c]s

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

Comments

आप इसके बजाय पैटर्न-मैच स्वैप कर सकते हैं (#), ,ओवर का &&उपयोग [l!!0,c]कर सकते हैं head l:[c], 1>0इसके बजाय True, आपको गिनने की ज़रूरत नहीं है f=और आप गैर-रिक्त इनपुट को मान सकते हैं जो l==[]गार्ड को बचाता है - आपको 13 बाइट्स बचाता है : इसे ऑनलाइन आज़माएं!

— ბიმო

Btw। मैं प्रयोग किया जाता है isLowerऔर isUpperमें गोल्फ जमा करते , मुझे आशा है कि के साथ है कि अन्यथा मैं अपने संपादित रिवर्स करेंगे आप ठीक कर रहे हैं।

— ბიმო

@BWO सुझावों के लिए धन्यवाद, और आगे बढ़ो!

— कर्टिस बेचटेल

Answer 9

जावास्क्रिप्ट (Node.js) , 116 102 बाइट्स

f=(s,i=1)=>s[i]?f(s.replace(RegExp(`^(.)(.{${i}})(?=[A-Z])|^(.{${i}})(.)(?=[a-z])`),"$4$3$2$1"),i+1):s

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

मूल ( 116 111 106 बी)

s=>Buffer(s).map((x,i)=>s=(t=s[S="slice"](i),i<2)?s:x>64&x<91?s[S](1,i)+s[0]+t:x>96&x<123?s[i-1]+s[S](0,i-1)+t:s)&&s

s=>Buffer(s).map((x,i)=>i<2|--x%32>25|x<64?s:s=[s[S="slice"](1,i)+s[0],s[i-1]+s[S](0,i-1)][+(x>95)]+s[S](i))&&s

s=>Buffer(s).map((x,i)=>!i|--x%32>25|x<64?s:s=(w=x>95,t=s.slice(1-w,i-w),w?s[i-1]+t:t+s[0])+s.slice(i))&&s

Comments

यह शायद eval(`regex`)

— निर्माणकर्ता

@Downgoat मुझे डर है कि ऐसा न हो क्योंकि स्लैश की जरूरत होती है eval(`regex`), इसलिए -2 + 2 = 0 और इस प्रकार यह बाइट काउंट को कम करने में मदद नहीं करता है।

— शायरु असकोतो

@Downgoat eval()कम से कम एक ध्वज का उपयोग करने पर यह प्रयोग करने योग्य है: eval('/./g')3 बाइट्स से छोटा है RegExp('.','g')।

— अरनुलद

@ अर्नुलद यह सच है, लेकिन मैं यहां झंडे का इस्तेमाल नहीं करता।

— शायरु असकोतो

@ शायरूआसाकोतो (ज़रूर। मेरी टिप्पणी को मुख्य रूप से डाउगोएट को यह बताने के लिए संबोधित किया गया था कि यह यहाँ करने लायक क्यों नहीं है।)

— अरनौल्ड

Answer 10

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

->s{w=[];s.map{|x|w.rotate!(x=~/\W/||?_<=>x)<<x};w}

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

इनपुट और आउटपुट वर्णों के सरणियाँ हैं

चाल:

कोड बहुत सीधा है, शायद रोटेशन वाले हिस्से को छोड़कर:

(x=~/\W/||?_<=>x)

x एक एकल वर्ण है, जो एक अक्षर हो सकता है, यदि यह एक अक्षर है, तो पहली अभिव्यक्ति x=~/\W/वापस आती nilहै, और 0 अन्यथा। यदि यह 0 है, तो हम कर रहे हैं, यदि नहीं, तो तार्किक orदूसरी अभिव्यक्ति की जांच करता है: ?_<=>xऊपरी मामले के लिए रिटर्न -1 और निचले मामले के लिए 1। तो रोटेशन है:

• ऊपरी मामले के लिए -1 (बाईं ओर)
• निचले मामले के लिए +1 (दाईं ओर)
• 0 (कोई रोटेशन नहीं) यदि यह एक पत्र नहीं है

Answer 11

लाल , 110 बाइट्स

func[s][p: s forall s[if all[(a: first s)>#"@"a < #"["][move p back s]if all[a >#"`"a <#"{"][move back s p]]p]

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

स्पष्टीकरण:

f: func [ s ] [
    p: s                                ; store the starting position of the string in p
    forall s [                          ; iterate through the entire string
        a: first s                      ; store the current character in a
        if all [ a > #"@" a < #"[" ] [  ; if `a` is a uppercase letter
            move p back s               ; move the starting char to the position before current
        ]
        if all [ a > #"`" a < #"{" ] [  ; if `a` is a lowercase letter
            move back s p               ; move the character before the current one to the start
        ]
    ]
    p                                   ; return the string 
]

Answer 12

पर्ल 6 , 47 बाइट्स

*.reduce:{|@$^a.rotate($^b~~/\w/&&'_'leg$b),$b}

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

वर्णों की एक सरणी पर काम करता है।

Comments

आह, मैं cmp और uc / lc का उपयोग करने के लिए गया था, लेकिन वह 49 बाइट्स में

— Jo King

डार, 48 बाइट्स लगभग पकड़े गए

— जो किंग

Answer 13

जाप, 17 16 14 बाइट्स

एक वर्ण के रूप में इनपुट लेता है, एक स्ट्रिंग आउटपुट करता है

;rÏiXéCøY -BøY

कोशिश करो

---

व्याख्या

 rÏ                :Reduce by passing the current result (X) & the current element (Y) through a function
   i               :  Prepend to Y
    Xé             :  X rotated right by
;     B            :    Uppercase alphabet
       øY          :    Contains Y?
          -        :    Subtract
;          C       :    Lowercase alphabet
            øY     :    Contains Y?

Answer 14

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

W€ḷṙ01ŒlƑ?-ŒuƑ?};ʋ/

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

Answer 15

जावा 10, 149 119 बाइट्स

s->{for(int i=1;i<s.length();)s=s.replaceAll("^(.)(.{"+i+"})(?=[A-Z])|^(.{"+i+++"})(.)(?=[a-z])","$4$3$2$1");return s;}

@ShieruAsakoto जावास्क्रिप्ट उत्तर पोर्ट , इसलिए उसे सुनिश्चित करने के लिए सुनिश्चित करें।

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

स्पष्टीकरण:

s->{                          // Method with String as both parameter and return-type
  for(int i=1;i<s.length();)  //  Loop `i` in the range [1, length)
    s=s.replaceAll("^(.)(.{"+i+"})(?=[A-Z])|^(.{"+i+++"})(.)(?=[a-z])","$4$3$2$1");
                              //   Rotate the substring of [0, i] either left or right
  return s;}                  //  Return the modified input-String as result

Answer 16

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

éG7[Æ┐äZ▬Θε♫∙~╞ÉH╔u╬←J╛ü╢(┼▒uX)Ü

इसे चलाएं और डीबग करें

B]s{c97 123:bsaa|)sc65 91:bsaa|(s+c}fd  #Full program, unpacked, implicit input
B]s                                     #Unons-left, singleton, swap top 2 of stack
   {c                                   #Copy iterative letter
     97 123                             #Put 97 and 123 on stack(lower case)
           :bsaa                        #Check if iterative letter is between range, swap orientation back to proper order
                |)                      #Rotate if the letter is within range
                  sc                    #Swap top 2 and copy top
                    65 91               #Put 65 and 91 on stack (Capitals)
                         :bsaa          #Check if iterative letter is between range, swap orientation back to proper order
                              |(        #Rotate if the letter is within range
                                s+c     #swap, concat and copy
                                   }fd  #remove duplicate of original answer after loop and implicitly print

ढेर सारी ढेर सारी अदला-बदली जो शायद अनावश्यक है। मैं वास्तव में इसे और नीचे लाना चाहूंगा, लेकिन मैं स्टैक के आदेश के साथ संघर्ष कर रहा था। हो सकता है कि अगर कोई बोर हो जाए तो कोई इसका पता लगा सकता है। उस पर काम करते रहेंगे।

Answer 17

अटैची , 69 बाइट्स

~Fold[{s'r.=_'sp;Rotate[s,&`-!Has&r[0]=>ALPHA'alpha]+r}@SplitAt]#Iota

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

व्याख्या

सामान्य आकार

फ़ंक्शन आम तौर पर इस तरह दिखता है:

~Fold[{...}]#Iota

जो कि बीज के रूप में इनपुट से शुरू होकर ( ) {...}से 0लेकर #input - 1( Iota) तक प्रत्येक सदस्य के ऊपर तह करता है।

आंतरिक कार्य

निम्नलिखित समारोह के रूप में कहा जाता है f[building, index]और से प्रत्येक सूचकांक के साथ कहा जाता है 0के लिए #inputविशेष। इन तर्कों पर @SplitAtकॉल SplitAt, इनपुट स्ट्रिंग को विभाजित करना index।

{s'r.=_'sp;Rotate[s,&`-!Has&r[0]=>ALPHA'alpha]+r}
{                                               }    anonymous function taking the split string
                                                     e.g.: ["cd-", "Adf!"]
      _'sp                                           concat the input with a space
                                                     e.g.: ["cd-", "Adf!", " "]
                                                     (this is to handle index = 0)
 s'r.=                                               `s` is the first member, and `r` is the second
           Rotate[s,                         ]       rotate `s` by:
                                  ALPHA'alpha          over uppercase and lowercase alphabets:
                        Has&r[0]=>                       test if r[0] is in each alphabet
                                                       e.g.: [true, false]
                    &`-!                               subtract the second from the first
                                                       e.g.: (true - false) = 1 - 0 = 1
                                                     s is rotated according to the following map:
                                                       uppercase =>  1
                                                       symbol    =>  0
                                                       lowercase => -1
                                              +r     append the right portion of the string

अनिवार्य रूप से, यह फ़ंक्शन दाएं भाग के पहले चरित्र के अनुसार स्ट्रिंग के बाएं हिस्से को घुमाता है।

Answer 18

चारकोल , 20 बाइट्स

ＦＳ≔⁺⭆ω§ω⁻⁺λ№αι№βιιωω

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

ＦＳ

इनपुट वर्णों पर लूप करें।

≔⁺⭆ω§ω⁻⁺λ№αι№βιιω

अब तक एकत्र किए गए वर्णों के स्ट्रिंग पर मानचित्र, वर्तमान वर्ण और ऊपरी या निचले मामले में क्रमशः अनुक्रमित होने या घटाए जाने के साथ अब तक एकत्रित वर्णों में चक्रीय रूप से अनुक्रमण किया जाता है। इससे चक्कर पूरा होता है। अगले वर्ण को तब संघटित किया जाता है, और परिणाम वापस स्ट्रिंग को सौंपा जाता है।

ω

परिणाम प्रिंट करें।

Answer 19

आर , 107 102 100 बाइट्स

बड़े पैमाने पर क्योंकि आर की स्ट्रिंग हेरफेर भारी है। क्या कोई इसे 100 के नीचे ला सकता है?

-5 बाइट्स "सेट लूप वेरिएबल्स टू एफ से शुरू होने से बचने के लिए" ट्रिक।

-2 बाइट्स यह मानकर कि सभी वर्ण प्रिंट करने योग्य हैं और निचले मामले के परीक्षण के 2*!k%%97>25बजाय 2*k%in%97:122, ऑपरेटर की पूर्वता का उपयोग कर रहे हैं।

function(x){for(k in u<-utf8ToInt(x))u[1:F-1]=u[(1:(F=F+1)+k%in%65:90-2*!k%%97>25)%%F];intToUtf8(u)}

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

Comments

आओ हमारे साथ (यह अभी मुझे सही है ...) आर गोल्फ चैटरूम में चारों ओर कुछ विचारों को उछालने के लिए! मेरा अनुमान है कि क्रमपरिवर्तन टुकड़ा इस दृष्टिकोण के साथ कम हो सकता है, लेकिन इसे स्वयं करने की कोशिश नहीं कर रहा है, मैं निश्चित रूप से नहीं कह सकता।

— ग्यूसेप

Answer 20

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

मैं हारता हूं, इसे छोटा नहीं कर सकता

-2 बाइट्स अपहरण से

£=¯Y éXè\a -Xè\A)+UsYÃU

---

£=¯Y éXè\a -Xè\A)+UsYÃU     Full program. Implicit input U
£                           map each char
 =                          set U equal to:
  ¯Y                        U sliced to current mapped value
    éXè\a -Xè\A)            and rotated left or right 1 char
                +UsY        append the non-sliced U value
                      ÃU    Output U    

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

Comments

अफसोस की बात है, मैं ऐसा करने के लिए एक छोटा रास्ता नहीं खोज éXè\a -Xè\Aसकता :-( आप दो बाइट्स को डबल स्पेस को बदलकर एक में सहेज सकते हैं ), और हटाने ©(अंतर्निहित अल्पविराम का मतलब है कि Uअभी भी

— आउटपुट है

झंडे को गिराकर ÃUऔर इस्तेमाल करके एक और 2 बाइट बचाएं -h।

— झबरा

Answer 21

रेटिना , 67 64 58 बाइट्स

^
¶
+`(.*)(.)¶([a-z])|(.)(.*)¶([A-Z])|¶(.)
$2$1$3$5$4$6$7¶

-9 बाइट्स @ नोइल को हटाने के लिए धन्यवाद जो ?मैंने जोड़ा था, साथ ही साथ (.*)अन्य मामले में अनावश्यक भी।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें । (नोट: एक अनुगामी न्यूलाइन के साथ आउटपुट। टेस्ट सूट में हेडर प्रत्येक इनपुट-लाइन को एक अलग टेस्ट केस के रूप में परीक्षण करने के लिए है, और पाद एक अधिक कॉम्पैक्ट आउटपुट के लिए उस अनुगामी न्यूलाइन को निकालने के लिए है।)

स्पष्टीकरण:

इनपुट से पहले एक नई रूपरेखा तैयार करें:

^
¶

जब तक हम एक मैच पा सकते हैं, तब तक बदलते रहें:

+`

बाकी सब तीन अलग-अलग चेक एक साथ मर्ज किए गए हैं:

यदि न्यूलाइन के बाद वर्ण कम है तो अक्षर छोटा है: दाईं ओर एक बार न्यूलाइन से पहले सब कुछ घुमाएं, और फिर उस चरित्र और न्यूलाइन को संलग्न करें:

(.*)(.)¶([a-z])
$2$1$3¶

यदि न्यूलाइन के बाद वर्ण सही है तो अपरकेस अक्षर: बाईं ओर एक बार न्यूलाइन से पहले सब कुछ घुमाएं, और फिर उस चरित्र और न्यूलाइन को जोड़ें:

(.)(.*)¶([A-Z])
$2$1$3¶

एल्स (न तो एक लोअरकेस और न ही अपरकेस अक्षर): बस अगली 'पुनरावृत्ति' के लिए दाईं ओर एक बार नईलाइन को शिफ्ट करें:

¶(.)
$1¶

ऊपर दिए गए ये तीन चेक रेगेक्स या स्टेटमेंट ( |) और बड़े ग्रुप-रिप्लेसमेंट के साथ मर्ज किए गए हैं ताकि इसे एक्ट की तरह बनाया जा सके if(lowercase) ... elseif(uppercase) ... else ...:

Comments

मुझे नहीं लगता कि आपको एस की जरूरत है ?- अगर अभी तक घूमने के लिए कुछ भी नहीं है, तो कोई फर्क नहीं पड़ता कि कोई पत्र है या नहीं।

— नील

इसके अलावा, की जगह (.*)¶(.)के साथ $1$2¶की जगह को सरल किया जा सकता ¶(.)साथ $1¶ही अन्य कब्जा परिणाम को प्रभावित नहीं करता।

— नील

@ नील अहिल, धन्यवाद। -9 बाइट्स वहीं! :)

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

Answer 22

MATL , 20 बाइट्स

ttYo-ZS"X@q:&)w@YSwh

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

-4 लुइस मेन्डो के लिए धन्यवाद बाइट्स।

अपरकेस / लोअरकेस / गैर-पत्र को [-1,0,1] में परिवर्तित करता है (कार्यक्रम का पहला भाग)। परिक्रमा लगातार (दूसरी छमाही) लागू होती है। अगर मेरे पास अपरकेस / लोअरकेस से [-1,0,1] (दूसरा संस्करण देखें) तक पहुंचने का एक बेहतर तरीका है, और शायद दो को निकालने के लिए स्ट्रिंग को उल्टा करने का एक तरीका है, तो मैं अपने दिमाग को मिटा रहा हूं wके लिए आवश्यक है &)।

Answer 23

सी (क्लैंग) , 168 159 153 119 बाइट्स

g,i,j;f(char*a){for(i=0;a[j=i++];islower(a[i])?g=a[j],bcopy(a,a+1,j),*a=g:isupper(a[i])?g=*a,bcopy(a+1,a,j),a[j]=g:0);}

-26 धन्यवाद @ceilingcat को

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

Comments

सुझाएँ g=a[j=i++];islower(a[i])?bcopy(a,a+1,j)बजायa[j=i++];islower(a[i])?g=a[j],bcopy(a,a+1,j)

— ceilingcat

Answer 24

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

em=+.>k-F}RGrBd2

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

स्पष्टीकरण:

em=+.>k-F}RGrBd2dQ    Autofill variables
 m               Q    for each d in Q (the input):
            rBd2       Take [d, swapcase(d)]
         }RG           Figure out which are in the lowercase alphabet (returns [1,0] for lowercase, [0,1] for uppercase, [0,0] for non-letters)
       -F              Fold on subtraction (1 for lowercase, -1 for uppercase, 0 for non-letter)
    .>k                Cycle the processed part (k) of the input right by ^ steps
   +            d      Add in the new character at the end
  =   k                Store new process step back into k (k starts as an empty string)
e                     Get the (e)nd step's output.