Um desafio bastante simples: você receberá duas entradas, uma sequência e um número (o número pode ser tomado como uma sequência, ou seja, em "123"vez de 123)

Se a sequência não terminar em um número (ou seja, não corresponde à regex \d$), basta acrescentar o número ao final da sequência.

Se a sequência terminar em um número (ou seja, corresponde ao regex \d+$), você deve primeiro excluí-lo e depois anexá-lo.

Nenhuma das entradas jamais será inválida ou vazia (inválida é definida pela entrada numérica que não contém apenas dígitos)

O número nunca conterá a -ou a ..

A sequência nunca conterá uma nova linha ou caracteres não-em branco que não podem ser impressos.

Casos de teste:

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 duas seqüências de caracteres como entrada, separadas por uma nova linha.

Experimente online!

Python 2 , 30 bytes

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

Experimente online!

PHP, 37 36 35 33 bytes

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

Guardado 1 byte graças a Jörg Hülsermann .

Perl 5, 12 bytes

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

s/\d*$/<>/e

Experimente online!

Java 8, 32 bytes

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

Recebe entrada acomo uma String e, por bisso, não importa se é uma String ou um número inteiro (embora eu use Integer no link TIO abaixo).

Experimente aqui.

Python 2 , 32 bytes

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

Experimente online!

Toma as entradas na ordem inversa, tanto como string.

05AB1E , 9 bytes

DvTFNÜ}}«

Experimente online! Provavelmente uma solução ruim, mas é a melhor que eu poderia

Explicação

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

Japonês , 10 bytes

r"%d*$" +V

Experimente online!

 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

EDIT: -4 bytes thanks to @Dom Hastings. I don't use regular expressions much.

EDIT 2: -2 bytes thanks to @totallyhuman pointing out that the number could be taken as a string

Had to be expected...

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

Just removes the digits at the end of the string and appends the number

Try it online!

Pip, 9 7 bytes

a<|XD.b

@DLosc saved me 2 bytes!

Try it online!

Explanation

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.

Jelly, 5 bytes

œrØD;

Try it online!

How it works

œ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 saved thanks to Neil reminding me why I shouldn't golf early in the morning!

Ruby, 21 bytes

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

Takes two strings in input.

Try it online!

C#, 45 bytes

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

Explanation:

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

óä*î

Try it online!

This uses the same regex as the Retina answer above:

s:/\d*\n//

Perl 6, 20 bytes

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

Tcl 32 bytes

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

Não tenho certeza sobre a interface esperada. Isso é feito como um procedimento que aceita as duas entradas como argumentos de chamada. Para transformá-lo em um script independente que lê a entrada de stdin e gera o resultado em stdout, seria necessário a linha extra:

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

ou faria tudo "inline":

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

regsub pega um RE, a string original e uma string para substituir a parte correspondente.

Mathematica, 48 bytes

Já existe uma solução Mathematica (84 bytes).

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

Cenoura , 16 21 bytes

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

Experimente online!(a entrada é separada por avanço de linha)

Explicação

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

Eu tive que aumentar o número de bytes em 5 porque o código não funcionava para casos de teste como a5b3com vários 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

Eu tentei fazer isso sem regex, então talvez essa seria uma resposta dramaticamente aprimorada. Além disso, existem algumas maneiras pelas quais eu poderia fazer isso, por isso não tenho certeza se consigo raspar alguns bytes com uma abordagem diferente.

UPDATE: Eu subi em bytes porque percebi que estava falhando no caso de teste em que existem números na string que não são o sufixo. Agora tenho certeza que o regex forneceria uma resposta muito melhor.

UPDATE2: Após um ótimo feedback, mais bytes foram transferidos!

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

input 2 strings

["ab3d5", "55"]

resultado

ab3d55

C (gcc) , 99 98 96 95 bytes

Deve ser capaz de jogar isso um pouco ...

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

Experimente online!

Noether , 11 bytes

I"\d+$"-I+P

Experimente aqui!

Ao inserir uma sequência, coloque-a entre aspas

Explicação:

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Ü}«

Experimente online!

Explicação:

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.