Un défi assez simple: vous recevrez deux entrées, une chaîne et un nombre (le nombre peut être pris comme une chaîne, c'est-à-dire "123"au lieu de 123)

Si la chaîne ne se termine pas par un nombre (c'est-à-dire qu'elle ne correspond pas à l'expression régulière \d$), ajoutez simplement le nombre à la fin de la chaîne.

Si la chaîne se termine par un nombre (c'est-à-dire qu'elle correspond à l'expression régulière \d+$), vous devez d'abord le supprimer, puis ajouter le numéro.

Aucune des entrées ne sera jamais invalide ou vide (invalide est défini par l'entrée numérique ne contenant que des chiffres)

Le numéro ne contiendra jamais a -ou a ..

La chaîne ne contiendra jamais de nouvelle ligne ou de caractères non blancs non imprimables.

Cas de test:

abc123 + 345 -> abc345
123 + 1 -> 1
hello + 33 -> hello33
123abc123 + 0 -> 123abc0
ab3d5 + 55 -> ab3d55
onetwo3 + 3 -> onetwo3
99ninenine + 9999 -> 99ninenine9999

Rétine , 5 octets

\d*¶

Prend deux chaînes en entrée, séparées par une nouvelle ligne.

Essayez-le en ligne!

Python 2 , 30 octets

lambda a,b:a.rstrip(`56**7`)+b

Essayez-le en ligne!

PHP, 37 36 35 33 octets

<?=chop($argv[1],3**39),$argv[2];

1 octet enregistré grâce à Jörg Hülsermann .

Perl 5, 12 octets

Code de 11 octets + 1 pour -p.

s/\d*$/<>/e

Essayez-le en ligne!

Java 8, 32 octets

a->b->a.replaceAll("\\d*$","")+b

Prend l'entrée en atant que chaîne, et bpeu importe qu'il s'agisse d'une chaîne ou d'un entier (bien que j'utilise Integer dans le lien TIO ci-dessous).

Essayez-le ici.

Python 2 , 32 octets

import re
re.compile("\d*$").sub

Essayez-le en ligne!

Prend les entrées dans l'ordre inverse, toutes deux sous forme de chaîne.

05AB1E , 9 octets

DvTFNÜ}}«

Essayez-le en ligne! Probablement une mauvaise solution mais c'est le mieux que je puisse trouver

Explication

DvTFNÜ}}«
Dv     }  # For each character in input1
  TF  }   # 10 times
    NÜ    # Get 0-9 and trim it from input1
        « # Concatenate with input2

Japt , 10 octets

r"%d*$" +V

Essayez-le en ligne!

 r"%d*$" +V
Ur"%d*$" +V # Implicit input (U and V)
 r          # Remove
  "%d*$"    #   any trailing digits
U           #   from the first input
         +V # And append the second input
            # Implicit output

Python 2 , 44 41 39 octets

EDIT: -4 octets grâce à @Dom Hastings. Je n'utilise pas beaucoup d'expressions régulières.

EDIT 2 : -2 octets grâce à @totallyhuman soulignant que le nombre peut être pris comme une chaîne

Il fallait s'y attendre ...

lambda x,y:re.sub("\d*$",y,x)
import re

Supprime simplement les chiffres à la fin de la chaîne et ajoute le nombre

Essayez-le en ligne!

Pip , 9 7 octets

a<|XD.b

@DLosc m'a sauvé 2 octets!

Essayez-le en ligne!

Explication

a<|         Strip all matches off the end of 'a' (the first cmd line arg)
   XD         of the pattern \d (ordinarily, a regex would be entered as '\d', but digits 
              have a pre-existing constant XD)
     .b     Then concatenate 'b' (the second cmd line arg)
            PIP implicitly prints the results of the last operation.

Gelée , 5 octets

œrØD;

Essayez-le en ligne!

Comment ça fonctionne

œrØD;  Main link. Left argument: s. Right argument: t

  ØD   Digits; yield "0123456789".
œr     Trim these characters from the right of s.
    ;  Append t.

JavaScript (ES6), 28 26 25 octets

x=>y=>x.replace(/\d*$/,y)

• 1 octet économisé grâce à Neil me rappelant pourquoi je ne devrais pas jouer au golf tôt le matin!

Rubis , 21 octets

->a,b{a=~/\d*$/;$`+b}

Prend deux chaînes en entrée.

Essayez-le en ligne!

C #, 45 octets

s=>n=>s.TrimEnd("0123456789".ToCharArray())+n

Explication:

s=>n=>                                        // Take input
      s.TrimEnd(                              // Trim the end of the string with the specified chars
                "0123456789"                  // Create a string of the digits
                            .ToCharArray())   // Turn the string into a char array
                                           +n // Append the integer onto the end

V , 7 4 octets

óä*î

Essayez-le en ligne!

Cela utilise le même regex que la réponse Retina ci-dessus:

s:/\d*\n//

Perl 6 , 20 octets

->$_,\n{S/\d*$/{n}/}

Tcl 32 octets

proc s a\ b {regsub \\d*$ $a $b}

Je ne suis pas sûr de l'interface attendue. Cela se fait comme une procédure qui accepte les deux entrées comme arguments d'appel. Pour le transformer en un script autonome qui lit les entrées de stdin et renvoie le résultat vers stdout, il faudrait la ligne supplémentaire:

puts [s [gets stdin] [gets stdin]]

ou ferait tout "en ligne":

puts [regsub \\d*$ [gets stdin] [gets stdin]]

regsub prend un RE, la chaîne d'origine et une chaîne pour remplacer la partie correspondante.

Mathematica, 48 octets

Il existe déjà une solution Mathematica (84 octets).

StringDrop[StringTrim["."<>#,_?DigitQ..]<>#2,1]&

Carotte , 16 21 octets

$^//^.*?(?=\d*$)/S0^#

Essayez-le en ligne!(l'entrée est séparée par un saut de ligne)

Explication

$^                Set the stack-string to be equal to the first line in the input
/                 Set the stack-array to be equal to the matches of this regex:
 /^.*?(?=\d*$)/   The beginning of the string followed by non-digit characters at the end that are not included in the match.
S0                Convert to a string with 0 as the delimiter
^#                Append the rest of the input to the stack-string

J'ai dû augmenter le bytecount de 5 car le code ne fonctionnait pas pour les cas de test comme a5b3avec plusieurs chiffres.

Haskell, 75 octets 95 octets 91 79 61 octets

b=(`notElem`['0'..'9'])
r=reverse
d#e=r(snd$break b$r d)++e

J'ai essayé de le faire sans regex, alors ce serait peut-être une réponse considérablement améliorée. Il y a aussi quelques façons de procéder, donc je ne sais pas si je peux raser quelques octets avec une approche différente.

MISE À JOUR: J'ai augmenté en octets parce que j'ai réalisé que j'échouais le cas de test où des nombres existent dans la chaîne qui ne sont pas le suffixe. Maintenant, je suis sûr que l'expression régulière fournirait une bien meilleure réponse.

UPDATE2: Après quelques bons commentaires, plus d'octets ont été joués!

Mathematica, 84 octets

(k=#;T=ToCharacterCode;L=T@k;While[47<Last@L<58,w=k~StringDrop~-1;k=w;L=T@w];w<>#2)&

entrée 2 chaînes

["ab3d5", "55"]

production

ab3d55

C (gcc) , 99 98 96 95 octets

Devrait être en mesure de jouer au golf un peu ...

main(c,v)char**v;{for(c=strlen(v[1]);~c*isdigit(v[1][--c]);v[1][c]=0);printf(v[1]),puts(v[2]);}

Essayez-le en ligne!

Noether , 11 octets

I"\d+$"-I+P

Essayez-le ici!

Lorsque vous entrez une chaîne, placez-la entre guillemets

Explication:

I       - Push input to stack
"\d+$"  - Push string to stack
-       - Remove characters from first string which match the regex
I       - Push input to stack
+       - Append to the first string
P       - Print top item of stack

05AB1E , 8 octets

DþRvyÜ}«

Essayez-le en ligne!

Explication:

DþRvyÜ}«
D        Duplicate input.
 þ       Get the digits of the input.
  R      Reverse the digits of the input.
   v  }  For each of the digits in the input:
    y        Push the current digit
     Ü       Trim that from the right of the input.
       « Concatenate to 2nd input.