Una sfida abbastanza semplice: riceverai due input, una stringa e un numero (il numero può essere preso come una stringa, cioè "123"invece di 123)

Se la stringa non termina con un numero (cioè non corrisponde alla regex \d$), basta aggiungere il numero alla fine della stringa.

Se la stringa termina con un numero (cioè corrisponde alla regex \d+$), è necessario prima eliminarlo e quindi aggiungere il numero.

Nessuno degli ingressi sarà mai invalido o vuoto (non valido è definito dall'ingresso numerico che non contiene solo cifre)

Il numero non conterrà mai a -o a ..

La stringa non conterrà mai una nuova riga o caratteri non bianchi non stampabili.

Casi test:

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

Retina , 5 byte

\d*¶

Accetta due stringhe come input, separate da una nuova riga.

Provalo online!

Python 2 , 30 byte

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

Provalo online!

PHP, 37 36 35 33 byte

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

Salvato 1 byte grazie a Jörg Hülsermann .

Perl 5, 12 byte

11 byte codice + 1 per -p.

s/\d*$/<>/e

Provalo online!

Java 8, 32 byte

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

Accetta input acome stringa e perb non importa se si tratta di una stringa o di un numero intero (anche se utilizzo Integer nel collegamento TIO di seguito).

Provalo qui.

Python 2 , 32 byte

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

Provalo online!

Porta gli input in ordine inverso, entrambi come stringa.

05AB1E , 9 byte

DvTFNÜ}}«

Provalo online! Probabilmente una pessima soluzione, ma è la migliore che ho potuto inventare

Spiegazione

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

Japt , 10 byte

r"%d*$" +V

Provalo 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 byte

EDIT: -4 byte grazie a @Dom Hastings. Non uso molto le espressioni regolari.

MODIFICA 2 : -2 byte grazie a @totallyhuman sottolineando che il numero potrebbe essere preso come una stringa

Doveva aspettarsi ...

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

Rimuove solo le cifre alla fine della stringa e accoda il numero

Provalo online!

Pip , 9 7 byte

a<|XD.b

@DLosc mi ha salvato 2 byte!

Provalo online!

Spiegazione

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.

Gelatina , 5 byte

œrØD;

Provalo online!

Come funziona

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

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

• 1 byte salvato grazie a Neil che mi ricorda perché non dovrei giocare a golf la mattina presto!

Rubino , 21 byte

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

Accetta due stringhe in input.

Provalo online!

C #, 45 byte

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

Spiegazione:

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 byte

óä*î

Provalo online!

Questo utilizza lo stesso regex della risposta Retina sopra:

s:/\d*\n//

Perl 6 , 20 byte

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

Tcl 32 byte

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

Non sono sicuro dell'interfaccia prevista. Questo viene fatto come una procedura che accetta i due input come argomenti di chiamata. Per trasformarlo in uno script autonomo che legge l'input da stdin e restituisce il risultato a stdout, è necessaria la riga aggiuntiva:

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

o farebbe tutto "inline":

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

regsub prende un RE, la stringa originale e una stringa con cui sostituire la parte corrispondente.

Mathematica, 48 byte

Esiste già una soluzione Mathematica (84 byte).

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

Carota , 16 21 byte

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

Provalo online! (l'ingresso è separato dall'alimentazione di linea)

Spiegazione

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

Ho dovuto aumentare il numero di byte di 5 perché il codice non funzionava per i casi di test come a5b3con più cifre.

Haskell, 75 byte 95 byte 91 79 61 byte

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

Ho provato a farlo senza regex, quindi forse quella sarebbe una risposta notevolmente migliorata. Inoltre ci sono un paio di modi in cui posso fare questo, quindi non sono sicuro di poter radere qualche byte con un approccio diverso.

AGGIORNAMENTO: Sono salito in byte perché mi sono reso conto di non riuscire nel caso di test in cui nella stringa esistono numeri che non sono il suffisso. Ora sono sicuro che regex fornirebbe una risposta molto migliore.

AGGIORNAMENTO2: dopo alcuni ottimi riscontri, sono stati giocati più byte!

Mathematica, 84 byte

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

inserire 2 stringhe

["ab3d5", "55"]

produzione

ab3d55

C (cc) , 99 98 96 95 byte

Dovrebbe essere in grado di giocare a golf un po '...

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

Provalo online!

Noether , 11 byte

I"\d+$"-I+P

Provalo qui!

Quando si inserisce una stringa, racchiuderla tra virgolette

Spiegazione:

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 byte

DþRvyÜ}«

Provalo online!

Spiegazione:

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.