Yalnızca alfasayısal ASCII karakterleri içeren ve bir harfle başlayan bir giriş dizesi verildiğinde, her harf çalışmasını aşağıdaki rakam çalıştırmasıyla değiştirin.

Bir çalışma , ardışık harf veya rakam dizisidir. Giriş dizesinin harflerle bitmesi durumunda, bu işlemin dokunulmadan bırakıldığını unutmayın.

Gözden geçirme örneği

Örneğin, girdi dizesi verildiğinde uV5Pt3I0:

1. Ayrı harfler ve rakamlar: uV 5 Pt 3 I 0
2. Koşu çiftlerini tanımlayın: (uV 5) (Pt 3) (I 0)
3. Koşu çiftlerini değiştirin: (5 uV) (3 Pt) (0 I)
4. Concatenate: 5uV3Pt0I

Örnekler

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

Bu kod golf yani bayt en kısa cevap kazanır. Açıklamalar teşvik edilir.

Jöle , 9 bayt

~ṠŒg⁸ṁṭ2/

Çevrimiçi deneyin!

Nasıl çalışır

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

Retina , 15 bayt

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

Bu normal ifade değiştirir (\D+)(\d+)ile $2$1. Bunun ne anlama geldiğini bilmiyorsanız bunu yıkalım.

\DAnlamına gelen 'bir sayı değil maç şey'. \d"sayı olan her şeyi eşleştir" anlamına gelir. +İşaret vasıtaları 'bir kez, en az bu maç ama mümkün olduğu kadar çok kez bunu maç denemek'. Köşeli ayraçlar bir grup tanımlar. İlk grup (\D+)ve ikinci grup(\d+)

İkinci satırda, ikinci grup tarafından eşleşen her şeyi, ardından ilk grup tarafından eşleşen her şeyi koymak istediğimizi söylüyoruz. Bu harf ve rakam çalışmalarını etkili bir şekilde değiştirir.

Çevrimiçi deneyin!

Haskell , 58 56 bayt

@Laikoni'ye 2 bayt tıraş ettiği için teşekkürler

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

Çevrimiçi deneyin!

Ungolfed:

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

JavaScript (ES6), 34 bayt

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

Dene

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 bayt

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

açıklama

     :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

Test takımı .

Python 2 , 49 bayt

Denediğim regex olmayan her çözüm daha uzundu. : P

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

Çevrimiçi deneyin!

Japt (v2.0a0), 16 bayt

q/(\d+/ ò mw c q

Çevrimiçi test edin!

Not: Bu kararsız bir alfadır, bu nedenle bu bağlantı koparsa, v1.4.4'te biraz daha uzun bir sürüm kullanabilirsiniz: Çevrimiçi test edin!

açıklama

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 bayt

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

CJam'ın regex'i yoktur ve "rakamlara ve harflere bölünür" veya başka bir şey yoktur, bu yüzden bu biraz acı vericiydi.

Çevrimiçi deneyin!

açıklama

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 karakter

<L><D>=$2$1

Örnek çalışma:

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

Java 8, 38 bayt

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

Açıklamak için fazla bir şey yok. @Okx'in Retina yanıtıyla aynı yöntemi kullanır ve bu Java'da daha kısa olamaz.

Burada deneyin.

Japt, 18 bayt

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

Dene

Sed, 29 bayt

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

-R ile çalıştır.

Yakalama gruplarını kullanır ve bunları ters sırada değiştirir.

Jöle , 12 bayt

e€ØDŒg⁸ṁs2Ṛ€

Çevrimiçi deneyin!

Açıklama:

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, normal ifade yok, 73 bayt

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

Pipo ile çalıştırın -nRveya çevrimiçi test edin .

Yıkmak

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 bayt

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

Çevrimiçi deneyin!

C #, 71 bayt

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

Sadece utanç verici C # ifadeleri çok uzun.

Çevrimiçi deneyin!

Tam / Biçimlendirilmiş sürüm:

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 bayt

Regex gerçekten kullanışlı ... neyse ( TIO ):

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

partition-bybu işlevin dönüş değerine dayalı olarak ardışık çalışmalara partition-allböler, 2 bölüme ayırır (değiştireceğimiz çiftler), map reversebunları tersine çevirir flatten, iç içe liste yapısından kurtulur ve sonunda bir dize çıkarırız. Eğerpartition yerine kullanılmıştır partition-allve biz o zaman sonuncusu atılacak topakları tek sayı vardı.

Orjinal kullanılan ayrıntılı ama eğlenceli (juxt second first)ve (set"0123456789")yerine reverseve aralıkları tamsayı ASCII.

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

QuadR , 15 bayt

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

Çevrimiçi deneyin!

Okx'tan açıkça çalınan açıklama :

Bu normal ifade değiştirir (\D+)(\d+)ile \2\1. Bunun ne anlama geldiğini bilmiyorsanız bunu yıkalım.

\DAnlamına gelen 'bir sayı değil maç şey'. \d"sayı olan her şeyi eşleştir" anlamına gelir. +İşaret vasıtaları 'bir kez, en az bu maç ama mümkün olduğu kadar çok kez bunu maç denemek'. Köşeli ayraçlar bir grup tanımlar. İlk grup (\D+)ve ikinci grup(\d+)

İkinci satırda, ikinci grup tarafından eşleşen her şeyi, ardından ilk grup tarafından eşleşen her şeyi koymak istediğimizi söylüyoruz. Bu harf ve rakam çalışmalarını etkili bir şekilde değiştirir.

PowerShell , 40 bayt

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

Çevrimiçi deneyin!

PowerShell bunun için oldukça idealdir, normal regex ara ve değiştir'i kutudan çıkardığını destekler. Regex çözümü için aksesuarlar @Okx'a gider .

Pip , 17 bayt

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

Girdiyi komut satırı bağımsız değişkeni olarak alır. Çevrimiçi deneyin!

açıklama

Bu, biraz golf oynayan standart normal ifade değiştirme stratejisini kullanır.

Normal ifade olduğu -C+XL.C+XDdeğerlendirilirse, hangi `(?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+)`

Bunun yerine, {c.b}ikinci grubu ( c) ve birinci grubu ( b) birleştiren bir geri arama işlevidir . (İşlevin ilk argümanı,a , tüm eşleşmeyi içerir.)

Bu, saftan üç bayt daha kısadır aR`(\D+)(\d+)``\2\1`.

beyin , 98 bayt

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

Çevrimiçi deneyin!

açıklama

Bu program henüz yazılmamış bir harf sırasını korur ve uygun olduğunda bunları çıkarır.

Bu programın anahtarı >>----[---->+<<<-[>]>]. Giriş hücresinin sağındaki üç hücre sıfırdan başlar. Giriş 1 ile 63 arasında bir kod noktasıysa, bu işaretçiyi bir boşluk sağa taşır ve girişi bu yeni konumun iki boşluğunun sağına yerleştirir. Aksi takdirde, işaretçi iki boşluk sağa hareket eder, yeni konumun bir boşluk sağındaki hücre 63 olur ve aynı 63 giriş hücresinden çıkarılır. Bu, girişi düzgün bir şekilde harflere (65-122) ve rakamlara (48-57) böler.

,[                       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 bayt

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

Çevrimiçi deneyin!

Mathematica, 129 bayt

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