Descripción del desafío

Ciclo todas las letras de la primera parte del alfabeto en una dirección, y las letras de la segunda mitad del alfabeto en la otra. Otros personajes permanecen en su lugar.

Ejemplos

1: hola 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 .: cadena vacía

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

Entrada

Cadena que necesita rotar. Puede estar vacio No contiene nuevas líneas.

Salida

Cadena de entrada girada, nueva línea final permitida
Puede ser escrita en la pantalla o devuelta por una función.

Reglas

• No se permiten lagunas
• Este es el código de golf, por lo que gana el código más corto en bytes para resolver el problema
• El programa debe devolver la solución correcta

MATL , 29 bytes

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Utiliza dos etapas de clasificación para rotar las letras de la primera y segunda mitad por separado.

05AB1E , 44 43 42 bytes

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

Explicación

Genere una lista de las letras del alfabeto de ambos casos. ['Aa','Bb', ..., 'Zz']

Оn2äø€J

Dividir en 2 partes y almacenar una copia en el registro.

2ä©

Extraer las cartas de la entrada, que son una parte de la primera mitad del alfabeto, girarla y almacenar en X .

`ŠÃÁU

Extraiga las letras de la entrada que forman parte de la segunda mitad del alfabeto, gírelo y guárdelo Y .

ÃÀV

Bucle 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

Pruébalo en línea!

Nota: El inicioÐ puede omitirse en 2sable para una solución 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: guardado 3 4 bytes usando unshift()(inspirado en la respuesta de edc65)

Cómo funciona

La Rfunción toma un método de matriz como parámetrom :

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

Se usa por primera vez con el pushmétodo para almacenar caracteres extraídos en a[](primera mitad del alfabeto) yb[] (segunda mitad del alfabeto). Una vez que estas matrices se han girado, R()se llama por segunda vez con el shiftmétodo para inyectar los nuevos caracteres en la cadena final.

De ahí la sintaxis ligeramente inusual: R`push` y R`shift`.

Manifestación

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=

Pruébalo en línea!

Utiliza un enfoque similar a mi respuesta de combinación de vocales .

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

Lo mejor que pude hacer. Toma la cadena de STDIN e imprime el resultado en STDOUT.

alternativa con 204 Bytes, pero desafortunadamente imprime una nueva línea después de cada carácter:

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 la parseIntbase 36 para separar la primera mitad, la segunda mitad y otras. Para cualquier personaje c, evalúo 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

Entonces y=parseInt(c,36), x=(y>22)+(y>9)da x==1para la primera mitad, x==2para la segunda mitad y x==0para cualquier otra (ya que NaN> cualquier número es falso)

Primer paso: la cadena de entrada se asigna a una matriz de 0,1 o 2. Mientras tanto, todos los caracteres de la cadena se agregan a 3 matrices. Al final de este primer paso, la matriz 1 y 2 se giran en direcciones opuestas.

Segundo paso: se escanea la matriz asignada, reconstruyendo una cadena de salida que toma cada carácter de las 3 matrices temporales.

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 golf

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``

Prueba

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

Incluye +1 para -p

Ejecutar con la entrada en 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, 142133 bytes

Una mejor variación sobre el 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')

sin golf:

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

solución previa:

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]')

sin golf:

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

Muy difícil jugar al golf ... Aquí está mi propuesta:

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