Description du défi

Faites défiler toutes les lettres de la première partie de l'alphabet dans un sens et les lettres de la seconde moitié de l'alphabet dans l'autre. Les autres personnages restent en place.

Exemples

1: Bonjour tout le monde

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 .: chaîne vide

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

Contribution

Chaîne que vous devez faire pivoter. Peut être vide. Ne contient pas de nouvelles lignes.

Sortie

Chaîne d'entrée pivotée,
retour à la ligne autorisé autorisé Peut être écrit à l'écran ou renvoyé par une fonction.

Règles

• Aucune échappatoire autorisée
• C'est le code-golf, donc le code le plus court en octets pour résoudre le problème l'emporte
• Le programme doit renvoyer la bonne solution

MATL , 29 octets

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

Essayez-le en ligne!

Explication

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

Rétine , 55 octets

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

Essayez-le en ligne!

Utilise deux étapes de tri pour faire pivoter séparément la première et la seconde moitié des lettres.

05AB1E , 44 43 42 octets

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

Explication

Générez une liste des lettres de l'alphabet des deux cas. ['Aa','Bb', ..., 'Zz']

Оn2äø€J

Divisé en 2 parties et stockez une copie dans le registre.

2ä©

Extrait les lettres de l'entrée qui font partie de la 1ère moitié de l'alphabet, faites -le pivoter et stocker dans X .

`ŠÃÁU

Extrait les lettres de l'entrée qui font partie de la 2ème moitié de l'alphabet, faites -le pivoter et stocker dans Y .

ÃÀV

Boucle principale

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

Essayez-le en ligne!

Remarque: le débutÐ peut être omis dans 2sable pour une solution de 41 octets.

Javascript (ES6), 155 142 138 octets

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)

Edit: enregistré 3 4 octets en utilisant unshift()(inspiré par la réponse d'edc65)

Comment ça marche

La Rfonction prend une méthode de tableau comme paramètre m:

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

Il est d'abord utilisé avec la pushméthode pour stocker les caractères extraits dans a[](première moitié de l'alphabet) et b[](seconde moitié de l'alphabet). Une fois que ces tableaux ont été tournés, R()est appelé une deuxième fois avec la shiftméthode pour injecter les nouveaux caractères dans la chaîne finale.

D'où la syntaxe légèrement inhabituelle: R`push`et R`shift`.

Démo

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 octets

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

Essayez-le en ligne!

Utilise une approche similaire à ma réponse de mélange de voyelles .

Python, 211 octets

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

Le mieux que je puisse faire. Prend la chaîne de STDIN et imprime le résultat dans STDOUT.

alternative avec 204 octets, mais imprime malheureusement une nouvelle ligne après chaque caractère:

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 octets

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

Utiliser la parseIntbase 36 pour séparer la première moitié, la seconde moitié et les autres. Pour tout personnage c, j'évalue y=parseInt(c,36)pour 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

y=parseInt(c,36), x=(y>22)+(y>9)Donne donc x==1pour la première moitié, x==2pour la seconde moitié et x==0pour tout autre (commeNaN > tout nombre est faux)

Première étape: la chaîne d'entrée est mappée sur un tableau de 0,1 ou 2. Pendant ce temps, tous les caractères de la chaîne sont ajoutés à 3 tableaux. À la fin de cette première étape, les réseaux 1 et 2 sont tournés dans des directions opposées.

Deuxième étape: le tableau mappé est analysé, reconstruisant une chaîne de sortie en prenant chaque caractère des 3 tableaux temporaires.

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

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

Tester

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 octets

Comprend +1 pour -p

Exécutez avec l'entrée sur 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 octets

Une meilleure variation sur le thème:

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

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

solution antérieure:

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

non 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

Rubis, 89 octets

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 octets

Assez difficile à jouer au golf ... Voici ma proposition:

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