Đưa ra một chuỗi đầu vào chỉ chứa các ký tự ASCII chữ và số và bắt đầu bằng một chữ cái, hoán đổi mỗi chữ cái chạy với chữ số chạy theo sau.

Một chạy là một chuỗi các ký tự liên tiếp hoặc chữ số. Lưu ý rằng trong trường hợp chuỗi đầu vào kết thúc bằng một dòng chữ, thì lần chạy này không bị ảnh hưởng.

Ví dụ đi bộ

Chẳng hạn, đưa ra chuỗi đầu vào uV5Pt3I0:

1. Các chữ cái và chữ số riêng biệt: uV 5 Pt 3 I 0
2. Xác định các cặp chạy: (uV 5) (Pt 3) (I 0)
3. Hoán đổi các cặp chạy: (5 uV) (3 Pt) (0 I)
4. Kết hợp: 5uV3Pt0I

Ví dụ

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

Đây là môn đánh gôn, vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng. Giải thích được khuyến khích.

Thạch , 9 byte

~ṠŒg⁸ṁṭ2/

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

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

~ṠŒ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.

Võng mạc , 15 byte

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

Điều này thay thế cho regex (\D+)(\d+) bằng $2$1. Hãy phá vỡ nó nếu bạn không biết điều đó có nghĩa là gì.

Có \Dnghĩa là 'khớp với bất cứ thứ gì không phải là số'. \dcó nghĩa là 'khớp mọi thứ là một số'. Các +phương tiện dấu 'phù hợp này ít nhất một lần nhưng cố gắng để phù hợp với nó nhiều lần càng tốt'. Dấu ngoặc xác định một nhóm. Nhóm thứ nhất là (\D+)và nhóm thứ hai là(\d+)

Trong dòng thứ hai, chúng tôi nói rằng chúng tôi muốn đặt bất cứ thứ gì phù hợp với nhóm thứ hai, tiếp theo là bất cứ thứ gì phù hợp với nhóm thứ nhất. Điều này có hiệu quả hoán đổi chữ và chữ số chạy.

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

Haskell , 58 56 byte

Cảm ơn @Laikoni đã cạo sạch 2 byte

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

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

Ung dung:

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

Thử nó

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>

Bình thường , 15 byte

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

Giải trình

     :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

Bộ thử nghiệm .

Python 2 , 49 byte

Mọi giải pháp phi regex tôi đã thử là lâu hơn. : P

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

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

Japt (v2.0a0), 16 byte

q/(\d+/ ò mw c q

Kiểm tra nó trực tuyến!

Lưu ý: đây là bản alpha không ổn định, vì vậy nếu liên kết này bị hỏng, bạn có thể sử dụng phiên bản dài hơn một chút trong v1.4.4: Kiểm tra trực tuyến!

Giải trình

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 byte

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

CJam không có regex và không "chia thành chữ số và chữ cái" hoặc không có gì, vì vậy điều này thật đau đớn.

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

Giải trình

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 ký tự

<L><D>=$2$1

Chạy mẫu:

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

Java 8, 38 byte

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

Không có nhiều để giải thích. Sử dụng phương pháp tương tự như câu trả lời Retina của @Okx , không thể ngắn hơn trong Java.

Hãy thử nó ở đây.

Japt, 18 byte

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

Kiểm tra nó

Sed, 29 byte

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

Chạy với -r.

Sử dụng các nhóm chụp và thay thế chúng theo thứ tự ngược lại.

Thạch , 12 byte

e€ØDŒg⁸ṁs2Ṛ€

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

Giải trình:

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, không có regex, 73 byte

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

Chạy như ống với -nRhoặc kiểm tra nó trực tuyến .

phá vỡ

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 byte

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

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

C #, 71 byte

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

Chỉ là một biểu thức thông thường xấu hổ là rất dài trong C #.

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

Phiên bản đầy đủ / được định dạng:

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 byte

Oh regex thực sự tiện dụng ... dù sao đi nữa ( TIO ):

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

partition-bychia thành các lần chạy liên tiếp dựa trên giá trị trả về của hàm đó, partition-allchia thành các phân vùng 2 (các cặp chúng ta sẽ hoán đổi), map reverseđảo ngược chúng, flattenthoát khỏi cấu trúc danh sách lồng nhau và cuối cùng chúng ta sẽ xuất ra một chuỗi. Nếu partitionđược sử dụng thay vìpartition-all và chúng tôi có số lượng lẻ thì số cuối cùng sẽ bị loại bỏ.

Bản gốc được sử dụng dài dòng nhưng thú vị (juxt second first)và (set"0123456789")thay vì reversephạm vi số nguyên ASCII.

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

QuadR , 15 byte

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

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

Giải thích bị đánh cắp trắng trợn từ Okx :

Điều này thay thế regex(\D+)(\d+) bằng \2\1. Hãy phá vỡ nó nếu bạn không biết điều đó có nghĩa là gì.

Có \Dnghĩa là 'khớp với bất cứ thứ gì không phải là số'. \dcó nghĩa là 'khớp mọi thứ là một số'. Các +phương tiện dấu 'phù hợp này ít nhất một lần nhưng cố gắng để phù hợp với nó nhiều lần càng tốt'. Dấu ngoặc xác định một nhóm. Nhóm thứ nhất là (\D+)và nhóm thứ hai là(\d+)

Trong dòng thứ hai, chúng tôi nói rằng chúng tôi muốn đặt bất cứ thứ gì phù hợp với nhóm thứ hai, tiếp theo là bất cứ thứ gì phù hợp với nhóm thứ nhất. Điều này có hiệu quả hoán đổi chữ và chữ số chạy.

PowerShell , 40 byte

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

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

PowerShell khá lý tưởng cho việc này, vì thấy rằng nó hỗ trợ regex tìm kiếm và thay thế ngoài hộp. Đạo cụ đi đến @Okx cho giải pháp regex.

Pip , 17 byte

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

Đưa đầu vào làm đối số dòng lệnh. Hãy thử trực tuyến!

Giải trình

Điều này sử dụng chiến lược thay thế regex tiêu chuẩn, hơi bị đánh gôn.

Regex là -C+XL.C+XD, đánh giá `(?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+)`

Sự thay thế là {c.b}, một hàm gọi lại nối liền nhóm thứ hai ( c) và nhóm thứ nhất ( b). (Đối số đầu tiên cho hàm a, chứa toàn bộ khớp.)

Đây là ba byte ngắn hơn ngây thơ aR`(\D+)(\d+)``\2\1`.

cân não , 98 byte

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

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

Giải trình

Chương trình này duy trì một hàng các chữ cái chưa được xuất ra và xuất chúng khi thích hợp.

Chìa khóa của chương trình này là >>----[---->+<<<-[>]>]. Ba ô bên phải của ô nhập vào bắt đầu từ 0. Nếu đầu vào là một điểm mã nằm trong khoảng từ 1 đến 63, thì điều này sẽ di chuyển con trỏ sang một khoảng trắng và đặt hai khoảng trắng bên phải của vị trí mới này. Mặt khác, con trỏ di chuyển hai khoảng trắng bên phải, ô một không gian bên phải của vị trí mới trở thành 63 và cùng 63 được trừ khỏi ô đầu vào. Điều này gọn gàng phân chia đầu vào thành các chữ cái (65-122) và chữ số (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 byte

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

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

Toán học, 129 byte

(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)&