Если задана входная строка, содержащая только буквенно-цифровые символы ASCII и начинающаяся с буквы, поменяйте местами каждую букву на следующую цифру.

Перспектива представляет собой последовательность из последовательных букв или цифр. Обратите внимание, что в случае, когда строка ввода заканчивается набором букв, этот цикл остается без изменений.

Пример прохождения

Например, учитывая входную строку uV5Pt3I0:

1. Отдельные серии букв и серий цифр: uV 5 Pt 3 I 0
2. Определите пары трасс: (uV 5) (Pt 3) (I 0)
3. Обмен парами трасс: (5 uV) (3 Pt) (0 I)
4. Объединить: 5uV3Pt0I

Примеры

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

Это код-гольф, поэтому выигрывает самый короткий ответ в байтах. Пояснения приветствуются.

Желе , 9 байт

~ṠŒg⁸ṁṭ2/

Попробуйте онлайн!

Как это устроено

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

Сетчатка , 15 байт

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

Это заменяет регулярное выражение (\D+)(\d+)с $2$1. Давайте разберемся с этим, если вы не знаете, что это значит.

\DСопоставляют все , что не является числом "означает. \dозначает «соответствовать всему, что является числом». В +знак означает "соответствовать этому по крайней мере один раз , но попытаться соответствовать его столько раз , сколько это возможно. Скобки определяют группу. Первая группа, (\D+)а вторая(\d+)

Во второй строке мы говорим, что хотим поместить то, что было сопоставлено второй группой, а затем то, что было сопоставлено первой группой. Это эффективно меняет буквы и цифры.

Попробуйте онлайн!

Haskell , 58 56 байт

Спасибо @Laikoni за то, что сбрил 2 байта

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

Попробуйте онлайн!

Ungolfed:

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

JavaScript (ES6), 34 байта

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

Попытайся

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 байт

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

объяснение

     :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

Тестовый пакет .

Python 2 , 49 байт

Каждое нерегулярное решение, которое я пробовал, было длиннее. :П

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

Попробуйте онлайн!

Japt (v2.0a0), 16 байт

q/(\d+/ ò mw c q

Проверьте это онлайн!

Примечание: это нестабильная альфа, поэтому, если эта ссылка не работает, вы можете использовать более длинную версию в v1.4.4: протестируйте ее онлайн!

объяснение

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 байт

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

У CJam нет регулярных выражений и «разбитых на цифры и буквы» или еще много чего, так что это было довольно болезненно.

Попробуйте онлайн!

объяснение

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.

Гема , 11 персонажей

<L><D>=$2$1

Образец прогона:

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

Java 8, 38 байт

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

Не так много, чтобы объяснить. Использует тот же метод, что и ответ Retina @Okx , который не может быть короче в Java.

Попробуй это здесь.

Japt, 18 байт

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

Проверь это

Sed, 29 байт

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

Запустите с -r.

Использует группы захвата и заменяет их в обратном порядке.

Желе , 12 байт

e€ØDŒg⁸ṁs2Ṛ€

Попробуйте онлайн!

Объяснение:

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, без регулярных выражений, 73 байта

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

Беги как труба с -nR или проверьте это онлайн .

сломать

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 байт

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

Попробуйте онлайн!

C #, 71 байт

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

Просто позор регулярных выражений так долго в C #.

Попробуйте онлайн!

Полная / Отформатированная версия:

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 байт

О, регулярное выражение действительно удобно ... во всяком случае ( TIO ):

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

partition-byразбивается на последовательные запуски, основанные на возвращаемом значении этой функции, partition-allразбивается на части по 2 (пары, которые мы поменяем местами), map reverseпереворачивает их, flattenизбавляется от структуры вложенного списка, и, наконец, мы выводим строку. Если partitionбыл использован вместоpartition-all нечетное количество кусков, то последний отбрасывается.

Оригинал использовал многословный, но забавный (juxt second first)и (set"0123456789")вместо reverseцелочисленных диапазонов ASCII.

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

QuadR , 15 байт

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

Попробуйте онлайн!

Пояснения, явно украденные у Okx :

Это заменяет регулярное выражение (\D+)(\d+)с \2\1. Давайте разберемся с этим, если вы не знаете, что это значит.

\DСопоставляют все , что не является числом "означает. \dозначает «соответствовать всему, что является числом». В +знак означает "соответствовать этому по крайней мере один раз , но попытаться соответствовать его столько раз , сколько это возможно. Скобки определяют группу. Первая группа, (\D+)а вторая(\d+)

Во второй строке мы говорим, что хотим поместить то, что было сопоставлено второй группой, а затем то, что было сопоставлено первой группой. Это эффективно меняет буквы и цифры.

PowerShell , 40 байт

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

Попробуйте онлайн!

PowerShell идеально подходит для этого, поскольку он поддерживает поиск и замену регулярных выражений «из коробки». Реквизиты идут в @Okx для решения регулярных выражений.

Пип , 17 байт

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

Принимает ввод в качестве аргумента командной строки. Попробуйте онлайн!

объяснение

Здесь используется стандартная стратегия замены регулярных выражений, в некотором роде играющая в гольф.

Регулярное выражение -C+XL.C+XD, которое оценивает `(?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+)`

Замена - {c.b}функция обратного вызова, которая объединяет вторую группу ( c) и первую группу ( b). (Первый аргумент функции a, содержит полное совпадение.)

Это на три байта короче, чем наивный aR`(\D+)(\d+)``\2\1`.

брейкфук , 98 байт

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

Попробуйте онлайн!

объяснение

Эта программа поддерживает очередь букв, которые еще не были выведены, и выводит их при необходимости.

Ключ к этой программе >>----[---->+<<<-[>]>]. Три ячейки справа от входной ячейки начинаются с нуля. Если ввод является кодовой точкой от 1 до 63 включительно, это перемещает указатель на один пробел вправо и помещает входные два пробела справа от этой новой позиции. В противном случае указатель перемещается на два пробела вправо, ячейка на один пробел справа от новой позиции становится 63, и те же 63 вычитаются из входной ячейки. Это аккуратно делит ввод на буквы (65-122) и цифры (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

Рубин , 31 байт

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

Попробуйте онлайн!

Mathematica, 129 байт

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