Un desafío bastante simple: recibirá dos entradas, una cadena y un número (el número puede tomarse como una cadena, es decir, en "123"lugar de 123)

Si la cadena no termina en un número (es decir, no coincide con la expresión regular \d$), simplemente agregue el número al final de la cadena.

Si la cadena termina en un número (es decir, coincide con la expresión regular) \d+$ ), primero debe eliminar eso y luego agregar el número.

Ninguna de las entradas será inválida o vacía (inválida se define por la entrada numérica que no contiene solo dígitos)

El número nunca contendrá a -o a. .

La cadena nunca contendrá una nueva línea o caracteres no imprimibles que no sean espacios en blanco.

Casos de prueba:

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

Retina , 5 bytes

\d*¶

Toma dos cadenas como entrada, separadas por una nueva línea.

Pruébalo en línea!

Python 2 , 30 bytes

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

Pruébalo en línea!

PHP, 37 36 35 33 bytes

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

Guardado 1 byte gracias a Jörg Hülsermann .

Perl 5, 12 bytes

Código de 11 bytes + 1 para -p.

s/\d*$/<>/e

Pruébalo en línea!

Java 8, 32 bytes

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

Toma la entrada acomo una Cadena, y para bello no importa si es una Cadena o un entero (aunque uso Integer en el enlace TIO a continuación).

Pruébalo aquí.

Python 2 , 32 bytes

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

Pruébalo en línea!

Toma las entradas en orden inverso, ambas como cadena.

05AB1E , 9 bytes

DvTFNÜ}}«

Pruébalo en línea! Probablemente sea una mala solución, pero es lo mejor que se me ocurrió.

Explicación

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

Japt , 10 bytes

r"%d*$" +V

Pruébalo en línea!

 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 bytes

EDITAR: -4 bytes gracias a @Dom Hastings. No uso muchas expresiones regulares.

EDITAR 2 : -2 bytes gracias a @totallyhuman señalando que el número podría tomarse como una cadena

Tenía que esperarse ...

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

Simplemente elimina los dígitos al final de la cadena y agrega el número

Pruébalo en línea!

Pip , 9 7 bytes

a<|XD.b

¡@DLosc me ahorró 2 bytes!

Pruébalo en línea!

Explicación

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.

Jalea , 5 bytes

œrØD;

Pruébalo en línea!

Cómo funciona

œ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 bytes

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

• ¡1 byte guardado gracias a que Neil me recuerda por qué no debería jugar golf temprano en la mañana!

Ruby , 21 bytes

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

Toma dos cadenas de entrada.

Pruébalo en línea!

C #, 45 bytes

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

Explicación:

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 bytes

óä*î

Pruébalo en línea!

Utiliza la misma expresión regular que la respuesta de Retina anterior:

s:/\d*\n//

Perl 6 , 20 bytes

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

Tcl 32 bytes

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

No estoy seguro de la interfaz esperada. Esto se realiza como un procedimiento que acepta las dos entradas como argumentos de llamada. Para convertirlo en un script independiente que lea la entrada de stdin y envíe el resultado a stdout, se necesitaría la línea adicional:

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

o lo haría todo "en línea":

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

regsub toma un RE, la cadena original y una cadena para reemplazar la parte correspondiente.

Mathematica, 48 bytes

Ya existe una solución de Mathematica (84 bytes).

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

Zanahoria , 16 21 bytes

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

Pruébalo en línea!(la entrada está separada de salto de línea)

Explicación

$^                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

Tuve que aumentar el bytecount en 5 porque el código no funcionaba para casos de prueba como a5b3con varios dígitos.

Haskell, 75 bytes 95 bytes 91 79 61 bytes

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

Intenté hacer esto sin expresiones regulares, así que tal vez esa sería una respuesta dramáticamente mejorada. También hay un par de maneras en que podría hacerlo, así que no estoy seguro si puedo reducir algunos bytes con un enfoque diferente.

ACTUALIZACIÓN: subí en bytes porque me di cuenta de que estaba fallando el caso de prueba donde existen números en la cadena que no son el sufijo. Ahora estoy seguro de que regex proporcionaría una respuesta mucho mejor.

ACTUALIZACIÓN2: ¡Después de algunos comentarios excelentes, se jugaron más bytes!

Mathematica, 84 bytes

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

entrada 2 cuerdas

["ab3d5", "55"]

salida

ab3d55

C (gcc) , 99 98 96 95 bytes

Debería poder jugar golf un poco ...

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]);}

Pruébalo en línea!

Noether , 11 bytes

I"\d+$"-I+P

Pruébalo aquí!

Al ingresar una cadena, escríbala entre comillas

Explicación:

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 bytes

DþRvyÜ}«

Pruébalo en línea!

Explicación:

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.