십진수를 포함하는 문자열이 주어진 경우 :

teststring134this 123test string54 100

이 문자열의 모든 숫자를 1 씩 증가시켜 새 문자열을 제공하십시오.

teststring135this 124test string55 101.

문자열은 다음과 같이 제공 될 수 있습니다.

• 명령 행 인수
• STDIN
• 하드 코딩 된 변수 또는 함수 인수

숫자의 가능한 모든 위치를 커버하십시오 :

• 단어의 접두사로; 123test►124test
• 단어의 접미사로; test123►test124
• 단어 안에; te123st►te124st
• 혼자서 test 123 test►test 124 test

다음은 파이썬에서 골프가 아닌 솔루션입니다.

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

이것은 code-golf가장 짧은 코드가 승리 하는 질문입니다.

펄, 14 바이트

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

-p1 바이트로 계산 한 스위치가 필요합니다 .

예제 실행

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

루비, 30 24 바이트

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

에 입력이 저장 될 것으로 예상합니다 s.

Vim-13 번의 키 입력

0qqqqq^Al@qq@q

입력이 현재 행이 될 것으로 예상합니다.

또는 8 + ceil (log (n)) 키 스트로크에서 유한하게 많은 수 (예 : 999)의 경우 :

0qq^Alq999@q

자바 스크립트 (ES6)-28

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

를 사용하여 실행하십시오 H("test 123 234t").

펄, 23

입력 문자열이 할당 된 것으로 가정 $_

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

파이썬 2-59

문자열을 변수로 제공하십시오 n

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

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

편집 : GCC 4.9.0 (-std = c99 사용)과 Visual C ++ 2013은 모두 포함없이 동일한 코드를 경고와 함께 성공적으로 빌드합니다. 나는 당신이 그렇게 할 줄 몰랐어요! 힌트 주셔서 감사합니다.

편집 : 문자열을 만든 다음 인쇄하는 대신 화면에 즉시 작성 해야하는 경우조차 없었습니다. 그것은 큰 차이를 만듭니다. 고마워 데니스!

하드 코딩 된 문자열을 사용하지만 문자열의 내용은 총계로 계산되지 않습니다 (= ""가 계산 됨).

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

기본적으로 문자열을 통해 한 번에 한 문자 씩 실행하여 정수인지 확인합니다. 그렇다면 정수를 증가시키고 출력에 씁니다. 그렇지 않으면 현재 문자를 출력에 복사합니다.

하드 코드 된 문자열은 s를 증가시키기 때문에 누출됩니다.

J (20)

입력이 변수에 저장 될 것으로 예상합니다 a.

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

테스트:

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

(f?) lex (39)

파일 inc.l:

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

엮다:

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

운영:

$ 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 :-)

나는 이것을 원본으로 테스트하지 않았다 lex. 의견을 환영합니다.

이맥스-20 자

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

현재 버퍼에 텍스트를 처리해야합니다. 여기서는 세 개의 수정자를 누른 상태에서 한 번의 키 입력으로 CM- %를 하나의 문자로 계산했습니다.

GNU sed, 304 (-r 플래그의 경우 1 포함)

나는이 질문을 가능한 중복으로 찬성 투표했지만이 대답은 사소하게 변경되어서 작동하지 않기 때문에 아마도 그와 반대입니다. 그러나 가장 긴 대답입니다.

sed documentation 에서이 예제에서 영감을 얻었 지만 문자열에서 여러 숫자를 처리하는 작업이 필요했습니다.

: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/

산출:

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

이로 _인해 문자가 일시적으로 삽입 되므로 _입력 스트림에있는 경우 잘못된 결과가 발생할 수 있습니다 . 이를 완화하기 _위해 sed 스크립트에서를 인쇄 할 수없는 문자 (예 : ASCII 0x07 BEL)로 바꿀 수 있으며 입력 스트림에 인쇄 가능한 ASCII 만 있다고 가정합니다. 테스트 할 때 제대로 작동하는 것 같습니다.

라켓 74

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

루아-68 자

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

입력이 s에 저장 될 것으로 예상합니다.

CJam, 67 58 53 48 31 자

이 질문은 CJam의 최악의 질문과 같습니다. 정규 표현식, 패턴 일치, 예외 잡기 없음. 그러나 우리는 간다 (#YOLO)

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

이것은 문자열을 알파벳과 숫자로 그룹화합니다. 각 자릿수를 증가시키고 한 번에 하나의 요소를 사용하여 두 배열을 다시 연결합니다.

이전 솔루션 :

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

여기에서 온라인으로 사용해보십시오

작동 방식 :

기본 아이디어는 숫자 인 경우 문자열에 별도로 문자를 저장하고 숫자가 아닌 문자를 얻으면 증가 된 값을 최종 문자열로 덤프하는 것입니다.

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";

코브라-88

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

C 번호 - 178 169 157 자

이것은 999와 같은 숫자가 000으로 오버 플로우 될 수 있고-+ ,. E는 숫자의 일부가 아니라고 가정합니다.

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

더 읽기 쉬운 형태 :

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

나는 여기에 새롭고 전에 코드 골프를 시도한 적이 없으며 시도해 보았습니다. :)

누구든지 그것을 더 짧게 할 아이디어가 있는지 궁금합니다 ...

C #에 참여하려면 실제 코드 주위에 필요한 모든 프레임 워크를 생략 할 수 있다면 좋을 것입니다 .82 문자 만 있고 강력한 시스템 기능을 호출하지 않고도 가능합니다.

포인터 (182 문자)와 동일합니다.

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

이제 넘치지 않고 999 경우 (223 자)를 올바르게 처리합니다.

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

다른 오래된 파일은 표준 입력에서 읽고 재귀를 사용합니다.

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

참고 : Console.ReadKey();문자열 자체는 계산되지 않아야합니다.

나는 이것을 이미 여러 번 개선했다. 더 많은 개선의 여지가 여전히 남아 있습니다.)라고 말하고 싶습니다. 길이가 미안하지만 다른 버전이 그들을 유지하기에 충분히 재미 있다고 생각합니다 ...

그루비, 38 바이트

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

Ugggghhh ... 나는 절대로 단어를 싫어 replace하고 all, 그들은 나를 위해 모든 정규식 골프를 망 칩니다 .

PHP-91 바이트

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

정규식을 사용하고 싶지 않았습니다. PHP는 문자열 오프셋을 직접 증가시킬 수 없으므로 증가 단계에서 약간의 바이트를 추가해야했습니다. 이 한 줄짜리 스크립트는 PHP 스크립팅의 매우 어두운 시대를 기억합니다.

K, 56

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

sed and bash-40 (호출 및 파이프 포함)

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

출력 :

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

자바 7, 119 바이트

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

요구 사항이 단순히 함수가 아닌 프로그램 인 경우 149 바이트입니다.

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

언 골프 및 테스트 코드 :

여기에서 시도하십시오.

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

산출:

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

대마, 14 자

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

샘플 실행 :

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

DASH , 16 바이트 (비경쟁)

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

함수 / 부분 응용 프로그램을 반환합니다.

용법:

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

설명

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

CJam, 18 바이트

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

여기에서 시도하십시오.

설명

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 바이트

파티에 늦었다. 입력이 variable에 저장되었다고 가정합니다 x. 아마도 regmatches이것을 해결하기 위해 사용할 필요는 없지만 외부 패키지없이 벡터화 된 대체물을 알 수 없었습니다.

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

언 골프 및 설명

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

출력 예

input: 
"teststring135this 124test string55 101"

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

명령 줄 옵션이있는 C # (Visual C # Interactive Compiler)/u:System.Text.RegularExpressions.Regex;System.Int32 , 40 바이트

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

입력이 n이라는 변수에있을 것으로 예상합니다.

온라인으로 사용해보십시오!