Il y a l'encodage et le décodage classiques.

input   output
a3b2c5  aaabbccccc

Et c'est assez simple et fait avant.

Le défi consiste également à prendre en compte un comportement non standard lorsque plusieurs caractères précèdent la longueur d'exécution (un seul chiffre de 0 à 9). Chaque caractère avant le chiffre de la longueur d'exécution (le dernier chiffre avant un non-chiffre ou la fin de la chaîne) a cette valeur qui lui est appliquée individuellement et imprimé dans l'ordre.

Quelques entrées et sorties de test, y compris certains cas de bord:

input   output
ab3c5   aaabbbccccc
a0b3    bbb  
13b1    111b
a13b1   aaa111b
a123b1  aaa111222b
aa2a1b1 aaaaab

• Une séquence de caractères ( [a-zA-Z0-9]+) doit être suivie de sa longueur de longueur ( [0-9])
• Seule une entrée valide doit être prise en compte ( ([a-zA-Z0-9]+[0-9])*)
  • oui, une chaîne vide est une entrée valide.
• L'entrée se fait via une entrée standard, la sortie via une sortie standard

Il s'agit du code golf, le nombre d'octets détermine le gagnant.

Pip, 22 + 1 = 23 octets

Utilise le -rdrapeau. Notez que cela vous oblige à 1) entrer un EOF après l'entrée (Ctrl-D sous Linux, Ctrl-Z sous Windows) ou 2) diriger l'entrée depuis un autre endroit.

(^_@<v)X_@vMa@`\D*\d+`

Explication:

                        a is first line of stdin (from -r flag) and v is -1 (implicit)
              `\D*\d+`  Pattern (regex) object that matches zero or more non-digits
                        followed by at least one digit
            a@          Find all non-overlapping matches in a, returning a list of strings
           M            To that list, map a lambda function:
  _@<v                    Argument sans last character (equivalent to Python a[:-1])
(^    )                   Split into a list of characters
        _@v               Last character of argument
       X                  Repeat each character of the list that many times
                          (String multiplication X, like most operators, works item-wise
                          on lists)
                        Auto-print (implicit)

Le résultat de l'opération de mappage est en fait une liste de listes, mais par défaut, les listes sont simplement concaténées ensemble lors de l'impression, donc aucune conversion manuelle en chaîne n'est nécessaire.

Exemple, avec entrée a13b1:

Var a gets        "a13b1"
After regex match  ["a13" "b1"]
After map          [["aaa" "111"] ["b"]]
Final output       aaa111b

Pip a un support regex de base en date de ... il y a 2 jours . Bon timing!

Perl / Bash 54 40 + 1 = 41 octets

perl -pe's:(\D*\d*)(\d):"\$1=~s/./\$&x$2/egr":ege'

C'est fondamentalement une expression régulière dans une expression régulière. Et un peu de magie.

Explication

L'expression régulière externe /(\D*\d*)(\d)/gextrait chaque groupe codé de longueur d'exécution. Nous capturons les éléments à répéter $1et le nombre de répétitions $2. Maintenant, nous substituons chacun de ces groupes à l'expansion de ce groupe. Pour cela, nous évaluons le code "\$1=~s/./\$&x$2/egr" deux fois (comme par le /eedrapeau sur la substitution externe).

La première évaluation n'interpole que le nombre de répétitions dans la chaîne - les autres variables sont protégées par une barre oblique inverse. En supposant donc l'entrée a14, nous aurions maintenant le code $1=~s/./$&x4/egr, qui sera à nouveau évalué.

Cela appliquera la substitution au contenu de $1(le truc à répéter a1). La substitution correspond à chaque caractère .. La $&variable contient la correspondance entière, que nous répétons x4fois. Nous faisons cela de manière /globaire pour chaque correspondance et /rretournons la chaîne substituée plutôt que de modifier la $1variable (qui est en lecture seule). Le résultat de la substitution intérieure est donc aaaa1111.

L' -pindicateur applique la substitution à chaque ligne d'entrée et imprime le résultat.

CJam, 33 31 27 octets

Ughh, le manque d'expressions régulières rend cela assez long ...

qN+{:XA,s&L\:L>{])~e*[}&X}%

Comment ça fonctionne

Nous parcourons tous les caractères de la chaîne d'entrée et à chaque itération, gardons une trace du dernier caractère rencontré (en commençant par un caractère vide pour la première fois). Ensuite, nous vérifions si le caractère actuel n'est pas numérique et le dernier caractère est numérique. Si c'est le cas, nous répétons chaque caractère précédent (qui n'a pas déjà été répété), le nombre de fois.

(Expansion de code un peu dépassée)

q{                       }%        e# Read the input (q) and loop through each character
  L                                e# Put variable L (initially empty character) on stack
   A,                              e# Put variable A (equals 10) and create an array 0..9
     s                             e# Convert the array to string "0123456789"
      &                            e# Do a set intersect b/w previous char and 0-9 string
                                   e# If numeric, it gives 1 char string, otherwise 0
       \:LA,s&                     e# Swap to bring current character on top. Store it in L
                                   e# and do the same set intersect with it
              >                    e# Means we are checking that current char is non-numeric
                                   e# and previous numeric
               {      }&           e# Run this block if above is true
                ])~                e# Wrap everything not already repeated in an array and
                                   e# take out the last character and convert it to integer.
                                   e# This is the run length of the preceding string
                   e*              e# Repeat each character in the string, run length times
                     [             e# Start a new array to help when next run length is found
                        L          e# Restore the current character back on stack to be used
                                   e# in next iteration
                           )~e*    e# The last string-run-length pair is not decoded..
                                   e# So we do that now

Essayez-le en ligne ici

rs , 43 71 caractères

Eh bien, cela a tourné longtemps rapidement. Des nombres stupides ...

(\d)(\D)/\1 \2
+(\w)(\w+?)(\d)(?= |$)/\1\3 \2\3
(\w)(\d)/(\1)^^(\2)
 /

Essayez-le ici!

Version originale (ne fonctionnait pas avec une entrée comme 123):

+(\D)(\D+)(\d)/\1\3\2\3
(\D)(\d)/(\1)^^(\2)

Explication

Les premiers espaces de lieux de ligne entre séries contenant des nombres, par exemple transformer a313ena3 13 .

La deuxième ligne développe en continu les encodages compressés comme aa5poura5a5 .

La troisième ligne convertit chaque instance de a5en aaaaautilisant l' opérateur de répétition .

La dernière ligne supprime les espaces.

Javascript ( ES6 ), 86 83 octets

alert(prompt().replace(/(.+?)(\d)(?!\d)/g,(a,b,c)=>b.replace(/./g,y=>y.repeat(c))))

Commenté:

alert( // output final result
    prompt(). // take input
    replace(/(.+?)(\d)(?!\d)/g, // replace ungreedy capture group of any characters 
                                // followed by a digit (captured)
                                // and not followed by a digit (negative lookahead)
        (a, b, c)=> // replace with a function
            b.replace(/./g, // replace all characters in b
                y=>y.repeat(c) // with that character repeated c times
            )
    )
)

CJam, 27 25 octets

r_'A+1>.{64&1$>{])~f*o}&}

Essayez-le en ligne dans l' interpréteur CJam .

Comment ça fonctionne

r_                        e# Read a token from STDIN and push a copy.
  'A+                     e# Append the character A to the copy.
     1>                   e# Discard the first character of the copy.
       .{               } e# For each character C of the input string and the
                          e# corresponding character D of the copy:
         64&              e#   Take the bitwise and of D and 64. This pushes @
                          e#   if D is a letter and NUL if it is a digit.
            1$>           e#   Compare the result to a copy of C. This pushes 1
                          e#   if and only if D is a letter and C is a digit.
               {      }&  e#   If the result was 1, do the following:
                ]         e#     Wrap the stack in an array.
                 )~       e#     Pop and evaluate the last character.
                   f*     e#     Repeat each char in the array that many times.
                     o    e#     Print all characters.

Pyth, 33 32 28 octets

ssmm*vedkPdPcz-hMJf<@zT\=UzJ

Essayez-le en ligne: démonstration ou test de harnais

Explication

Je vais expliquer le code en utilisant l'exemple d'entrée aa1a23b2. J'espère que c'est un peu plus facile à suivre que sans.

                               implicit: z = input string = 'aa1a23b2'
                         Uz    the indices of z: [0, 1, 2, 4, 5, 6, 7]
                  f            filter for indices T, which satisfy:
                   <@zT\=        z[T] < "="
                               this gives us the list of indices [2, 4, 5, 7], 
                               which correspond to digits in z. 
                 J             assignment, J = [2, 4, 5, 7]
               hMJ             increment all element in J: [3, 5, 6, 8]
              -            J   and remove the elements of J:
                                 [3, 5, 6, 8] - [2, 4, 5, 7] = [3, 6, 8]
            cz                 split z at these indices: ['aa1', 'a23', 'b2', '']
           P                   remove last element: ['aa1', 'a23', 'b2']
  m                            map each string d to:
   m     Pd                      map each string k of d-without-last-char to:
     ved                           int(last element of d)
    *   k                          * k
                               this creates [['a', 'a'], ['aaa', '222'], ['bb']]
 s                             sum the lists: ['a', 'a', 'aaa', '222', 'bb']
s                              sum the strings: 'aaaaa222bb'

Rubis 73

gets.split(/(\d)(?!\d)/).each_slice(2){|s,i|s.chars.map{|c|$><<c*i.to_i}}

Tests: http://ideone.com/L1fssb

JavaScript 112

alert(prompt().replace(/.*?\d+/g,function(m){for(i=n=m.length-1,o="";i--;){j=m[n];while(j--)o=m[i]+o}return o}))

Python 2.7, 98 octets

import re
print"".join(c*int(m[-1])for m in 
re.findall(r".+?\d(?!\d)",raw_input())for c in m[:-1])

Cela fait juste une recherche regex simple pour les chiffres qui ne sont pas suivis par un chiffre, puis fait l'arithmétique des chaînes sur chaque groupe et les regroupe tous.

Julia, 105 99 95 87 octets

s->join([join([string(b)^(int(p[end])-48)for b=chop(p)])for p=matchall(r"\D*\d*\d",s)])

Cela crée une fonction sans nom qui prend une chaîne en entrée et renvoie une chaîne. Pour l'appeler, donnez-lui un nom, par exemple f=s->....

Deux compréhensions de tableau sont utilisées ici, l'une imbriquée dans l'autre. La compréhension externe agit sur chaque correspondance de la chaîne d'entrée contre l'expression régulière\D*\d*\d . La compréhension intérieure répète chaque caractère de la correspondance en fonction du chiffre de fin. Les éléments du tableau interne sont joints en une chaîne, donc le tableau externe est un tableau de chaînes. Ceux-ci sont joints et retournés.

Dans Julia, les chaînes peuvent être traitées comme des tableaux de caractères. Cependant, notez que les types Charet Stringdans Julia n'ont pas les mêmes méthodes définies; en particulier, il n'y a pas de méthode de répétition utilisant ^des caractères for. Cela utilise une solution de contournement:

• Faites une boucle sur la chaîne en omettant le dernier caractère, qui est supprimé à l'aide de chop() .
• Convertissez le caractère actuel en chaîne à l'aide de string() .
• Convertissez le dernier chiffre, qui est également un caractère, en entier. Cependant, notez que, par exemple,int('4') ne renvoie pas 4. Il renvoie plutôt le point de code, qui dans ce cas est 52. Ainsi, nous pouvons soustraire 48 pour récupérer l'entier réel.
• Répétez string(b)selon int(p[end]) - 48.

Exemples:

julia> f("ab3c5")
"aaabbbccccc"

julia> f("a0b3")
"bbb"

julia> f("13b1")
"111b"

Python 3, 148 144 136 135 135 octets

w,o,r,d=''.join,'',[],[]
for c in input()+' ':
 if'/'<c<':':d+=[c]
 elif d:o+=w(x*int(w(d))for x in r);r=[c];d=[]
 else:r+=[c]
print(o)

Merci à Pietu1998 et mbomb007 pour les suggestions.

Python 2, 161 151 147 147 139 138 octets

Peut-être que la journée d'aujourd'hui a été longue au travail, mais je n'arrive pas à comprendre comment jouer au golf.

w,o,r,d=''.join,'',[],[]
for c in raw_input()+' ':
 if'/'<c<':':d+=[c]
 elif d:o+=w(x*int(w(d))for x in r);r=[c];d=[]
 else:r+=[c]
print o

Java 7, 175 octets

String c(String s){String r="",a[];for(String x:s.split("(?<=(\\d)(?!\\d))")){a=x.split("");for(int i=0,j,l=a.length-1;i<l;i++)for(j=0;j++<new Short(a[l]);r+=a[i]);}return r;}

Le défi est plus difficile qu'il n'y paraît, imo ..

Code non testé et testé:

Essayez-le ici.

class M{
  static String c(String s){
    String r = "",
           a[];
    for(String x : s.split("(?<=(\\d)(?!\\d))")){
      a = x.split("");
      for(int i = 0, j, l = a.length-1; i < l; i++){
        for(j = 0; j++ < new Short(a[l]); r += a[i]);
      }
    }
    return r;
  }

  public static void main(String[] a){
    System.out.println(c("ab3c5"));
    System.out.println(c("a0b3"));
    System.out.println(c("13b1"));
    System.out.println(c("a13b1"));
    System.out.println(c("a123b1"));
    System.out.println(c("aa2a1b1"));
    System.out.println(c("123"));
  }
}

Production:

aaabbbccccc
bbb
111b
aaa111b
aaa111222b
aaaaab
111222