Dada una cadena que contiene números decimales:

teststring134this 123test string54 100

incremente cada número en esta cadena por uno para dar la nueva cadena

teststring135this 124test string55 101.

La cadena se puede proporcionar como:

• un argumento de línea de comando
• STDIN
• una variable codificada o argumento de función

Cubra todas las posiciones posibles para un número:

• como prefijo de una palabra; 123test►124test
• como sufijo de una palabra; test123►test124
• dentro de una palabra; te123st►te124st
• solo test 123 test►test 124 test

Aquí hay una solución sin golf en Python:

NUMBERS = '0123456789'

def increment(s):
    out = ''

    number = ''
    for c in s:
        if c in NUMBERS:
            number += c
        else:
            if number != '':
                out += str(int(number) + 1)
                number = ''
            out += c

    if number != '':
        out += str(int(number) + 1)
        number = ''

    return out


print "\"%s\"" % (increment('teststring134this 123test string54 100'))

Esta es una code-golfpregunta, el código más corto gana.

Perl, 14 bytes

s/\d+/$&+1/ge

Requiere el -pinterruptor, que he contado como un byte.

Ejecución de ejemplo

$ perl -p <(echo 's/\d+/$&+1/ge') <<< 'teststring134this 123test string54 100'
teststring135this 124test string55 101

Ruby, 30 24 bytes

$><<s.gsub(/\d+/,&:next)

Espera que la entrada se almacene en s.

Vim - 13 pulsaciones de teclas

0qqqqq^Al@qq@q

Espera que la entrada sea la línea actual.

O para un número finito de números (por ejemplo, 999) en 8 + ceil (log (n)) pulsaciones de teclas:

0qq^Alq999@q

JavaScript (ES6) - 28

H=k=>k.replace(/\d+/g,k=>++k)

Ejecutar usando H("test 123 234t").

Perl, 23

Asume que la cadena de entrada está asignada a $_

s/\d+/@{[$&+1]}/g;print

Python 2 - 59

Suministrar la cadena como variable n

import re;print re.sub('\d+',lambda x:`int(x.group())+1`,n)

C99 - 86 (GCC 4.9.0 y Visual C ++ 2013)

Editar: Tanto GCC 4.9.0 (con -std = c99) como Visual C ++ 2013 compilan con éxito (con advertencias) el mismo código sin las inclusiones. ¡No sabía que podías hacer eso! Gracias por la pista.

Editar: Ni siquiera se me ocurrió que debería escribirlo en la pantalla sobre la marcha en lugar de crear la cadena y luego imprimirla. Eso hace una gran diferencia. Gracias Dennis!

Esto está usando una cadena codificada pero el contenido de la cadena no se cuenta hacia el total (se cuenta el = "").

main(i){for(char*q,*s="test123test999test-1test";i=strtol(s,&q,0),*s;q>s?printf("%d",i+1,s=q):putchar(*s++));}

Básicamente se ejecuta a través de la cadena un carácter a la vez comprobando cada uno para ver si es un número entero. Si es así, incrementa el número entero y lo escribe en la salida; de lo contrario, copia el carácter actual en la salida.

Esto filtra la cadena codificada porque incrementa s.

J (20)

Espera que la entrada se almacene en la variable a.

'\d+'>:&.".rxapply a

Prueba:

   a=:'teststring134this 123test string54 100'
   '\d+'>:&.".rxapply a
teststring135this 124test string55 101

(f?) lex (39)

Archivo inc.l:

%%
[0-9]+ printf("%d",atoi(yytext)+1);

Compilar:

$ flex inc.l
$ gcc lex.yy.c -o inc -lfl

Correr:

$ echo 'teststring134this 123test string54 100' | ./inc
teststring135this 124test string55 101

$ i='(-: 2 empty bottles of beer :-)'
$ tty=$(tty)
$ for n in {2..5} ; do i=$(./inc<<<$i|tee $tty) ; done
(-: 3 empty bottles of beer :-)
(-: 4 empty bottles of beer :-)
(-: 5 empty bottles of beer :-)
(-: 6 empty bottles of beer :-)

No probé esto con el original lex. Comentarios son bienvenidos

Emacs - 20 caracteres

C-M-% [0-9]+ RET \,(1+ \#0) RET !

Requiere que se procese el texto para estar presente en el búfer actual. Conté CM-% como un carácter aquí, ya que se puede ingresar con una pulsación de tecla al mantener presionados tres modificadores.

GNU sed, 304 (incluido 1 para el indicador -r)

Voté esta pregunta como un posible duplicado, pero quizás esto sea contrario a eso porque esta respuesta no se puede cambiar trivialmente para que funcione allí. Sin embargo, con mucho, la respuesta más larga.

Inspirado en este ejemplo de la documentación de sed , aunque necesitaba algo de trabajo para manejar múltiples números en una cadena:

:d
s/9([^0-9]+|$)/_\1/g
td
s/8(_*)([^0-9]+|$)/9\1\2/g
s/7(_*)([^0-9]+|$)/8\1\2/g
s/6(_*)([^0-9]+|$)/7\1\2/g
s/5(_*)([^0-9]+|$)/6\1\2/g
s/4(_*)([^0-9]+|$)/5\1\2/g
s/3(_*)([^0-9]+|$)/4\1\2/g
s/2(_*)([^0-9]+|$)/3\1\2/g
s/1(_*)([^0-9]+|$)/2\1\2/g
s/0(_*)([^0-9]+|$)/1\1\2/g
s/(^|[^0-9_]+)(_+)/\11\2/g
y/_/0/

Salida:

$ for s in "teststring134this 123test string54 100" "123test" "test123" "te123st" "test 123 test" ; do echo "$s" | sed -rf incr.sed ; done
teststring135this 124test string55 101
124test
test124
te124st
test 124 test
$ 

Tenga en cuenta esta inserta temporalmente _caracteres, por lo que podría dar lugar a resultados incorrectos si hay _en el flujo de entrada. Como mitigación de esto, podemos reemplazar el _script en el sed con algún carácter no imprimible (por ejemplo, ASCII 0x07 BEL), y asumir que la secuencia de entrada contiene solo ASCII imprimible. Esto parece funcionar bien cuando lo pruebo.

Raqueta 74

(define(f x)(regexp-replace* #px"\\d+"x(λ(m)(~a(+ 1(string->number m))))))

Lua - 68 caracteres

d='(%D-)'for k,i,j in s:gmatch(d..'(%d+)'..d)do io.write(k,i+1,j)end

Espera que la entrada se almacene en s.

CJam, 67 58 53 48 31 caracteres

Esta pregunta es como la peor pregunta para CJam. Sin expresiones regulares, sin coincidencia de patrones, sin captura de excepciones. Pero aquí vamos (#YOLO)

Sl+_A,sNerN%\[_A,s-Ner~]:)]zs1>

Éste divide la cadena en un grupo de solo alfabetos y solo dígitos. Incrementa cada dígito y une las dos matrices tomando un elemento de cada una a la vez.

Solución previa:

L_l{:Ci57-zA<:RC*+:N\R!N*NNW?i):NL?+RLC?@R*}/NL?

Pruébalo en línea aquí

Cómo funciona:

La idea básica es seguir almacenando el carácter por separado en una cadena si es un dígito y volcar el valor incrementado en la cadena final una vez que obtengamos un carácter que no sea un dígito.

L_                                               "Push two empty strings to stack,"
                                                 "first representing the final string"
                                                 "and second, the current ongoing number";
  l{                                       }/    "Run this block for each character of input string";
    :Ci                                          "Store the character to C and convert to"
                                                 "its ASCII equivalent integer";
       57-zA<:R                                  "Subtract 57 from the integer and compare"
                                                 "its absolute value with 10. Numeric character"
                                                 "would result to true here. Store the result in R";
               C*+:N                             "Take either 0 or 1 characters from C based"
                                                 "on value of R, add it to the second string"
                                                 "from first step. Also store the value in N";
                    \                            "Switch the strings. Now the string containing"
                                                 "the final result string is at top of stack";
                     R!N*                        "If the character was not a digit and N contains a number in it";
                         NNW?i):NL?+             "Convert N to number and increment it."
                                                 "If N is blank, take 0 instead. Put the final"
                                                 "value back in N and add it to the final result string";
                                    RLC?         "If the character was not a digit, push it to stack";
                                        @R*      "Put the ongoing numeric string back to top of stack";
                                             NL? "This is to handle the case when the last number"
                                                 "is not followed by a string, so stack will"
                                                 "have a string at top. Push the value of N to stack in that case";

Cobra - 88

do(s='')=RegularExpressions.Regex.replace(s,'\d+',do(m as Match)='[int.parse("[m]")+1]')

C # - 178 169 157 caracteres

Esto supone que los números como 999 pueden desbordarse a 000 y que - + ,. E no son parte de un número.

class T{static void Main(){var a="".ToCharArray();for(int b=1,c,i=a.Length;i-->0;b=48>c|c>57?7:b>0?c>56?a[i]='0':++a[i]*0:b)c=a[i];System.Console.Write(a);}}

Mejor forma legible:

class T
{
    static void Main()
    {
        var a="7teststring134this 123test string59 100".ToCharArray();

        for (int b=3, c, i=a.Length; i-->0;
            b=48>c|c>57
                ?7
                :b>2
                    ?c>56?a[i]='0':++a[i]*0
                    :b
        ) c=a[i];

        System.Console.Write(a);
        System.Console.ReadKey();
    }
}

Soy nuevo aquí, nunca probé el código golf antes, solo lo intenté :)

Me pregunto si alguien tiene ideas para hacerlo aún más corto ...

Para participar con C #, sería bueno si pudiéramos omitir todo el marco necesario alrededor del código real, entonces esto solo tendría 82 caracteres, y eso sin llamar a ninguna función de sistema potente.

Lo mismo con los punteros (182 caracteres):

class T
{
    unsafe static void Main()
    {
        char[] a="7teststring134this 123test string59 100".ToCharArray();

        int b=3;
        fixed (char* s=&a[0])
            for (var p=s+a.Length; p-->s; )
                b=*p<48|*p>57
                    ?7
                    :b>2
                        ?*p>56?*p='0':++*p*0
                        :b;

        System.Console.Write(a);
        System.Console.ReadKey();
    }
}

Ahora sin desbordarse, esto maneja correctamente el caso 999 (223 caracteres):

class T
{
    static void Main()
    {
        var s=new System.Text.StringBuilder("9999teststring134this 123test string99 100");

        for (int b=3, c, i=s.Length; i-->0; )
        {
            c=s[i];
            b=48>c|c>57
                ?b>8?8:7
                :b>2
                    ?c>56?c-(s[i]='0'):++s[i]*0
                    :b;
            if (b>8&i<1|b==8) s.Insert(i+9-b, '1');
        }

        System.Console.Write(s);
        System.Console.ReadKey();
    }
}

Otro más antiguo, se lee desde la entrada estándar y usa la recursividad:

namespace System {
    using C=Console;
    class T {
        class t {
            byte b=1;
            string s="";
            void R() {
                var c=C.Read();
                if (c>31) {
                    R();
                    if (48>c|c>57) b=1;
                    else if (b==1) c=c==57?48:++c*b--;
                    s=(char)c+s;
                }
            }
            public t() {
                R();
                C.Write(s);
            }
        }
        static void Main() {
            new t();
            C.ReadKey();
        }
    }
}

Nota: Console.ReadKey();y la cadena en sí no debe contarse.

Ya mejoré esto varias veces, ver comentarios. Todavía hay espacio para más mejoras, diría :) Y perdón por la duración, pero creo que las diferentes versiones son lo suficientemente interesantes como para mantenerlas ...

Groovy, 38 bytes

{it.replaceAll(/\d+/,{(it as int)+1})}

Uggghhh ... Odio absolutamente las palabras replacey allarruinan todos los campos de golf regex para mí.

PHP - 91 bytes

<?$i=fgets(STDIN);for($n=0;$n<strlen($i);$n++)if(is_numeric($i[$n]))$i[$n]=$i[$n]+1;echo$i;

No quería usar expresiones regulares. PHP no es capaz de incrementar directamente un desplazamiento de cadena, por lo tanto, necesitaba agregar algunos bytes en el paso de incremento. Este script de una línea me recuerda una época muy oscura de los scripts PHP ...

K, 56

{" "/:{,/$(`$a)^`$$1+"I"$a:_[;x]@&~~':x in .Q.n}'" "\:x}

sed y bash - 40 (incluyendo invocación y tuberías)

$ cat << EOF |sed 's/[0-9]\+/$((\0+1))/g;s/^/echo /'|bash
teststring134this 123test string54 100
123test
test123
te123st
test 123 test
EOF

Salidas:

teststring135this 124test string55 101
124test
test124
te124st
test 124 test

Java 7, 119 bytes

void c(String s){for(String x:s.split("(?=[^\\d]+)|(?<=[^\\d]+)"))System.out.print(x.matches("\\d+")?new Long(x)+1:x);}

Si el requisito es un programa en lugar de solo una función, entonces son 149 bytes:

class M{public static void main(String[]a){for(String x:a[0].split("(?=[^\\d]+)|(?<=[^\\d]+)"))System.out.print(x.matches("\\d+")?new Long(x)+1:x);}}

Ungolfed y código de prueba:

Pruébalo aquí.

class M{
  static void c(String s){
    for(String x : s.split("(?=[^\\d]+)|(?<=[^\\d]+)")){
      System.out.print(x.matches("\\d+")
                        ? new Long(x) + 1
                        : x);
    }
  }

  public static void main(String[] a){
    c("123test");
    System.out.println();
    c("test123");
    System.out.println();
    c("te123st");
    System.out.println();
    c("test 123 test");
    System.out.println();
    c("7teststring134this 123test string59 100");
  }
}

Salida:

124test
test124
te124st
test 124 test
8teststring135this 124test string60 101

Gema, 14 personajes

<D>=@add{$1;1}

Ejecución de muestra:

bash-4.3$ gema '<D>=@add{$1;1}' <<< 'teststring134this 123test string54 100'
teststring135this 124test string55 101

DASH , 16 bytes (sin competencia)

rstr[R"\d+""g"+1

Esto devuelve una función / aplicación parcial.

Uso:

rstr[R"\d+""g"+1]"test 123 234t"

Explicación

rstr[          #. replace any parts of the input
  R "\d+" "g"  #. matching /\d+/g
  +1           #. with its incremented form
]

CJam, 18 bytes

q_A,s-_:(:`ers~]:)

Pruébalo aquí.

Explicación

q         e# Read input.
_A,s-     e# Duplicate and remove digits.
_         e# Duplicate.
:(:`      e# Decrement and get the string representation of each character.
er        e# Map the characters to the decremented string representation.
s~        e# Flatten to string and evaluate.
]:)       e# Wrap in an array and increment each element.

R, 83 bytes

Tarde a la fiesta. Asume que la entrada se almacena en variable x. Probablemente no sea necesario usarlo regmatchespara resolver esto, pero no pude encontrar reemplazos vectorizados sin ningún paquete externo.

paste0(el(r(x,m<-gregexpr("\\d+",x),T)),c(as.numeric(el(r(x,m)))+1,""),collapse="")

Desengañado y explicado

r=regmatches                                        # Alias for regmatch
y=r(x<-scan(,""),m<-gregexpr("\\d+",x))             # return match digits
i=r(x,m,T)                                          # return inverted match (non-digits)
paste0(el(i),c(as.numeric(el(y))+1,""),collapse="") # join digits+1 and non-digits, element-wise

Salida de ejemplo

input: 
"teststring135this 124test string55 101"

output:
[1] "teststring136this 125test string56 102"

C # (compilador interactivo de Visual C #) con opción de línea de comandos /u:System.Text.RegularExpressions.Regex;System.Int32, 40 bytes

Replace(n,"\\d+",m=>Parse(m.Value)+1+"")

Espera que la entrada esté en una variable llamada n.

Pruébalo en línea!