คำอธิบายการท้าทาย

วนตัวอักษรทั้งหมดจากส่วนแรกของตัวอักษรในทิศทางเดียวและตัวอักษรจากครึ่งหลังของตัวอักษรในอีกทิศทางหนึ่ง ตัวละครอื่น ๆ อยู่ในสถานที่

ตัวอย่าง

1: สวัสดีชาวโลก

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 .: สตริงว่าง

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

อินพุต

สายที่คุณต้องหมุน อาจว่างเปล่า ไม่มีการขึ้นบรรทัดใหม่

เอาท์พุต

สตริงอินพุตแบบหมุนขึ้นบรรทัดใหม่ที่อนุญาต
สามารถเขียนลงบนหน้าจอหรือส่งคืนโดยฟังก์ชัน

กฎระเบียบ

• ไม่อนุญาตช่องโหว่
• นี่คือ code-golf ดังนั้นโค้ดที่สั้นที่สุดในหน่วยไบต์ที่แก้ปัญหาจะชนะ
• โปรแกรมจะต้องส่งคืนโซลูชั่นที่ถูกต้อง

MATL , 29 ไบต์

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

ลองออนไลน์!

คำอธิบาย

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

เรติน่า , 55 ไบต์

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

ลองออนไลน์!

ใช้สองขั้นตอนการเรียงลำดับเพื่อหมุนตัวอักษรครึ่งแรกและครึ่งหลังแยกกัน

05AB1E , 44 43 42 ไบต์

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

คำอธิบาย

สร้างรายการตัวอักษรของตัวอักษรของทั้งสองกรณี ['Aa','Bb', ..., 'Zz']

Оn2äø€J

แบ่งออกเป็น 2 ส่วนและเก็บสำเนาไว้ในทะเบียน

2ä©

สารสกัดจากตัวอักษรจากการป้อนข้อมูลที่เป็นส่วนหนึ่งของ 1 ครึ่งหนึ่งของตัวอักษรที่หมุนและเก็บในX

`ŠÃÁU

สารสกัดจากตัวอักษรจากการป้อนข้อมูลที่เป็นส่วนหนึ่งของครึ่งปีที่ 2 ของตัวอักษรที่หมุนและเก็บในY

ÃÀV

ห่วงหลัก

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

ลองออนไลน์!

หมายเหตุ:การนำหน้าÐสามารถละเว้นใน2sableสำหรับโซลูชัน41ไบต์

Javascript (ES6), 155 142 138 ไบต์

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)

แก้ไข: บันทึกแล้ว 3 4 ไบต์โดยการใช้unshift()(ได้รับแรงบันดาลใจจากคำตอบของ edc65)

มันทำงานอย่างไร

Rฟังก์ชั่นใช้เวลาวิธีการอาร์เรย์เป็นพารามิเตอร์ของm :

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

มันถูกใช้ครั้งแรกกับpushวิธีการจัดเก็บอักขระที่แยกออกมาa[](ครึ่งแรกของตัวอักษร) และb[] (ครึ่งหลังของตัวอักษร) เมื่ออาร์เรย์เหล่านี้หมุนแล้วR()จะถูกเรียกอีกครั้งด้วยshiftวิธีการฉีดอักขระใหม่ในสตริงสุดท้าย

ดังนั้นไวยากรณ์ที่ผิดปกติเล็กน้อย: R`push`R`shift`และ

การสาธิต

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 ไบต์

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

ลองออนไลน์!

ใช้วิธีการคล้ายกับฉันคำตอบสระสับ

Python ขนาด 211 ไบต์

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

ดีที่สุดที่ฉันสามารถทำได้ รับสตริงจาก STDIN และพิมพ์ผลลัพธ์ไปที่ STDOUT

ทางเลือก 204 ไบต์ แต่น่าเสียดายที่พิมพ์บรรทัดใหม่หลังจากอักขระแต่ละตัว:

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 ไบต์

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

ใช้parseIntฐาน 36 เพื่อแยกครึ่งแรกครึ่งหลังและอื่น ๆ สำหรับตัวละครใด ๆcฉันประเมิน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

ดังนั้นy=parseInt(c,36), x=(y>22)+(y>9)ให้x==1ครึ่งแรกx==2สำหรับครึ่งหลังและx==0อีก ๆ (เหมือนNaN> หมายเลขใด ๆ เป็นเท็จ)

ขั้นตอนแรก: สตริงการป้อนข้อมูลที่ถูกแมปกับอาร์เรย์ของ 0,1 หรือ 2 ในขณะเดียวกันตัวอักษรสตริงทั้งหมดที่เพิ่มเข้าไปใน 3 อาร์เรย์ ในตอนท้ายของขั้นตอนแรกนี้อาร์เรย์ 1 และ 2 จะหมุนในทิศทางตรงกันข้าม

ขั้นตอนที่สอง: สแกนอาร์เรย์ที่แมปแล้วสร้างสตริงเอาต์พุตใหม่โดยใช้อักขระแต่ละตัวจาก 3 อาร์เรย์ชั่วคราว

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

น้อย golfed

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

ทดสอบ

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 ไบต์

รวม +1 สำหรับ -p

รันด้วยอินพุตบน 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 ไบต์

ชุดรูปแบบที่ดีกว่า:

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

วิธีแก้ปัญหาก่อนหน้า:

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 ไบต์

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 ไบต์

ค่อนข้างยากที่จะเล่นกอล์ฟ ... นี่คือข้อเสนอของฉัน:

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