Herausforderungsbeschreibung

Wechseln Sie alle Buchstaben aus dem ersten Teil des Alphabets in die eine und die Buchstaben aus der zweiten Hälfte des Alphabets in die andere Richtung. Andere Charaktere bleiben an Ort und Stelle.

Beispiele

1: Hallo Welt

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 .: leere Zeichenfolge

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

Eingang

String, den Sie drehen müssen. Kann leer sein. Enthält keine Zeilenumbrüche.

Ausgabe

Gedrehte Eingabezeichenfolge, Zeilenumbruch zulässig. Kann
auf den Bildschirm geschrieben oder von einer Funktion zurückgegeben werden.

Regeln

• Keine Lücken erlaubt
• Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes, der das Problem löst
• Das Programm muss die richtige Lösung zurückgeben

MATL , 29 Bytes

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

Probieren Sie es online!

Erläuterung

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

Netzhaut , 55 Bytes

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

Probieren Sie es online!

Verwendet zwei Sortierstufen, um die Buchstaben der ersten und zweiten Hälfte getrennt zu drehen.

05AB1E , 44 43 42 Bytes

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

Erläuterung

Erstellen Sie eine Liste der Buchstaben des Alphabets in beiden Fällen. ['Aa','Bb', ..., 'Zz']

Оn2äø€J

In 2 Teile teilen und eine Kopie im Register ablegen.

2ä©

Extrahiert die Briefe von dem Eingang, der ein Teil der 1. Hälfte des Alphabets sind, drehen, und Speicher in X .

`ŠÃÁU

Extrahiert die Briefe von dem Eingang, der ein Teil der zweiten Hälfte des Alphabets sind, drehen und zu speichern in Y .

ÃÀV

Hauptschleife

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

Probieren Sie es online!

Hinweis: Bei einer 41- Byte-Lösung Ðkann das führende Zeichen in 2sable weggelassen werden.

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)

Bearbeiten: 3 bis 4 Bytes mit gespeichert unshift()(inspiriert von der Antwort von edc65)

Wie es funktioniert

Die RFunktion verwendet eine Array-Methode als Parameter m:

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

Es wird zuerst mit der pushMethode verwendet, um extrahierte Zeichen in a[](erste Hälfte des Alphabets) und b[](zweite Hälfte des Alphabets) zu speichern . Sobald diese Arrays gedreht wurden, R()wird ein zweites Mal mit der shiftMethode aufgerufen , die neuen Zeichen in die endgültige Zeichenfolge einzufügen.

Daher die etwas ungewöhnliche Syntax: R`push`undR`shift` .

Demo

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=

Probieren Sie es online!

Benutzt einen ähnlichen Ansatz wie mein Vokal, der die Antwort mischt .

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

Bestes, was ich tun konnte. Nimmt den String von STDIN und gibt das Ergebnis an STDOUT aus.

alternativ mit 204 Bytes, gibt aber leider nach jedem Zeichen eine neue Zeile aus:

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

Verwenden der parseIntBasis 36, um die erste Hälfte, die zweite Hälfte und andere zu trennen. Für jeden Charakter cbewerte ich y=parseInt(c,36)damit

• 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

So y=parseInt(c,36), x=(y>22)+(y>9)gibt es x==1für die erste Hälfte, x==2für die zweite Hälfte und x==0für jede andere (da NaN> jede Zahl falsch ist)

Erster Schritt: Die Eingabezeichenfolge wird auf ein Array von 0,1 oder 2 abgebildet. In der Zwischenzeit werden alle Zeichenfolgenzeichen zu 3 Arrays hinzugefügt. Am Ende dieses ersten Schritts werden die Felder 1 und 2 in entgegengesetzte Richtungen gedreht.

Zweiter Schritt: Das zugeordnete Array wird gescannt. Dabei wird eine Ausgabezeichenfolge erstellt, die jedes Zeichen aus den drei temporären Arrays übernimmt.

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

Weniger golfen

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

Prüfung

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

Beinhaltet +1 für -p

Führen Sie mit der Eingabe auf STDIN aus:

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 Bytes

Eine bessere Variation des Themas:

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

vorherige Lösung:

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

Ziemlich schwer zu golfen ... Hier ist mein Vorschlag:

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