Descrição do Desafio

Ciclo todas as letras da primeira parte do alfabeto em uma direção e as letras da segunda metade do alfabeto na outra. Outros caracteres permanecem no lugar.

Exemplos

1: Olá mundo

Hello_world //Input
Hell     ld //Letters from first half of alphabet
    o wor   //Letters from second half of alphabet
     _      //Other characters
dHel     ll //Cycle first letters
    w oro   //Cycle second letters
     _      //Other characters stay
dHelw_oroll //Solution

2: codegolf

codegolf
c deg lf
 o   o  

f cde gl
 o   o  

focdeogl

3 .: corda vazia

(empty string) //Input
(empty string) //Output

Entrada

String que você precisa girar. Pode estar vazio. Não contém novas linhas.

Saída

Seqüência de caracteres de entrada girada, nova linha final permitida
Pode ser gravada na tela ou retornada por uma função.

Regras

• Não são permitidas brechas
• Isso é código-golfe, então o código mais curto em bytes que resolve o problema ganha
• O programa deve retornar a solução correta

MATL , 29 bytes

FT"ttk2Y213:lM@*+)m)1_@^YS9M(

Experimente online!

Explicação

FT        % Push arrray [0 1]
"         % For each
  t       %   Duplicate. Takes input string implicitly in the first iteration
  tk      %   Duplicate and convert to lower case
  2Y2     %   Predefined string: 'ab...yz'
  13:     %   Generate vector [1 2 ... 13]
  lM      %   Push 13 again
  @*      %   Multiply by 0 (first iteration) or 1 (second): gives 0 or 13
  +       %   Add: this leaves [1 2 ... 13] as is in the first iteration and
          %   transforms it into [14 15 ... 26] in the second
  )       %   Index: get those letters from the string 'ab...yz'
  m       %   Ismember: logical index of elements of the input that are in 
          %   that half of the alphabet
  )       %   Apply index to obtain those elements from the input
  1_@^    %   -1 raised to 0 (first iteration) or 1 (second), i.e. 1 or -1
  YS      %   Circular shift by 1 or -1 respectively
  9M      %   Push the logical index of affected input elements again
  (       %   Assign: put the shifted chars in their original positions
          % End for each. Implicitly display

Retina , 55 bytes

O$i`[a-m](?=.*([a-m]))?
$1
O$i`((?<![n-z].*))?[n-z]
$#1

Experimente online!

Usa dois estágios de classificação para girar as letras da primeira e da segunda metade separadamente.

05AB1E , 44 43 42 bytes

Оn2äø€J2ä©`ŠÃÁUÃÀVv®`yåiY¬?¦VëyåiX¬?¦Uëy?

Explicação

Gere uma lista das letras do alfabeto dos dois casos. ['Aa','Bb', ..., 'Zz']

Оn2äø€J

Divida em 2 partes e guarde uma cópia no registro.

2ä©

Extrair as letras da entrada que fazem parte da 1ª metade do alfabeto, girá-lo e armazenar em X .

`ŠÃÁU

Extrair as letras da entrada que fazem parte da segunda metade do alfabeto, girá-lo e armazenar em Y .

ÃÀV

Laço principal

v                         # for each char in input
 ®`                       # push the lists of first and second half of the alphabet
   yåi                    # if current char is part of the 2nd half of the alphabet
      Y¬?                 # push the first char of the rotated letters in Y
         ¦V               # and remove that char from Y
           ëyåi           # else if current char is part of the 1st half of the alphabet
               X¬?        # push the first char of the rotated letters in X
                  ¦U      # and remove that char from X
                    ëy?   # else print the current char

Experimente online!

Nota: O líder Ðpode ser omitido no 2sable para uma solução de 41 bytes.

Javascript (ES6), 155 142 138 bytes

s=>(a=[],b=[],S=s,R=m=>s=s.replace(/[a-z]/gi,c=>(c<'N'|c<'n'&c>'Z'?a:b)[m](c)),R`push`,a.unshift(a.pop(b.push(b.shift()))),s=S,R`shift`,s)

Editar: salvou 3 4 bytes usando unshift()(inspirado na resposta de edc65)

Como funciona

A Rfunção usa um método de matriz como parâmetro m:

R = m => s = s.replace(/[a-z]/gi, c => (c < 'N' | c < 'n' & c > 'Z' ? a : b)[m](c))

É usado pela primeira vez com o pushmétodo para armazenar caracteres extraídos em a[](primeira metade do alfabeto) e b[](segunda metade do alfabeto). Depois que essas matrizes são rotacionadas, R()é chamado uma segunda vez com o shiftmétodo para injetar os novos caracteres na sequência final.

Daí a sintaxe um pouco incomum: R`push`e R`shift`.

Demo

let f =
s=>(a=[],b=[],S=s,R=m=>s=s.replace(/[a-z]/gi,c=>(c<'N'|c<'n'&c>'Z'?a:b)[m](c)),R`push`,a.unshift(a.pop(b.push(b.shift()))),s=S,R`shift`,s)

console.log("Hello_world", "=>", f("Hello_world"));
console.log("codegolf", "=>", f("codegolf"));
console.log("HELLO_WORLD", "=>", f("HELLO_WORLD"));

CJam , 41 bytes

lee_{'N,_el^:A&},_1m>er_{ADf+&},_1m<erWf=

Experimente online!

Usa uma abordagem semelhante à minha resposta de embaralhamento de vogal .

Python, 211 bytes

x=input()
y=lambda i:'`'<i.lower()<'n'
z=lambda i:'m'<i.lower()<'{'
u=filter(y,x)
d=filter(z,x)
r=l=""
for i in x:
 if y(i):r+=u[-1];u=[i]
 else:r+=i
for i in r[::-1]:
 if z(i):l=d[0]+l;d=[i]
 else:l=i+l
print l

O melhor que eu poderia fazer. Pega a sequência de STDIN e imprime o resultado em STDOUT.

alternativa com 204 bytes, mas infelizmente imprime uma nova linha após cada caractere:

x=input()
y=lambda i:'`'<i.lower()<'n'
z=lambda i:'m'<i.lower()<'{'
f=filter
u=f(y,x)
d=f(z,x)
r=l=""
for i in x[::-1]:
 if z(i):l=d[0]+l;d=[i]
 else:l=i+l
for i in l:
 a=i
 if y(i):a=u[-1];u=[i]
 print a

Python 2, 149 bytes

s=input();g=lambda(a,b):lambda c:a<c.lower()<b
for f in g('`n'),g('m{'):
 t='';u=filter(f,s)[-1:]
 for c in s:
  if f(c):c,u=u,c
  t=c+t
 s=t
print s

JavaScript (ES6), 144

Usando a parseIntbase 36 para separar a primeira metade, a segunda metade e a outra. Para qualquer personagem c, eu avalio y=parseInt(c,36)para que

• c '0'..'9' -> y 0..9
• c 'a'..'m' or 'A'..'M' -> y 10..22
• c 'n'..'z' or 'N'..'Z' -> y 23..35
• c any other -> y NaN

O mesmo y=parseInt(c,36), x=(y>22)+(y>9)vale x==1para a primeira metade, x==2para a segunda metade e x==0para qualquer outra (como NaN> qualquer número é falso)

Primeiro passo: a string de entrada é mapeada para uma matriz de 0,1 ou 2. Enquanto isso, todos os caracteres da string são adicionados a 3 matrizes. No final desta primeira etapa, a matriz 1 e 2 são giradas em direções opostas.

Segunda etapa: a matriz mapeada é varrida, reconstruindo uma sequência de saída que pega cada caractere das 3 matrizes temporárias.

s=>[...s].map(c=>a[y=parseInt(c,36),x=(y>22)+(y>9)].push(c)&&x,a=[[],p=[],q=[]]).map(x=>a[x].shift(),p.unshift(p.pop(q.push(q.shift())))).join``

Menos golfe

s=>[...s].map(
  c => a[ y = parseInt(c, 36), x=(y > 22) + (y > 9)].push(c) 
       && x,
  a = [ [], p=[], q=[] ]
).map(
  x => a[x].shift(),  // get the output char from the right temp array
  p.unshift(p.pop()), // rotate p
  q.push(q.shift())   // rotate q opposite direction
).join``

Teste

f=
s=>[...s].map(c=>a[y=parseInt(c,36),x=(y>22)+(y>9)].push(c)&&x,a=[[],p=[],q=[]]).map(x=>a[x].shift(),p.unshift(p.pop()),q.push(q.shift())).join``

function update() {
  O.textContent=f(I.value);
}

update()

<input id=I oninput='update()' value='Hello, world'>
<pre id=O></pre>

Perl. 53 bytes

Inclui +1 para -p

Execute com a entrada em STDIN:

drotate.pl <<< "Hello_world"

drotate.pl:

#!/usr/bin/perl -p
s%[n-z]%(//g,//g)[1]%ieg;@F=/[a-m]/gi;s//$F[-$.--]/g

Python, 142 133 bytes

Uma melhor variação sobre o tema:

import re
def u(s,p):x=re.split('(?i)([%s])'%p,s);x[1::2]=x[3::2]+x[1:2];return ''.join(x)
v=lambda s:u(u(s[::-1],'A-M')[::-1],'N-Z')

ungolfed:

import re
def u(s,p):
    x = re.split('(?i)([%s])'%p,s)  # split returns a list with matches at the odd indices
    x[1::2] = x[3::2]+x[1:2]
    return ''.join(x)

def v(s):
  w = u(s[::-1],'A-M')
  return u(w[::-1],'N-Z')

solução anterior:

import re
def h(s,p):t=re.findall(p,s);t=t[1:]+t[:1];return re.sub(p,lambda _:t.pop(0),s)
f=lambda s:h(h(s[::-1],'[A-Ma-m]')[::-1],'[N-Zn-z]')

ungolfed:

import re
def h(s,p):                              # moves matched letters toward front
    t=re.findall(p,s)                    # find all letters in s that match p
    t=t[1:]+t[:1]                        # shift the matched letters
    return re.sub(p,lambda _:t.pop(0),s) # replace with shifted letter

def f(s):
    t = h(s[::-1],'[A-Ma-m]')            # move first half letters toward end
    u = h(t[::-1],'[N-Zn-z]')            # move 2nd half letters toward front
    return u

Ruby, 89 bytes

f=->n,q,s{b=s.scan(q).rotate n;s.gsub(q){b.shift}}
puts f[1,/[n-z]/i,f[-1,/[a-m]/i,gets]]

PHP, 189 bytes

Muito difícil de jogar golfe ... Aqui está a minha proposta:

for($p=preg_replace,$b=$p('#[^a-m]#i','',$a=$argv[1]),$i=strlen($b)-1,$b.=$b,$c=$p('#[^n-z]#i','',$a),$c.=$c;($d=$a[$k++])!=='';)echo strpos(z.$b,$d)?$b[$i++]:(strpos(a.$c,$d)?$c[++$j]:$d);