Opis wyzwania

Przełącz wszystkie litery z pierwszej części alfabetu w jednym kierunku, a litery z drugiej połowy alfabetu w drugim. Inne postacie pozostają na miejscu.

Przykłady

1: Witaj świecie

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 .: pusty ciąg

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

Wkład

Sznurek, który musisz obrócić. Może być pusty. Nie zawiera nowych linii.

Wydajność

Obrócony ciąg wejściowy, dozwolony końcowy
znak nowej linii Może być zapisany na ekranie lub zwrócony przez funkcję.

Zasady

• Niedozwolone są luki
• To jest golf golfowy, więc wygrywa najkrótszy kod w bajtach rozwiązujący problem
• Program musi zwrócić prawidłowe rozwiązanie

MATL , 29 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

Siatkówka , 55 bajtów

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

Wypróbuj online!

Wykorzystuje dwa etapy sortowania, aby oddzielnie obrócić pierwszą i drugą połowę litery.

05AB1E , 44 43 42 bajtów

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

Wyjaśnienie

Wygeneruj listę liter alfabetu obu przypadków. ['Aa','Bb', ..., 'Zz']

Оn2äø€J

Podziel na 2 części i zachowaj kopię w rejestrze.

2ä©

Wyodrębnić listów od wejścia, które są częścią 1. połowie alfabetu, obracać je i przechowywać w X .

`ŠÃÁU

Wyodrębnić listów od wejścia, które są częścią 2. połowie alfabetu, obracać je i przechowywać w Y .

ÃÀV

Główna pętla

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

Wypróbuj online!

Uwaga: Wiodące Ðmożna pominąć w 2sable dla rozwiązania 41- bajtowego.

JavaScript (ES6), 155 142 138 bajtów

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)

Edycja: zapisano 3 4 bajty za pomocąunshift() (inspirowane odpowiedzią edc65)

Jak to działa

RFunkcji zajmuje sposób tablicy jako parametr m:

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

Jest on po raz pierwszy używany w pushmetodzie do przechowywania wyodrębnionych znaków w a[](pierwsza połowa alfabetu) i b[](druga połowa alfabetu). Po obróceniu tych tablic R()wywoływana jest po raz drugi shiftmetodą wstrzykiwania nowych znaków w końcowy ciąg.

Stąd nieco nietypowa składnia: R`push` i R`shift`.

Próbny

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 bajtów

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

Wypróbuj online!

Stosuje podobne podejście do mojej odpowiedzi na tasowanie samogłosek .

Python, 211 bajtów

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

Najlepsze, co mogłem zrobić. Pobiera ciąg ze STDIN i wypisuje wynik do STDOUT.

alternatywnie z 204 bajtami, ale niestety drukuje nowy wiersz po każdym znaku:

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 bajtów

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

Używanie parseIntbazy 36 do rozdzielenia pierwszej, drugiej i drugiej połowy. Dla każdej postaci coceniam y=parseInt(c,36)tak

• 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

Więc y=parseInt(c,36), x=(y>22)+(y>9)daje x==1za pierwszą połowę, x==2za drugą połowę i x==0za każdą inną (ponieważ NaN> dowolna liczba jest fałszywa)

Pierwszy krok: łańcuch wejściowy jest odwzorowywany na tablicę 0,1 lub 2. W międzyczasie wszystkie znaki łańcucha są dodawane do 3 tablic. Na końcu tego pierwszego kroku układ 1 i 2 są obracane w przeciwnych kierunkach.

Drugi krok: skanowana tablica jest skanowana, przebudowując łańcuch wyjściowy, biorąc każdy znak z 3 tablic tymczasowych.

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

Mniej golfa

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

Test

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 bajty

Obejmuje +1 dla -p

Uruchom z wejściem na 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 bajty

Lepsza odmiana na temat:

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

bez golfa:

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

wcześniejsze rozwiązanie:

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

bez golfa:

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

Rubinowy, 89 bajtów

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 bajtów

Trudno grać w golfa ... Oto moja propozycja:

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