Tauschen Sie bei einer Eingabezeichenfolge, die nur alphanumerische ASCII-Zeichen enthält und mit einem Buchstaben beginnt, jeden Buchstabenlauf mit dem folgenden Ziffernlauf aus.

Ein Lauf ist eine Folge aufeinanderfolgender Buchstaben oder Ziffern. Beachten Sie, dass in dem Fall, in dem die Eingabezeichenfolge mit einer Folge von Buchstaben endet, diese Folge unberührt bleibt.

Beispiel für einen Rundgang

Zum Beispiel bei gegebener Eingabezeichenfolge uV5Pt3I0:

1. Getrennte Buchstaben- und Ziffernfolgen: uV 5 Pt 3 I 0
2. Laufpaare identifizieren: (uV 5) (Pt 3) (I 0)
3. Swap Paare von Läufen: (5 uV) (3 Pt) (0 I)
4. Verketten: 5uV3Pt0I

Beispiele

uV5Pt3I0 -> 5uV3Pt0I
J0i0m8 -> 0J0i8m
abc256 -> 256abc
Hennebont56Fr -> 56HennebontFr
Em5sA55Ve777Rien -> 5Em55sA777VeRien
nOoP -> nOoP

Das ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes. Erklärungen sind erwünscht.

Gelee , 9 Bytes

~ṠŒg⁸ṁṭ2/

Probieren Sie es online!

Wie es funktioniert

~ṠŒg⁸ṁṭ2/  Main link. Argument: s (string)

~          Apply bitwise NOT.
           Bitwise operators attempt to cast to int, so if c is a digit, this
           yields ~int(c), a negative number.
           If c cannot be cast to int, ~ will yield 0.
 Ṡ         Take the sign.
           We've now mapped digits to -1, non-digits to 0.
  Œg       Group consecutive equal elements.
    ⁸ṁ     Mold s as the result, grouping run of digits and runs of non-digits.
       2/  Reduce all pairs of runs by...
      ṭ        tack, appending the first run of the pair to the second run.

Netzhaut , 15 Bytes

(\D+)(\d+)
$2$1

Dies ersetzt den regulären Ausdruck (\D+)(\d+)durch $2$1. Lassen Sie uns das aufschlüsseln, wenn Sie nicht wissen, was das bedeutet.

Das \Dbedeutet "Finde alles, was keine Zahl ist". \dbedeutet "Finde alles, was eine Zahl ist". Das +Zeichen bedeutet "Mindestens einmal übereinstimmen, aber versuchen Sie es so oft wie möglich". Die Klammern definieren eine Gruppe. Die erste Gruppe ist (\D+)und die zweite ist(\d+)

In der zweiten Zeile sagen wir, dass wir setzen möchten, was auch immer von der zweiten Gruppe abgeglichen wurde, gefolgt von dem, was von der ersten Gruppe abgeglichen wurde. Dies tauscht die Buchstaben- und Ziffernläufe effektiv aus.

Probieren Sie es online!

Haskell , 58 56 Bytes

Vielen Dank an @Laikoni für das Abschneiden von 2 Bytes

f""=""
f s|(a,(b,y))<-span(<':')<$>span(>'9')s=b++a++f y

Probieren Sie es online!

Ungolfed:

f "" = ""
f string | (letters, afterLetters) <- span (> '9') string
         , (numbers, afterNumbers) <- span (< ':') afterLetters
         = numbers ++ letters ++ f afterNumbers

JavaScript (ES6), 34 Byte

s=>s.replace(/(\D+)(\d+)/g,"$2$1")

Versuch es

o.innerText=(f=
s=>s.replace(/(\D+)(\d+)/g,"$2$1")
)(i.value="uV5Pt3I0");oninput=_=>o.innerText=f(i.value)

<input id=i><pre id=o>

Pyth , 15 Bytes

ss_Mc:z"(\d+)"3 2

Erläuterung

     :z"(\d+)"3      # Split the input z onto matches of numbers (\d+)
    c           2    # Split the resulting list in pieces of length 2
  _M                 # Reverse each pair
ss                   # Concatenate

Testsuite .

Python 2 , 49 Bytes

Jede Nicht-Regex-Lösung, die ich ausprobierte, war länger. : P

lambda s:re.sub('(\D+)(\d+)',r'\2\1',s)
import re

Probieren Sie es online!

Japt (v2.0a0), 16 Bytes

q/(\d+/ ò mw c q

Online testen!

Hinweis: Dies ist ein instabiles Alpha. Wenn dieser Link nicht funktioniert, können Sie eine etwas längere Version in Version 1.4.4 verwenden: Testen Sie sie online!

Erläuterung

q/(\d+/ ò mw c q  : Implicit input              "uV5Pt3I0"
q                 : Split input on
 /(\d+/           :   runs of digits, keeping each run. (This compiles to the regex /(\d+)/g)
                  : This gives                  ["uV","5","Pt","3","I","0",""]
        ò         : Take every pair of items.   [["uV","5"],["Pt","3"],["I","0"],[""]]
          m       : Map each pair by
           w      :   reversing.                [["5","uV"],["3","Pt"],["0","I"],[""]]
             c    : Flatten into one array.     ["5","uV","3","Pt","0","I",""]
               q  : Join into a single string.  "5uV3Pt0I"
                  : Implicit: output result of last expression

CJam , 32 30 28 Bytes

q{i_64>X\:X^{])[}&c}/]]2/Wf%

CJam hat keine regulären Ausdrücke und keine "Aufteilung in Ziffern und Buchstaben" oder so, also war das irgendwie schmerzhaft.

Probieren Sie es online!

Erläuterung

q      e# Read the input.
{      e# Do the following for every char c:
 i     e#  Get c's codepoint.
 64>   e#  Check if it's greater than 64 (i.e. if it's a letter), pushing 1 or 0.
 X     e#  Push X (variable predefined to 1).
 \:X   e#  Store whether c was a letter or digit into X.
 ^{    e#  If (old X) XOR (new X) is 1:
  ]    e#   Close the current array.
  )    e#   Pull out its last character.
  [    e#   Open a new array.
 }&    e#  (end if)
 c     e#  Turn the codepoint back into a character. This also shoves it into the new array, 
       e#  in case one was opened.
}/     e# (end for)
]      e# Close the final array, since it hasn't been closed yet.
]      e# Wrap the whole stack into an array.
2/     e# Split elements into groups of 2.
Wf%    e# Reverse each group.
       e# Implicitly flatten and print.

Gema , 11 Zeichen

<L><D>=$2$1

Probelauf:

bash-4.4$ gema '<L><D>=$2$1' <<< 'Em5sA55Ve777Rien'
5Em55sA777VeRien

Java 8, 38 Bytes

s->s.replaceAll("(\\D+)(\\d+)","$2$1")

Nicht viel zu erklären. Verwendet dieselbe Methode wie die Retina-Antwort von @Okx , die in Java nicht kürzer sein kann.

Probieren Sie es hier aus.

Japt, 18 Bytes

r"(%D+)(%d+)""$2$1

Probier es aus

Sed, 29 Bytes

s/([^0-9]+)([0-9]+)/\2\1/g

Führen Sie mit -r.

Verwendet Erfassungsgruppen und ersetzt sie in umgekehrter Reihenfolge.

Gelee , 12 Bytes

e€ØDŒg⁸ṁs2Ṛ€

Probieren Sie es online!

Erläuterung:

e€ØDŒg⁸ṁs2Ṛ€ Accepts a string
eۯD         Check if each char is in ['0'..'9']
    Œg       Split runs of 0s and 1s (respectively letter and digit runs)
      ⁸ṁ     Replace with input, keeping the split
        s2   Get pairs of runs, last left alone if letter run
          Ṛ€ Swap each pair

PHP, kein regulärer Ausdruck, 73 Bytes

for(;a&$c=$argn[$i++];$p=$c)$c<A?print$c:$s=($p<A?!print$s:$s).$c;echo$s;

Laufen Sie als Rohr mit -nRoder testen Sie es online .

Nervenzusammenbruch

for(;a&$c=$argn[$i++];  # loop through input
    $p=$c)                  # 2. remember character
    $c<A                    # 1. if digit
        ?print$c            # then print it
        :$s=($p<A           # else if previous character was digit
            ?!print$s           # then print and reset string
            :$s                 # else do nothing
        ).$c;                   # append current character to string
echo$s;                 # print remaining string

PHP , 45 Bytes

<?=preg_replace("#(\D+)(\d+)#","$2$1",$argn);

Probieren Sie es online!

C #, 71 Bytes

s=>System.Text.RegularExpressions.Regex.Replace(s,@"(\D+)(\d+)","$2$1")

Nur schade, dass reguläre Ausdrücke in C # so lang sind.

Probieren Sie es online!

Voll / Formatierte Version:

using System;

class P
{
    static void Main()
    {
        Func<string, string> f = s => System.Text.RegularExpressions.Regex.Replace(s, @"(\D+)(\d+)", "$2$1");

        Console.WriteLine(f("uV5Pt3I0"));
        Console.WriteLine(f("J0i0m8"));
        Console.WriteLine(f("abc256"));
        Console.WriteLine(f("Hennebont56Fr"));
        Console.WriteLine(f("Em5sA55Ve777Rien"));
        Console.WriteLine(f("nOoP"));

        Console.ReadLine();
    }
}

Clojure, 104 88 Bytes

Oh, Regex ist wirklich praktisch ... trotzdem ( TIO ):

#(apply str(flatten(map reverse(partition-all 2(partition-by(fn[i](< 47(int i)58))%)))))

partition-byAufteilen in aufeinanderfolgende Läufe basierend auf dem Rückgabewert dieser Funktion, partition-allAufteilen in Partitionen von 2 (die Paare, die wir austauschen werden), map reverseUmkehren dieser Läufe , flattenEntfernen der verschachtelten Listenstruktur und schließlich Ausgeben einer Zeichenfolge. Wennpartition stattdessen verwendet wurde partition-allund wir eine ungerade Anzahl von Stücken hatten, wurde der letzte verworfen.

Original verwendet ausführlich, aber lustig (juxt second first)und (set"0123456789")statt reverseund ASCII-Integer-Bereiche.

#(apply str(flatten(map(juxt second first)(partition-all 2(partition-by(comp not(set"0123456789"))%)))))

QuadR , 15 Bytes

(\D+)(\d+)
\2\1

Probieren Sie es online!

Erläuterung die Okx offen gestohlen wurde :

Dies ersetzt den regulären Ausdruck (\D+)(\d+)durch \2\1. Lassen Sie uns das aufschlüsseln, wenn Sie nicht wissen, was das bedeutet.

Das \Dbedeutet "Finde alles, was keine Zahl ist". \dbedeutet "Finde alles, was eine Zahl ist". Das +Zeichen bedeutet "Mindestens einmal übereinstimmen, aber versuchen Sie es so oft wie möglich". Die Klammern definieren eine Gruppe. Die erste Gruppe ist (\D+)und die zweite ist(\d+)

In der zweiten Zeile sagen wir, dass wir setzen möchten, was auch immer von der zweiten Gruppe abgeglichen wurde, gefolgt von dem, was von der ersten Gruppe abgeglichen wurde. Dies tauscht die Buchstaben- und Ziffernläufe effektiv aus.

PowerShell , 40 Byte

$args|%{$_ -replace '(\D+)(\d+)','$2$1'}

Probieren Sie es online!

PowerShell ist dafür ziemlich ideal, da es reguläres Suchen und Ersetzen unterstützt. Requisiten gehen zu @Okx für die Regex-Lösung.

Pip , 17 Bytes

aR-C+XL.C+XD{c.b}

Übernimmt die Eingabe als Befehlszeilenargument. Probieren Sie es online!

Erläuterung

Hierbei wird die Standardstrategie zum Ersetzen von Regex verwendet, die etwas Golf spielt.

Die Regex ist -C+XL.C+XD, die ausgewertet `(?i)([a-z]+)(\d+)`:

   XL       Preset regex variable for lowercase letter: `[a-z]`
  +         Apply + to the regex: `[a-z]+`
 C          Wrap the regex in a capturing group: `([a-z]+)`
-           Apply the case-insensitive flag: `(?i)([a-z]+)`
        XD  Preset regex variable for digit: `\d`
       +    Apply + to the regex: `\d+`
      C     Wrap the regex in a capturing group: `(\d+)`
     .      Concatenate the two regexes: `(?i)([a-z]+)(\d+)`

Die Ersetzung ist {c.b}eine Rückruffunktion, die die zweite Gruppe ( c) und die erste Gruppe ( b) verkettet . (Das erste Argument der Funktion aenthält die gesamte Übereinstimmung.)

Dies ist drei Bytes kürzer als die naive aR`(\D+)(\d+)``\2\1`.

Brainfuck , 98 Bytes

,[>>----[---->+<<<-[>]>]>>[.[[-]<]<<[-]+>>]<[[-<<<+>>>]<<<<[-<[<]>[.[-]>]]>[-<+>]>],]<[-]<[<]>[.>]

Probieren Sie es online!

Erläuterung

Dieses Programm verwaltet eine Reihe von Briefen, die noch nicht ausgegeben wurden, und gibt sie gegebenenfalls aus.

Der Schlüssel zu diesem Programm ist >>----[---->+<<<-[>]>]. Die drei Zellen rechts von der Eingabezelle beginnen bei Null. Wenn es sich bei der Eingabe um einen Codepunkt zwischen 1 und einschließlich 63 handelt, wird der Zeiger um eine Stelle nach rechts verschoben und die Eingabe zwei Stellen rechts von dieser neuen Position platziert. Andernfalls bewegt sich der Zeiger zwei Stellen nach rechts, die Zelle eine Stelle rechts von der neuen Position wird 63, und dieselbe 63 wird von der Eingabezelle subtrahiert. Dies unterteilt die Eingabe in Buchstaben (65-122) und Ziffern (48-57).

,[                       Take first input byte and start main loop
  >>                     Move two cells to the right
  ----[---->+<<<-[>]>]   (See above)
  >>                     Move two cells to the right
                         This cell contains the input if it was a digit, and 0 if input was a letter
  [                      If input was a digit:
   .                     Output digit immediately
   [[-]<]                Zero out digit and working cell
   <<[-]+>>              Set flag so we know later that we've output a digit
  ]
  <                      Move one cell left
                         This cell contains 63 if input was a letter, and 0 if input was a digit
  [                      If input was a letter:
   [-<<<+>>>]            Add 63 back to input letter
   <<<<                  Move to flag
   [                     If a digit has been output since the last letter read:
    -                    Clear flag
    <[<]>                Move to start of queue
    [.[-]>]              Output and clear all queued letters
   ]
   >[-<+>]>              Move input to end of queue
  ]
,]                       Repeat until no input remains
<[-]                     Clear flag if present
<[<]>                    Move to start of queue
[.>]                     Output all queued letters

Ruby , 31 Bytes

->x{x.gsub /(\D+)(\d+)/,'\2\1'}

Probieren Sie es online!

Mathematica, 129 Bytes

(n=NumberString;l=Length;s=Riffle[a=StringCases[#,n],b=StringSplit[#,n]];If[l@a==0,s=#,If[l@a<l@b,AppendTo[s,b[[-2;;]]]]];""<>s)&