Mô tả thử thách

Xoay vòng tất cả các chữ cái từ phần đầu tiên của bảng chữ cái theo một hướng và các chữ cái từ nửa sau của bảng chữ cái theo hướng khác. Các nhân vật khác ở lại tại chỗ.

Ví dụ

1: Xin chào thế giới

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: cá tuyết

codegolf
c deg lf
 o   o  

f cde gl
 o   o  

focdeogl

3.: Chuỗi rỗng

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

Đầu vào

Chuỗi bạn cần xoay. Có thể trống rỗng. Không chứa dòng mới.

Đầu ra

Chuỗi đầu vào được xoay, dòng mới cho phép
Có thể được ghi vào màn hình hoặc được trả về bởi một chức năng.

Quy tắc

• Không có sơ hở cho phép
• Đây là mã golf, vì vậy mã ngắn nhất trong các byte giải quyết vấn đề sẽ thắng
• Chương trình phải trả về giải pháp đúng

MATL , 29 byte

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

Hãy thử trực tuyến!

Giải trình

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

Võng mạc , 55 byte

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

Hãy thử trực tuyến!

Sử dụng hai giai đoạn sắp xếp để xoay các chữ cái đầu tiên và nửa thứ hai một cách riêng biệt.

05AB1E , 44 43 42 byte

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

Giải trình

Tạo một danh sách các chữ cái của bảng chữ cái của cả hai trường hợp. ['Aa','Bb', ..., 'Zz']

Оn2äø€J

Chia thành 2 phần và lưu một bản sao trong sổ đăng ký.

2ä©

Trích xuất các ký tự từ đầu vào mà là một phần của nửa 1st của bảng chữ cái, xoay nó và lưu trữ trong X .

`ŠÃÁU

Trích xuất các ký tự từ đầu vào mà là một phần của nửa thứ 2 của bảng chữ cái, xoay nó và lưu trữ trong Y .

ÃÀV

Vòng lặp chính

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

Hãy thử trực tuyến!

Lưu ý: Có Ðthể bỏ qua phần đầu trong 2sable cho giải pháp 41 byte.

Javascript (ES6), 155 142 138 byte

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)

Chỉnh sửa: đã lưu 3 4 byte bằng cách sử dụng unshift()(lấy cảm hứng từ câu trả lời của edc65)

Làm thế nào nó hoạt động

Các Rchức năng có một phương pháp mảng như tham số của nó m:

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

Nó được sử dụng đầu tiên với pushphương thức lưu trữ các ký tự được trích xuất trong a[](nửa đầu của bảng chữ cái) và b[](nửa sau của bảng chữ cái). Khi các mảng này đã được xoay, R()được gọi là lần thứ hai với shiftphương thức để chèn các ký tự mới trong chuỗi cuối cùng.

Do đó cú pháp hơi bất thường: R`push`và R`shift`.

Bản giới thiệu

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 byte

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

Hãy thử trực tuyến!

Sử dụng một cách tiếp cận tương tự với câu trả lời xáo trộn nguyên âm của tôi .

Python, 211 byte

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

Tốt nhất tôi có thể làm. Lấy chuỗi từ STDIN và in kết quả sang STDOUT.

thay thế bằng 204 Byte, nhưng không may in một dòng mới sau mỗi char:

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 byte

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

Sử dụng parseIntcơ sở 36 để tách nửa đầu, nửa sau và khác. Đối với bất kỳ nhân vật c, tôi đánh giá y=parseInt(c,36)để

• 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

Vì vậy, y=parseInt(c,36), x=(y>22)+(y>9)đưa ra x==1cho nửa đầu, x==2cho nửa thứ hai và x==0cho bất kỳ khác (vì NaN> bất kỳ số nào là sai)

Bước đầu tiên: chuỗi đầu vào được ánh xạ tới một mảng 0,1 hoặc 2. Trong khi đó tất cả các ký tự chuỗi ar được thêm vào 3 mảng. Ở cuối bước đầu tiên này, mảng 1 và 2 được xoay theo hai hướng ngược nhau.

Bước thứ hai: mảng được ánh xạ được quét, xây dựng lại chuỗi đầu ra lấy từng ký tự từ 3 mảng tạm thời.

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

Ít chơi gôn

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

Kiểm tra

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 byte

Bao gồm +1 cho -p

Chạy với đầu vào trên 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 byte

Một biến thể tốt hơn về chủ đề:

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

vô dụng:

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

giải pháp trước:

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

vô dụng:

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 byte

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 byte

Khá khó để chơi gôn ... Đây là đề xuất của tôi:

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