An ogl-edocf challenge

Question

Input

A non-empty shuffled string consisting of ASCII characters in the range \$[32..126]\$.

Output

The output is obtained by applying successive rotations to the input string.

For each letter ([a-zA-Z]) in the input string, going from left to right:

• if the letter is in upper case, rotate all characters before it by one position to the left
• if the letter is in lower case, rotate all characters before it by one position to the right

Example

Input: "Cb-Ad"

• The first letter is a "C". We should do a rotation to the left, but there's no character before this "C". So, there's nothing to rotate.
• The next letter is a "b". We rotate "C" to the right. Because it's a single character, it is left unchanged.
• The character "-" does not trigger any rotation, as it's not a letter.
• The next letter is a "A". We rotate "Cb-" to the left, which gives "b-CAd"
• The fourth and last letter is a "d". We rotate "b-CA" to the right, which gives "Ab-Cd"

Therefore, the expected output is "Ab-Cd".

Rules

• You may take input as a string or as an array of characters -- which may or may not be the same thing, depending on your language.
• You may also output an array of characters instead of a string.
• This is ogl-edocf code-golf

Test cases

"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

Pyth, 21 20 bytes

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

Try it here

Explanation

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.

Answer 2

Python 2, 100 98 95 bytes

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

Try it online!

Answer 3

Jelly, 14 bytes

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

A monadic link accepting a list of characters which yields a list of characters.

Try it online! Or see the test-suite.

How?

ØẠŒ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

Answer 4

05AB1E, 18 17 16 14 bytes

õsvy.uy.l-._y«

Try it online or verify all test cases.

Explanation:

õ            # 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 bytes

Solution:

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

Examples:

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!"

Explanation:

Iterate over the input string, rotating the previous output by 1, -1 or 0 depending upon it's position in the list "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 (/)

Notes:

• -10 bytes with inspiration from the 05AB1E solution

Answer 6

><>, 45 43 bytes

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

Try it online!

The fact that ><> has stack rotation helps, but having to check the case of the letter doesn't.

Explanation:

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

Haskell, 101 91 bytes

^{-10 bytes inspired by Curtis Bechtel's answer (use '@'<c,c<'[' over elem c['A'..'Z'] and the according range for lower-cased letters).}

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

Try it online!

Explanation / Ungolfed

The operator (!) takes a non-empty string x on which we can pattern-match and a character:

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

Now we can reduce the input's tail from the left to the right, starting with the first character of the input using:

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

Answer 8

Haskell, 122 92 bytes

Thanks to BWO for the suggestions! I also saved a lot by taking a slightly different approach than my original answer.

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

Try it online!

Answer 9

JavaScript (Node.js), 116 102 bytes

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

Try it online!

Original (116 111 106B)

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

Answer 10

Ruby, 51 bytes

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

Try it online!

Input and output are arrays of characters

The trick:

The code is pretty straightforward, except perhaps the rotation part:

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

x is a single character, which could be a letter, the first expression x=~/\W/ returns nil if it's a letter, and 0 otherwise. If it's 0, we're done, if not, the logical or checks the second expression: ?_<=>x returns -1 for upper case and 1 for lower case. So the rotation is:

• -1 (1 to the left) for upper case
• +1 (1 to the right) for lower case
• 0 (no rotation) if it's not a letter

Answer 11

Red, 110 bytes

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]

Try it online!

Explanation:

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

Perl 6, 47 bytes

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

Try it online!

Works on an array of chars.

Answer 13

Japt, 17 16 14 bytes

Takes input as an array of characters, outputs a string

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

Try it

---

Explanation

 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

Jelly, 19 bytes

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

Try it online!

Answer 15

Java 10, 149 119 bytes

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

Port of @ShieruAsakoto JavaScript answer, so make sure to upvote him.

Try it online.

Explanation:

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

Stax, 32 bytes

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

Run and debug it

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

A lot of stack swapping which is probably unnecessary. I really would like to get this down more, but I was strugging with the ordering of the stack. Maybe somebody can figure it out if they are bored. Will keep working on it.

Answer 17

Attache, 69 bytes

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

Try it online!

Explanation

General shape

The function looks generally like this:

~Fold[{...}]#Iota

Which folds {...} over each member in the range from 0 to #input - 1 (Iota), starting with the input as a seed.

The inner function

The following function is called as f[building, index] and is called with each index from 0 to #input exclusive. @SplitAt calls SplitAt on these arguments, splitting the input string on 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

Essentially, this function rotates the left portion of the string according to the first character of the right portion.

Answer 18

Charcoal, 20 bytes

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

Try it online! Link is to verbose version of code. Explanation:

ＦＳ

Loop over the input characters.

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

Map over the string of collected characters so far, cyclically indexing into the collected characters so far with the index incremented or decremented if the current character is upper or lower case respectively. This completes the rotation. The next character is then concatenated, and the result assigned back to the string.

ω

Print the result.

Answer 19

R, 107 102 100 bytes

Massive because R's string manip is bulky. Can anyone get it under 100?

-5 bytes using the "set loop variables to F to avoid initializing" trick.

-2 bytes by assuming all characters are printable and using 2*!k%%97>25 rather than 2*k%in%97:122 for testing lower case, using operator precedence.

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)}

Try it online!

Answer 20

Japt, 25 23 bytes

I give up, Can't make it shorter

-2 bytes from @ETHproductions

£=¯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    

Try it online!

Answer 21

Retina, 67 64 58 bytes

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

-9 bytes thanks to @Neil removing the three unnecessary ? I had added, as well as the unnecessary (.*) in the else-case.

Try it online or verify all test cases. (NOTE: Outputs with a trailing newline. The header in the test suite is to test each input-line as a separate test case, and the footer is to remove that trailing newline for a more compact output.)

Explanation:

Prepend a newline before the input:

^
¶

Continue replacing as long as we can find a match:

+`

Everything else is three different checks merged together:

If the character right after the newline is lowercase letter: rotate everything before the newline once towards the right, and then append that character and the newline:

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

If the character right after the newline is an uppercase letter: rotate everything before the newline once towards the left, and then append that character and the newline:

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

Else (neither a lowercase nor uppercase letter): simply shift the newline once towards the right for the next 'iteration':

¶(.)
$1¶

These three checks above are merged with regex OR statements (|) and larger group-replacements to make it act like an if(lowercase) ... elseif(uppercase) ... else ...:

Answer 22

Pyth, 16 bytes

em=+.>k-F}RGrBd2

Try it here!

Explanation:

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.

Answer 23

MATL, 20 bytes

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

Try it online!

-4 bytes thanks to Luis Mendo.

Converts uppercase/lowercase/non-letter to [-1,0,1] (first half of the program). Applies circshift consecutively (second half). I'm wrecking my brain if there's a better way to map uppercase/lowercase to [-1,0,1] (see the second version), and perhaps a way to reverse the string right away so as to get rid of the two w's needed for the &).

Answer 24

C (clang), 168 159 153 119 bytes

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 thanks to @ceilingcat

Try it online!