Increment a numerical string

From Rosetta Code
Task
Increment a numerical string
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Increment a numerical string.

11l[edit]

Translation of: Python
V next = String(Int(‘123’) + 1)


8080 Assembly[edit]

	org	100h
	jmp	demo
	;;; Increment the number in the $-terminated string under HL.
	;;; The new string is written back to the original location.
	;;; It may grow by one byte (e.g. 999 -> 1000).
incstr:	mvi	a,'$'	; End marker
	lxi	d,303Ah	; D='0', E='9'+1
	lxi	b,0	; Find the end of the string and find the length
isrch:	cmp	m	; Are we there yet?
	inx	b	; If not, try next character
	inx	h
	jnz	isrch
	dcx	h
	dcx	b
	mov	a,b	; Is the string empty?
	ora	c
	rz		; Then return (do nothing)
	inx	b
idigit:	dcx	b	; Go to previous digit
	dcx	h
	mov	a,b	; Are we at the beginning of the string?
	ora	c
	jz	igrow	; Then the string grows (999 -> 1000)
	inr 	m	; Otherwise, increment the digit
	mov	a,e
	cmp	m	; Did we try to increment '9'?
	rnz		; If not, we're done, return
	mov	m,d	; But if so, this digit is now a 0
	jmp	idigit	; And we should do the next digit
igrow:	inx	h
	mvi	m,'1'	; The string should now be '10000...'
	inx	h	; We know the string is at least one char long
	mvi	a,'$'
izero:	cmp 	m	; Are we at the end yet?
	mov	m,d	; In any case, write a zero
	inx	h
	jnz	izero	; If not done, write a zero
	mov	m,a	; Finally, reterminate the string
	ret
	;;;	Demo code: increment the CP/M command line argument
demo:	lxi	h,80h	; $-terminate the string
	mov	a,m
	adi	81h	; Length is at 80h, the argument itself at 81h
	mov	l,a
	mvi	m,'$'
	mvi	l,80h	; Skip any spaces
	mvi	a,' '
space:	inx	h
	cmp	m
	jz 	space
	push	h	; Store the beginning of the string
	call	incstr	; Increment the number in the string
	pop	d	; Print the string
	mvi	c,9
	jmp	5

8086 Assembly[edit]

	cpu	8086
	bits	16
section	.text
	org	100h
	jmp	demo		; Jump towards demo code
	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	;;;	Increment the number in the $-terminated string
	;;;	in [ES:DI]. The string is written back to its original
	;;;	location. It may grow by one byte.
incnum:	mov	al,'$'		; Find string terminator
	mov	bx,di		; Store the beginning of the string
	mov	cx,-1
	repne	scasb
	dec	di		; Move to the terminator
	cmp	bx,di		; If the string is empty, do nothing
	je	.out
.digit:	cmp	bx,di		; Is this the first digit?
	je	.grow		; If so, the string grows
	dec	di		; Go one digit backwards
	inc	byte [es:di]	; Increment the digit
	cmp	byte [es:di],'9'+1	; Did we increment past 9?
	jne	.out		; If not, we're done
	mov	byte [es:di],'0'	; Otherwise, write a zero
	jmp	.digit		; And increment the next digit
.grow:	mov	al,'1'		; Write an 1 first (we know the string
	stosb			; is at least one character long)
	dec	al		; Zero
.zero:	cmp	byte [es:di],'$'	; Are we about to overwrite
	stosb			; the terminator? First, do it anyway;
	jne	.zero		; Keep writing zeroes until $ is reached
	mov	al,'$'		; Finally, write a new terminator
	stosb	
.out:	ret
	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	;;;	Demo code: increment the number on the MS-DOS
	;;;	command line.
demo:	mov	si,80h		; $-terminate the string
	lodsb
	xor	bh,bh
	mov	bl,al
	mov	byte [si+bx],'$'
	mov	al,' '		; Skip past any spaces
	mov	cx,-1
	mov	di,si
	repe	scasb
	dec	di
	mov	dx,di		; Keep start of string in DX
	call	incnum		; Increment the number in the string
	mov	ah,9		; Print the string
	int	21h
	ret

AArch64 Assembly[edit]

Works with: as version Raspberry Pi 3B version Buster 64 bits
/* ARM assembly AARCH64 Raspberry PI 3B */
/*  program incstring64.s   */
 
/*******************************************/
/* Constantes file                         */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"

.equ BUFFERSIZE,   100
/*******************************************/
/* Initialized data                        */
/*******************************************/
.data
szMessNum:           .asciz "Enter number : \n"
szCarriageReturn:    .asciz "\n"
szMessResult:        .asciz "Increment number is =  @ \n"      // message result

/*******************************************/
/* UnInitialized data                      */
/*******************************************/
.bss 
sBuffer:    .skip BUFFERSIZE
sZoneConv:  .skip 24
/*******************************************/
/*  code section                           */
/*******************************************/
.text
.global main 
main:                      // entry of program
 
    ldr x0,qAdrszMessNum
    bl affichageMess
    mov x0,#STDIN          // Linux input console
    ldr x1,qAdrsBuffer     // buffer address 
    mov x2,#BUFFERSIZE     // buffer size 
    mov x8, #READ          // request to read datas
    svc 0                  // call system
    ldr x1,qAdrsBuffer     // buffer address 
    strb wzr,[x1,x0]       // store zero at the end of input string (x0
    // 
    ldr x0,qAdrsBuffer     // buffer address
    bl conversionAtoD      // conversion string in number in x0
                           // increment x0
    add x0,x0,1
                           // conversion register to string
    ldr x1,qAdrsZoneConv                
    bl conversion10S       // call conversion
    ldr x0,qAdrszMessResult
    ldr x1,qAdrsZoneConv 
    bl strInsertAtCharInc  // insert result at @ character
    bl affichageMess       // display message
 
100:                       // standard end of the program
    mov x0,0               // return code
    mov x8,EXIT            // request to exit program
    svc 0                  // perform the system call
 
qAdrsZoneConv:          .quad sZoneConv
qAdrszMessNum:          .quad szMessNum
qAdrsBuffer:            .quad sBuffer
qAdrszMessResult:       .quad szMessResult
qAdrszCarriageReturn:   .quad szCarriageReturn
/********************************************************/
/*        File Include fonctions                        */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
Output:
Enter number :
50
Increment number is =  +51
pi@debian-buster-64:~/asm64/rosetta/asm4 $ incstring64
Enter number :
-12
Increment number is =  -11

ABAP[edit]

report zz_incstring
perform test using: '0', '1', '-1', '10000000', '-10000000'.

form test using iv_string type string.
  data: lv_int  type i,
        lv_string type string.
  lv_int = iv_string + 1.
  lv_string = lv_int.
  concatenate '"' iv_string '" + 1 = "' lv_string '"' into lv_string.
  write / lv_string.
endform.
Output:
"0" + 1 = "1 "
"1" + 1 = "2 "
"-1" + 1 = "0 "
"10000000" + 1 = "10000001 "
"-10000000" + 1 = "9999999-"

Action![edit]

PROC Increment(CHAR ARRAY src,dst)
  INT val

  val=ValI(src)
  val==+1
  StrI(val,dst)
RETURN

PROC Test(CHAR ARRAY src)
  CHAR ARRAY dst(10)
  Increment(src,dst)
  PrintF("%S+1=%S%E",src,dst)
RETURN

PROC Main()
  Test("0")
  Test("1")
  Test("9999")
  Test("-1")
  Test("-2")
  Test("-10000")
RETURN
Output:

Screenshot from Atari 8-bit computer

0+1=1
1+1=2
9999+1=10000
-1+1=0
-2+1=-1
-10000+1=-9999

ActionScript[edit]

function incrementString(str:String):String
{
	return String(Number(str)+1);
}

Ada[edit]

The standard Ada package Ada.Strings.Fixed provides a function for trimming blanks from a string.

S : String := "12345";
S := Ada.Strings.Fixed.Trim(Source => Integer'Image(Integer'Value(S) + 1), Side => Ada.Strings.Both);

Aime[edit]

o_text(itoa(atoi("2047") + 1));
o_byte('\n');

ALGOL 68[edit]

Works with: ALGOL 68 version Revision 1 - no extensions to language used
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny
STRING s := "12345"; FILE f; INT i;
associate(f, s); get(f,i); 
i+:=1; 
s:=""; reset(f); put(f,i);
print((s, new line))
Output:
+12346

ALGOL W[edit]

Increments a string representaton of an integer, without converting it to an integer and so allows values greater than will fit into an Algol W integer (which is restricted to 32 bits).

begin
    % returns a string representing the number in s incremented     %
    % As strings are fixed length, the significant length of s must %
    % be specified in length                                        %
    % s must contain an unsigned integer                            %
    % If the string is invalid or the result would require more     %
    % than 256 characters (the maximum string length), "error"      %
    % is returned                                                   %
    string(256) procedure increment( string(256) value s
                                   ; integer     value length
                                   ) ;
    begin
        logical isValid;
        integer rPos, sPos, carry;
        string(256) iValue;
        string(1) c;
        isValid := true;
        iValue  := " ";
        rPos    := 256;
        sPos    := length - 1;
        carry   := 1; % ensure the first digit is incremented       %
        while isValid and sPos >= 0 and rPos >= 0 do begin
            c      := s( sPos // 1 );
            sPos   := sPos - 1;
            if c not = " " then begin
                isValid := ( c >= "0" and c <= "9" );
                if isValid then begin
                    integer d;
                    d                   := ( decode( c ) - decode( "0" ) ) + carry;
                    carry               := d div 10;
                    rPos                := rPos - 1;
                    iValue( rPos // 1 ) := code( decode( "0" ) + d rem 10 )
                end if_isValid
            end if_c_ne_space
        end while_isValid_and_sPos_ge_0_and_rPOs_ge_0 ;
        if isValid then begin
            % the number was incremented successfully                                     %
            if carry not = 0 then begin
                % need an extra digit                                                     %
                if rPos <= 0
                then isValid := false % no room for an extra digit                        %
                else begin
                    % have space for an extra digit                                       %
                    rPos                := rPos - 1;
                    iValue( rPos // 1 ) := code( decode( "0" ) + carry )
                end if_rPos_lt_0__
            end if_carry_gt_0
        end if_isValid ;
        if not isValid then begin
            % s is not a numeric string or the result would be longer than 256 characters %
            iValue := "error"
            end
        else begin
            % the string could be incremented                                             %
            string(256) rightJustifiedValue;
            rightJustifiedValue := iValue;
            iValue              := " ";
            for iPos := 0 until 255 - rPos do iValue( iPos // 1 ) := rightJustifiedValue( rPos + iPos // 1 )
        end if_not_isValid_or_carry_ne_0__ ;
        iValue
    end increment ;
    % writes the string s, up to the first blank                                          %
    procedure writeonToBlank ( string(256) value s ) ;
    begin
        integer sPos;
        sPos := 0;
        while sPos < 256 and s( sPos // 1 ) not = " " do begin
            writeon( s_w := 0, s( sPos // 1 ) );
            sPos := sPos + 1
        end while_spos_lt_256_and_s_Spos_ne_space
    end writeonToBlank ;
    % test increment                                                                      %
    write( "                   0 + 1: " ); writeonToBlank( increment( "0",                     1 ) );
    write( "                   9 + 1: " ); writeonToBlank( increment( "9",                     1 ) );
    write( "           123456789 + 1: " ); writeonToBlank( increment( "123456789",             9 ) );
    write( "99999999999999999999 + 1: " ); writeonToBlank( increment( "99999999999999999999", 20 ) )
end.
Output:
                   0 + 1: 1
                   9 + 1: 10
           123456789 + 1: 123456790
99999999999999999999 + 1: 100000000000000000000

Apex[edit]

string count = '12345';
count = String.valueOf(integer.valueOf(count)+1);
system.debug('Incremental Value : '+count);
Output:
12346

APL[edit]

1+⍎'12345'
Output:
12346

AppleScript[edit]

Preserving the distinction between real and integer strings, and allowing for strings containing non-numeric tokens and/or multiple numeric expressions. Provides an option to either retain or prune out any non-numeric tokens in the string:

Translation of: Python
Translation of: Haskell
Translation of: JavaScript
use AppleScript version "2.4"
use framework "Foundation"
use scripting additions

-- succString :: Bool -> String -> String
on succString(blnPruned, s)
    script go
        on |λ|(w)
            try
                if w contains "." then
                    set v to w as real
                else
                    set v to w as integer
                end if
                {(1 + v) as string}
            on error
                if blnPruned then
                    {}
                else
                    {w}
                end if
            end try
        end |λ|
    end script
    unwords(concatMap(go, |words|(s)))
end succString


-- TEST ---------------------------------------------------
on run
    script test
        on |λ|(bln)
            succString(bln, ¬
                "41 pine martens in 1491.3 -1.5 mushrooms ≠ 136")
        end |λ|
    end script
    unlines(map(test, {true, false}))
end run

--> 42 1492.3 -0.5 137
--> 42 pine martens in 1492.3 -0.5 mushrooms ≠ 137

-- GENERIC ------------------------------------------------

-- concatMap :: (a -> [b]) -> [a] -> [b]
on concatMap(f, xs)
    set lng to length of xs
    set acc to {}
    tell mReturn(f)
        repeat with i from 1 to lng
            set acc to acc & |λ|(item i of xs, i, xs)
        end repeat
    end tell
    return acc
end concatMap

-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
    tell mReturn(f)
        set lng to length of xs
        set lst to {}
        repeat with i from 1 to lng
            set end of lst to |λ|(item i of xs, i, xs)
        end repeat
        return lst
    end tell
end map

-- Lift 2nd class handler function into 1st class script wrapper 
-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
    if class of f is script then
        f
    else
        script
            property |λ| : f
        end script
    end if
end mReturn

-- unlines :: [String] -> String
on unlines(xs)
    set {dlm, my text item delimiters} to ¬
        {my text item delimiters, linefeed}
    set str to xs as text
    set my text item delimiters to dlm
    str
end unlines

-- unwords :: [String] -> String
on unwords(xs)
    set {dlm, my text item delimiters} to ¬
        {my text item delimiters, space}
    set s to xs as text
    set my text item delimiters to dlm
    return s
end unwords

-- words :: String -> [String]
on |words|(s)
    set ca to current application
    (((ca's NSString's stringWithString:(s))'s ¬
        componentsSeparatedByCharactersInSet:(ca's ¬
            NSCharacterSet's whitespaceAndNewlineCharacterSet()))'s ¬
        filteredArrayUsingPredicate:(ca's ¬
            NSPredicate's predicateWithFormat:"0 < length")) as list
end |words|
Output:
42 1492.3 -0.5 137
42 pine martens in 1492.3 -0.5 mushrooms ≠ 137

ARM Assembly[edit]

Works with: as version Raspberry Pi
/* ARM assembly Raspberry PI  */
/*  program incstring.s   */

/* Constantes    */
.equ BUFFERSIZE,   100
.equ STDIN,  0     @ Linux input console
.equ STDOUT, 1     @ Linux output console
.equ EXIT,   1     @ Linux syscall
.equ READ,   3     @ Linux syscall
.equ WRITE,  4     @ Linux syscall
/* Initialized data */
.data
szMessNum:           .asciz "Enter number : \n"
szCarriageReturn:  .asciz "\n"
szMessResult:       .ascii "Increment number is = "      @ message result
sMessValeur:        .fill 12, 1, ' '
                       .asciz "\n"

/* UnInitialized data */
.bss 
sBuffer:    .skip    BUFFERSIZE

/*  code section */
.text
.global main 
main:                /* entry of program  */
    push {fp,lr}    /* saves 2 registers */

    ldr r0,iAdrszMessNum
    bl affichageMess
    mov r0,#STDIN         @ Linux input console
    ldr r1,iAdrsBuffer   @ buffer address 
    mov r2,#BUFFERSIZE   @ buffer size 
    mov r7, #READ         @ request to read datas
    swi 0                  @ call system
    ldr r1,iAdrsBuffer    @ buffer address 
    mov r2,#0                @ end of string
    strb r2,[r1,r0]         @ store byte at the end of input string (r0
    @ 
    ldr r0,iAdrsBuffer    @ buffer address
    bl conversionAtoD    @ conversion string in number in r0
    @ increment r0
    add r0,#1
    @ conversion register to string
    ldr r1,iAdrsMessValeur                
    bl conversion10S       @ call conversion
    ldr r0,iAdrszMessResult
    bl affichageMess            @ display message
    
100:   /* standard end of the program */
    mov r0, #0                  @ return code
    pop {fp,lr}                 @restaur 2 registers
    mov r7, #EXIT              @ request to exit program
    swi 0                       @ perform the system call

iAdrsMessValeur:        .int sMessValeur
iAdrszMessNum:           .int szMessNum
iAdrsBuffer:             .int sBuffer
iAdrszMessResult:       .int szMessResult
iAdrszCarriageReturn:  .int szCarriageReturn
/******************************************************************/
/*     display text with size calculation                         */ 
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
    push {fp,lr}    			/* save  registres */ 
    push {r0,r1,r2,r7}    		/* save others registers */
    mov r2,#0   				/* counter length */
1:      /* loop length calculation */
    ldrb r1,[r0,r2]  			/* read octet start position + index */
    cmp r1,#0       			/* if 0 its over */
    addne r2,r2,#1   			/* else add 1 in the length */
    bne 1b          			/* and loop */
                                /* so here r2 contains the length of the message */
    mov r1,r0        			/* address message in r1 */
    mov r0,#STDOUT      		/* code to write to the standard output Linux */
    mov r7, #WRITE             /* code call system "write" */
    swi #0                      /* call systeme */
    pop {r0,r1,r2,r7}     		/* restaur others registers */
    pop {fp,lr}    				/* restaur des  2 registres */ 
    bx lr	        			/* return  */

 /******************************************************************/
/*     Convert a string to a number stored in a registry          */ 
/******************************************************************/
/* r0 contains the address of the area terminated by 0 or 0A */
/* r0 returns a number                           */
conversionAtoD:
    push {fp,lr}         @ save 2 registers 
    push {r1-r7}         @ save others registers 
    mov r1,#0
    mov r2,#10           @ factor 
    mov r3,#0            @ counter 
    mov r4,r0            @ save address string -> r4 
    mov r6,#0            @ positive sign by default 
    mov r0,#0            @ initialization to 0 
1:     /* early space elimination loop */
    ldrb r5,[r4,r3]     @ loading in r5 of the byte located at the beginning + the position 
    cmp r5,#0            @ end of string -> end routine
    beq 100f
    cmp r5,#0x0A        @ end of string -> end routine
    beq 100f
    cmp r5,#' '          @ space ? 
    addeq r3,r3,#1      @ yes we loop by moving one byte 
    beq 1b
    cmp r5,#'-'          @ first character is -    
    moveq r6,#1         @  1 -> r6
    beq 3f              @ then move on to the next position 
2:   /* beginning of digit processing loop */
    cmp r5,#'0'          @ character is not a number 
    blt 3f
    cmp r5,#'9'          @ character is not a number
    bgt 3f
    /* character is a number */
    sub r5,#48
    umull r0,r1,r2,r0         @ multiply par factor 10 
	cmp r1,#0           @ overflow ?
    bgt 99f            @ overflow error
    add r0,r5            @ add to  r0 
3:
    add r3,r3,#1         @ advance to the next position 
    ldrb r5,[r4,r3]     @ load byte 
    cmp r5,#0            @ end of string -> end routine
    beq 4f
    cmp r5,#0x0A            @ end of string -> end routine
    beq 4f
    b 2b                 @ loop 
4:
    cmp r6,#1            @ test r6 for sign 
    moveq r1,#-1
    muleq r0,r1,r0       @ if negatif, multiply par -1 
    b 100f
99:  /* overflow error */
    ldr r0,=szMessErrDep
    bl   affichageMess
    mov r0,#0      @ return  zero  if error
100:
    pop {r1-r7}          @ restaur other registers 
    pop {fp,lr}          @ restaur   2 registers 
    bx lr                 @return procedure 
/* constante program */	
szMessErrDep:  .asciz  "Too large: overflow 32 bits.\n"
.align 4

/***************************************************/
/*  Converting a register to a signed decimal      */
/***************************************************/
/* r0 contains value and r1 area address    */
conversion10S:
    push {r0-r4,lr}    @ save registers
    mov r2,r1       /* debut zone stockage */
    mov r3,#'+'     /* par defaut le signe est + */
    cmp r0,#0       @ negative number ? 
    movlt r3,#'-'   @ yes
    mvnlt r0,r0     @ number inversion
    addlt r0,#1   
    mov r4,#10       @ length area
1:  @ start loop
    bl divisionpar10
    add r1,#48   @ digit
    strb r1,[r2,r4]  @ store digit on area
    sub r4,r4,#1      @ previous position
    cmp r0,#0          @ stop if quotient = 0
    bne 1b	

    strb r3,[r2,r4]  @ store signe 
    subs r4,r4,#1    @ previous position
    blt  100f        @ if r4 < 0 -> end

    mov r1,#' '   @ space	
2:
    strb r1,[r2,r4]  @store byte space
    subs r4,r4,#1    @ previous position
    bge 2b           @ loop if r4 > 0
100: 
    pop {r0-r4,lr}   @ restaur registers
    bx lr  


/***************************************************/
/*   division par 10   signé                       */
/* Thanks to http://thinkingeek.com/arm-assembler-raspberry-pi/*  
/* and   http://www.hackersdelight.org/            */
/***************************************************/
/* r0 dividende   */
/* r0 quotient */	
/* r1 remainder  */
divisionpar10:	
    /* r0 contains the argument to be divided by 10 */
    push {r2-r4}   /* save registers  */
    mov r4,r0 
    ldr r3, .Ls_magic_number_10 /* r1 <- magic_number */
    smull r1, r2, r3, r0   /* r1 <- Lower32Bits(r1*r0). r2 <- Upper32Bits(r1*r0) */
    mov r2, r2, ASR #2     /* r2 <- r2 >> 2 */
    mov r1, r0, LSR #31    /* r1 <- r0 >> 31 */
    add r0, r2, r1         /* r0 <- r2 + r1 */
    add r2,r0,r0, lsl #2   /* r2 <- r0 * 5 */
    sub r1,r4,r2, lsl #1   /* r1 <- r4 - (r2 * 2)  = r4 - (r0 * 10) */
    pop {r2-r4}
    bx lr                  /* leave function */
    .align 4
.Ls_magic_number_10: .word 0x66666667

Arturo[edit]

num: "12349"

print ["The next number is:" (to :integer num)+1]
Output:
The next number is: 12350

Asymptote[edit]

string cadena = "12345.78";
cadena = string((real)cadena + 1);
write(cadena);
Output:
12346.78

AutoHotkey[edit]

str = 12345
MsgBox % str += 1
Output:
12346

AutoIt[edit]

Global $x = "12345"
$x += 1
MsgBox(0,"",$x)
Output:
12346

Avail[edit]

numberString ::= "1080";
incremented ::= numberString (base 10) + 1;

AWK[edit]

The example shows that the string s can be incremented, but after that still is a string of length 2.

$ awk 'BEGIN{s="42"; s++; print s"("length(s)")" }'
43(2)

BASIC[edit]

Works with: Applesoft BASIC
Works with: BaCon
Works with: BBC BASIC
Works with: QBasic
Works with: PowerBASIC
Works with: Visual Basic
Works with: Liberty BASIC
Works with: Yabasic
s$ = "12345"
s$ = STR$(VAL(s$) + 1)

Applesoft BASIC[edit]

S$ = "12345":S$ =  STR$ ( VAL (S$) + 1)

BASIC256[edit]

cadena$ = "12345"
cadena$ = string(val(cadena$) + 1)
#or also
cadena$ = string(FromRadix(cadena$,10) + 1)

OxygenBasic[edit]

When a number is assigned to a string, it autoconverts.

string s="122"
s=val(s)+1
print s 'result: "123"

True BASIC[edit]

Works with: QBasic
LET cadena$ = "12345"
LET cadena$ = STR$(VAL(cadena$) + 1)
PRINT cadena$
END

Yabasic[edit]

cadena$ = "12345"
cadena$ = str$(val(cadena$) + 1)

IS-BASIC[edit]

100 LET S$="12345"
110 LET S$=STR$(VAL(S$)+1)

ZX Spectrum Basic[edit]

The ZX Spectrum needs line numbers and a let statement, but the same technique can be used:

10 LET s$ = "12345"
20 LET s$ = STR$(VAL(s$) + 1)

Batch File[edit]

Since environment variables have no type distinction all numbers are simply numeric strings:

Works with: Windows NT version 4
set s=12345
set /a s+=1

BBC BASIC[edit]

This assumes the task is about incrementing an arbitrary-length decimal string.

      num$ = "567"
      REPEAT
        PRINT num$
        PROCinc$(num$)
      UNTIL FALSE
      END
      
      DEF PROCinc$(RETURN n$)
      LOCAL A$, I%
      I% = LEN(n$)
      REPEAT
        A$ = CHR$(ASCMID$(n$,I%) + 1)
        IF A$=":" A$ = "0"
        MID$(n$,I%,1) = A$
        I% -= 1
      UNTIL A$<>"0" OR I%=0
      IF A$="0" n$ = "1" + n$
      ENDPROC

Boo[edit]

s = "1234"
s = (int.Parse(s) + 1).ToString()

BQN[edit]

1•Repr∘+•BQN "1234"

Bracmat[edit]

Numbers are strings. Bracmat supports rational numbers, including integers, using arbitrary-precision arithmetic. Pure imaginary numbers are formed using a factor i (or -i). There is no support for floating point arithmetics. (Historically, because the ARM 2 processor in the Archimedes computer didn't sport an FPU.)

(n=35664871829866234762187538073934873121878/6172839450617283945)
&!n+1:?n
&out$!n

   35664871829866234762193710913385490405823/6172839450617283945

Brat[edit]

#Convert to integer, increment, then back to string
p ("100".to_i + 1).to_s  #Prints 101

Burlesque[edit]

ri?ish

C[edit]

Handling strings of arbitrary sizes:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

/*  Constraints: input is in the form of (\+|-)?[0-9]+
 *  and without leading zero (0 itself can be as "0" or "+0", but not "-0");
 *  input pointer is realloc'able and may change;
 *  if input has leading + sign, return may or may not keep it.
 *  The constranits conform to sprintf("%+d") and this function's own output.
 */
char * incr(char *s)
{
	int i, begin, tail, len;
	int neg = (*s == '-');
	char tgt = neg ? '0' : '9';

	/* special case: "-1" */
	if (!strcmp(s, "-1")) {
		s[0] = '0', s[1] = '\0';
		return s;
	}

	len = strlen(s);
	begin = (*s == '-' || *s == '+') ? 1 : 0;

	/* find out how many digits need to be changed */
	for (tail = len - 1; tail >= begin && s[tail] == tgt; tail--);

	if (tail < begin && !neg) {
		/* special case: all 9s, string will grow */
		if (!begin) s = realloc(s, len + 2);
		s[0] = '1';
		for (i = 1; i <= len - begin; i++) s[i] = '0';
		s[len + 1] = '\0';
	} else if (tail == begin && neg && s[1] == '1') {
		/* special case: -1000..., so string will shrink */
		for (i = 1; i < len - begin; i++) s[i] = '9';
		s[len - 1] = '\0';
	} else { /* normal case; change tail to all 0 or 9, change prev digit by 1*/
		for (i = len - 1; i > tail; i--)
			s[i] = neg ? '9' : '0';
		s[tail] += neg ? -1 : 1;
	}

	return s;
}

void string_test(const char *s)
{
	char *ret = malloc(strlen(s));
	strcpy(ret, s);

	printf("text: %s\n", ret);
	printf("  ->: %s\n", ret = incr(ret));
	free(ret);
}

int main()
{
	string_test("+0");
	string_test("-1");
	string_test("-41");
	string_test("+41");
	string_test("999");
	string_test("+999");
	string_test("109999999999999999999999999999999999999999");
	string_test("-100000000000000000000000000000000000000000000");

	return 0;
}
Output:

text: +0

 ->: +1

text: -1

 ->: 0

text: -41

 ->: -40

text: +41

 ->: +42

text: 999

 ->: 1000

text: +999

 ->: 1000

text: 109999999999999999999999999999999999999999

 ->: 110000000000000000000000000000000000000000

text: -100000000000000000000000000000000000000000000

->: -99999999999999999999999999999999999999999999

C#[edit]

string s = "12345";
s = (int.Parse(s) + 1).ToString();
// The above functions properly for strings >= Int32.MinValue and
//  < Int32.MaxValue. ( -2147483648 to 2147483646 )

// The following will work for any arbitrary-length integer string.
//  (Assuming that the string fits in memory, leaving enough space
//  for the temporary BigInteger created, plus the resulting string):
using System.Numerics;
string bis = "123456789012345678999999999";
bis = (BigInteger.Parse(bis) + 1).ToString();
// Note that extremely long strings will take a long time to parse
//  and convert from a BigInteger back into a string.

C++[edit]

// standard C++ string stream operators
#include <cstdlib>
#include <string>
#include <sstream>

// inside a function or method...
std::string s = "12345";

int i;
std::istringstream(s) >> i;
i++;
//or:
//int i = std::atoi(s.c_str()) + 1;

std::ostringstream oss;
if (oss << i) s = oss.str();
Works with: C++11
#include <string>

std::string s = "12345";
s = std::to_string(1+std::stoi(s));
Library: Boost
// Boost
#include <cstdlib>
#include <string>
#include <boost/lexical_cast.hpp>

// inside a function or method...
std::string s = "12345";
int i = boost::lexical_cast<int>(s) + 1;
s = boost::lexical_cast<std::string>(i);
Library: Qt
Uses: Qt (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/Qt/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})
// Qt
QString num1 = "12345";
QString num2 = QString("%1").arg(v1.toInt()+1);
Library: MFC
Uses: Microsoft Foundation Classes (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/Microsoft Foundation Classes/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})
Uses: C Runtime (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/C Runtime/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})
// MFC
CString s = "12345";
int i = _ttoi(s) + 1;
int i = _tcstoul(s, NULL, 10) + 1; 
s.Format("%d", i);

All of the above solutions only work for numbers <= INT_MAX. The following works for an (almost) arbitrary large number:

Works with: g++ version 4.0.2
#include <string>
#include <iostream>
#include <ostream>

void increment_numerical_string(std::string& s)
{
    std::string::reverse_iterator iter = s.rbegin(), end = s.rend();
    int carry = 1;
    while (carry && iter != end)
    {
        int value = (*iter - '0') + carry;
        carry = (value / 10);
        *iter = '0' + (value % 10);
        ++iter;
    }
    if (carry)
        s.insert(0, "1");
}

int main()
{
    std::string big_number = "123456789012345678901234567899";
    std::cout << "before increment: " << big_number << "\n";
    increment_numerical_string(big_number);
    std::cout << "after increment:  " << big_number << "\n";
}

Ceylon[edit]

shared void run() {
	
	"Increments a numeric string by 1. Returns a float or integer depending on the string. 
	 Returns null if the string isn't a number."
	function inc(String string) => 
			if(exists integer = parseInteger(string)) then integer + 1
			else if(exists float = parseFloat(string)) then float + 1.0
			else null;
	
	value a = "1";
	print(a);
	value b = inc(a);
	print(b);
	value c = "1.0";
	print(c);
	value d = inc(c);
	print(d);
}

Clojure[edit]

(str (inc (Integer/parseInt "1234")))

CMake[edit]

CMake performs all arithmetic with numeric strings, through its math() command.

set(string "1599")
math(EXPR string "${string} + 1")
message(STATUS "${string}")
-- 1600

COBOL[edit]

       PROGRAM-ID. increment-num-str.
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01  str                    PIC X(5) VALUE "12345".
       01  num                    REDEFINES str PIC 9(5).
       
       PROCEDURE DIVISION.
           DISPLAY str
           ADD 1 TO num
           DISPLAY str

           GOBACK
           .

The following example also increments a numerical string, although it does not apear to. num-str is implicitly defined as USAGE DISPLAY which means its contents will be stored as characters. This means num-str is effectively a string of (numeric) characters.

       PROGRAM-ID. increment-num-str.
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01  num-str                PIC 9(5) VALUE 12345.
       
       PROCEDURE DIVISION.
           DISPLAY num-str
           ADD 1 TO num-str
           DISPLAY num-str
       
           GOBACK
           .

Common Lisp[edit]

(princ-to-string (1+ (parse-integer "1234")))

Component Pascal[edit]

BlackBox Component Builder

MODULE Operations;
IMPORT StdLog,Args,Strings;

PROCEDURE IncString(s: ARRAY OF CHAR): LONGINT;
VAR
	resp: LONGINT;
	done: INTEGER;
BEGIN
	Strings.StringToLInt(s,resp,done);
	INC(resp);
	RETURN resp
END IncString;

PROCEDURE DoIncString*;
VAR
	p: Args.Params;
BEGIN
	Args.Get(p);
	IF p.argc > 0 THEN
		StdLog.String(p.args[0] + " + 1= ");StdLog.Int(IncString(p.args[0]));StdLog.Ln
	END
END DoIncString;

END Operations.

Execute: ^Q Operatiosn.DoIncString 124343~

Output:
124343 + 1=  124344

D[edit]

void main() {
    import std.string;

    immutable s = "12349".succ;
    assert(s == "12350");
}

Delphi[edit]

program IncrementNumericalString;

{$APPTYPE CONSOLE}

uses SysUtils;

const
  STRING_VALUE = '12345';
begin
  WriteLn(Format('"%s" + 1 = %d', [STRING_VALUE, StrToInt(STRING_VALUE) + 1]));

  Readln;
end.
Output:
"12345" + 1 = 123456

Dyalect[edit]

var str = "42"
str = (parse(str) + 1).ToString()

//Another option:
str = (Integer(str) + 1).ToString()

//And another option using interpolation:
str = "\(parse(str) + 1)"

print(str) //Outputs 45

DWScript[edit]

var value : String = "1234";
value := IntToStr(StrToInt(value) + 1);
PrintLn(value);

Déjà Vu[edit]

 !. to-str ++ to-num "100"
Output:
"101"

E[edit]

__makeInt("1234", 10).next().toString(10)

EasyLang[edit]

a$ = "12"
a$ = number a$ + 1
print a$

EchoLisp[edit]

(number->string (1+ (string->number "665")))
     "666"

Ecstasy[edit]

Ecstasy provides two types that represent various numbers as if they were String values: IntLiteral and FPLiteral. For example:

String s = "12345";
IntLiteral lit1 = new IntLiteral(s);
IntLiteral lit2 = 6789;
++lit1; // lit1=12346
++lit2; // lit2=6790

Eero[edit]

#import <Foundation/Foundation.h>

int main()

  i := (int)'123' + 1
  s := @(i).description

  Log( '%@', s )
  return 0

EGL[edit]

s string = "12345";
s = 1 + s;  // Note: s + 1 is a string concatenation.

Eiffel[edit]

class
	APPLICATION

create
	make

feature {NONE}

	make
		do
			io.put_string (increment_numerical_string ("7"))
			io.new_line
			io.put_string (increment_numerical_string ("99"))
		end

	increment_numerical_string (s: STRING): STRING
			-- String 's' incremented by one.
		do
			Result := s.to_integer.plus (1).out
		end

end

Output:

8

100

Elena[edit]

ELENA 4.x:

import extensions;
 
public program()
{
    var s := "12345";
    s := (s.toInt() + 1).toString();
 
    console.printLine(s)
}
Output:
12346

Elixir[edit]

Values can be converted to integers then converted back after incrementing

increment1 = fn n -> to_string(String.to_integer(n) + 1) end
# Or piped
increment2 = fn n -> n |> String.to_integer |> +1 |> to_string end

increment1.("1")
increment2.("100")
Output:
"2"
"101"


Case of char list:

iex(1)> (List.to_integer('12345') + 1) |> to_char_list
'12346'

Emacs Lisp[edit]

(1+ (string-to-number "12345"))

Erlang[edit]

integer_to_list(list_to_integer("1336")+1).

ERRE[edit]

   ....................
    s$="12345"
    s$=STR$(VAL(s$)+1)
   ....................

Euphoria[edit]

include get.e

function val(sequence s)
    sequence x
    x = value(s)
    return x[2]
end function

sequence s

s = "12345"
s = sprintf("%d",{val(s)+1})

F#[edit]

let next = string( int( "1234" ) + 1 )

Factor[edit]

"1234" string>number 1 + number>string

Fantom[edit]

Within 'fansh':

fansh> a := "123"
123
fansh> (a.toInt + 1).toStr
124

Forth[edit]

This word causes the number whose string value is stored at the given location to be incremented. The address passed must contain enough space to hold the string representation of the new number. Error handling is rudimentary, and consists of aborting when the string does not contain a numerical value.

The word ">string" takes and integer and returns the string representation of that integer. I factored it out of the definitions below to keep the example simpler.

: >string ( d -- addr n )
  dup >r dabs <# #s r> sign #> ;

: inc-string ( addr -- )
  dup count number? not abort" invalid number"
  1 s>d d+ >string rot place ;

Here is a version that can increment by any value

: inc-string ( addr n -- )
  over count number? not abort" invalid number"
  rot s>d d+  >string rot place ;

Test the first version like this:

s" 123" pad place
pad inc-string
pad count type

And the second one like this:

s" 123" pad place
pad 1 inc-string
pad count type

Fortran[edit]

Works with: Fortran version 90 and later

Using 'internal' files you can increment both integer and real strings

CHARACTER(10) :: intstr = "12345", realstr = "1234.5"
INTEGER :: i
REAL :: r
 
READ(intstr, "(I10)") i        ! Read numeric string into integer i
i = i + 1                      ! increment i
WRITE(intstr, "(I10)") i       ! Write i back to string

READ(realstr, "(F10.1)") r 	
r = r + 1.0				
WRITE(realstr, "(F10.1)") r

FreeBASIC[edit]

' FB 1.05.0 Win64

Function Increment (num As String) As String
  Dim d As Double = Val(num)
  Return Str(d + 1.0)
End Function

Dim num(5) As String = {"1", "5", "81", "123.45", "777.77", "1000"}
For i As Integer = 0 To 5
  Print num(i); " + 1", " = "; Increment(num(i))
Next

Print
Print "Press any key to exit"
Sleep
Output:
1 + 1          = 2
5 + 1          = 6
81 + 1         = 82
123.45 + 1     = 124.45
777.77 + 1     = 778.77
1000 + 1       = 1001

Frink[edit]

The following works for integers, rational numbers, complex numbers, floating-point, etc.

a = input["Enter number: "]
toString[eval[a] + 1]

FutureBasic[edit]

include "NSLog.incl"

CFStringRef s = @"12345"
NSInteger   i

for i = 1 to 10
NSLog( @"%ld", fn StringIntegerValue( s ) + i )
next
HandleEvents

Output:

 12346
 12347
 12348
 12349
 12350
 12351
 12352
 12353
 12354
 12355

Fōrmulæ[edit]

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website, However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.

In this page you can see the program(s) related to this task and their results.

Gambas[edit]

Click this link to run this code

Public Sub Main()
Dim vInput As Variant = "12345" 

Inc vInput
Print vInput

End

Output:

12346

GAP[edit]

# Using built-in functions
Incr := s -> String(Int(s) + 1);

# Implementing addition
# (but here 9...9 + 1 = 0...0 since the string length is fixed)
Increment := function(s)
  local c, n, carry, digits;
  digits := "0123456789";
  n := Length(s);
  carry := true;
  while n > 0 and carry do
    c := Position(digits, s[n]) - 1; 
    if carry then
      c := c + 1;
    fi;
    if c > 9 then
      carry := true;
      c := c - 10;
    else
      carry := false;
    fi;
    s[n] := digits[c + 1];
    n := n - 1;
  od;
end;

s := "2399";
Increment(s);
s;
# "2400"

Go[edit]

Concise:

package main
import "fmt"
import "strconv"
func main() {
  i, _ := strconv.Atoi("1234")
  fmt.Println(strconv.Itoa(i + 1))
}

More:

package main

import (
    "math/big"
    "fmt"
    "strconv"
)

func main() {
    // integer
    is := "1234"
    fmt.Println("original:   ", is)
    i, err := strconv.Atoi(is)
    if err != nil {
        fmt.Println(err)
        return
    }
    // assignment back to original variable shows result is the same type.
    is = strconv.Itoa(i + 1)
    fmt.Println("incremented:", is)

    // error checking worthwhile
    fmt.Println()
    _, err = strconv.Atoi(" 1234") // whitespace not allowed
    fmt.Println(err)
    _, err = strconv.Atoi("12345678901")
    fmt.Println(err)
    _, err = strconv.Atoi("_1234")
    fmt.Println(err)
    _, err = strconv.ParseFloat("12.D34", 64)
    fmt.Println(err)

    // float
    fmt.Println()
    fs := "12.34"
    fmt.Println("original:   ", fs)
    f, err := strconv.ParseFloat(fs, 64)
    if err != nil {
        fmt.Println(err)
        return
    }
    // various options on FormatFloat produce different formats.  All are valid
    // input to ParseFloat, so result format does not have to match original
    // format.  (Matching original format would take more code.)
    fs = strconv.FormatFloat(f+1, 'g', -1, 64)
    fmt.Println("incremented:", fs)
    fs = strconv.FormatFloat(f+1, 'e', 4, 64)
    fmt.Println("what format?", fs)

    // complex
    // strconv package doesn't handle complex types, but fmt does.
    // (fmt can be used on ints and floats too, but strconv is more efficient.)
    fmt.Println()
    cs := "(12+34i)"
    fmt.Println("original:   ", cs)
    var c complex128
    _, err = fmt.Sscan(cs, &c)
    if err != nil {
        fmt.Println(err)
        return
    }
    cs = fmt.Sprint(c + 1)
    fmt.Println("incremented:", cs)

    // big integers have their own functions
    fmt.Println()
    bs := "170141183460469231731687303715884105728"
    fmt.Println("original:   ", bs)
    var b, one big.Int
    _, ok := b.SetString(bs, 10)
    if !ok {
        fmt.Println("big.SetString fail")
        return
    }
    one.SetInt64(1)
    bs = b.Add(&b, &one).String()
    fmt.Println("incremented:", bs)
}
Output:
original:    1234
incremented: 1235

strconv.ParseInt: parsing " 1234": invalid syntax
strconv.ParseInt: parsing "12345678901": value out of range
strconv.ParseInt: parsing "_1234": invalid syntax
strconv.ParseFloat: parsing "12.D34": invalid syntax

original:    12.34
incremented: 13.34
what format? 1.3340e+01

original:    (12+34i)
incremented: (13+34i)

original:    170141183460469231731687303715884105728
incremented: 170141183460469231731687303715884105729

Golfscript[edit]

~)`

With a test framework to supply a number:

"1234" ~)` p

Groovy[edit]

Solution:

println ((("23455" as BigDecimal) + 1) as String)
println ((("23455.78" as BigDecimal) + 1) as String)
Output:
23456
23456.78

Haskell[edit]

(show . (+1) . read) "1234"

or, for Integral values, we can use the Prelude's succ function:

(show . succ) (read "1234" :: Int)

and to extend the range of a succString function to allow for both floating point and integral numeric strings, for non-numeric noise, for multiple numeric expressions within a single string, and for an option to retain or prune any non-numeric noise, we could write things like:

Translation of: Python
import Text.Read (readMaybe)
import Data.Maybe (mapMaybe)

succString :: Bool -> String -> String
succString pruned s =
  let succs
        :: (Num a, Show a)
        => a -> Maybe String
      succs = Just . show . (1 +)
      go w
        | elem '.' w = (readMaybe w :: Maybe Double) >>= succs
        | otherwise = (readMaybe w :: Maybe Integer) >>= succs
      opt w
        | pruned = Nothing
        | otherwise = Just w
  in unwords $
     mapMaybe
       (\w ->
           case go w of
             Just s -> Just s
             _ -> opt w)
       (words s)


-- TEST ---------------------------------------------------
main :: IO ()
main =
  (putStrLn . unlines) $
  succString <$> [True, False] <*>
  pure "41.0 pine martens in 1491 -1.5 mushrooms ≠ 136"
Output:
42.0 1492 -0.5 137
42.0 pine martens in 1492 -0.5 mushrooms ≠ 137

HicEst[edit]

CHARACTER string = "123     -4567.89"

   READ( Text=string) a,   b
   WRITE(Text=string) a+1, b+1 ! 124 -4566.89

HolyC[edit]

I8 *s;

s = "10";
s = Str2I64(s) + 1;
Print("%d\n", s);

s = "-10";
s = Str2I64(s) + 1;
Print("%d\n", s);

Hy[edit]

(str (inc (int "123")))

Alternatively, with the "threading" macro:

(-> "123" (int) (inc) (str))

HyperTalk[edit]

put 0 into someVar
add 1 to someVar
-- without "into [field reference]" the value will appear
-- in the message box
put someVar -- into cd fld 1

i[edit]

software {
	string = "1"
	string += 1
	print(string)
}

Icon and Unicon[edit]

Icon and Unicon will automatically coerce type conversions where they make sense. Where a conversion can't be made to a required type a run time error is produced.

s := "123"  # s is a string
s +:= 1     # s is now an integer

IDL[edit]

str = '1234'
print, string(fix(str)+1)
;==>   1235

In fact, IDL tries to convert types cleverly. That works, too:

print, '1234' + 1
;==>    1235

Inform 7[edit]

This solution works for numbers that fit into a single word (16-bit signed int for Z-machine, 32-bit signed int for Glulx virtual machine).

Home is a room.

To decide which indexed text is incremented (T - indexed text):
	let temp be indexed text;
	let temp be the player's command;
	change the text of the player's command to T;
	let N be a number;
	if the player's command matches "[number]":
		let N be the number understood;
	change the text of the player's command to temp;
	decide on "[N + 1]".

When play begins:
	say incremented "12345";
	end the story.

Io[edit]

str := ("123" asNumber + 1) asString

J[edit]

incrTextNum=: >:&.".

Note that in addition to working for a single numeric value, this will increment multiple values provided within the same string, on a variety of number types and formats including rational and complex numbers (though mixing these notations will coerce all values in the list to a lowest common denominator type).

   incrTextNum '34.5'
35.5
   incrTextNum '7 0.2 3r5 2j4 5.7e_4'
8 1.2 1.6 3j4 1.00057

Note also that the result here is a list of characters, and not a list of integers, which becomes obvious when you manipulate the result. For example, consider the effect of reversing the contents of the list:

   |.incrTextNum'123 456'
754 421
   |.1+123 456
457 124

Java[edit]

When using Integer.parseInt in other places, it may be beneficial to call trim on the String, since parseInt will throw an Exception if there are spaces in the String.

String s = "12345";
s = String.valueOf(Integer.parseInt(s) + 1);

Another solution that works with big decimal numbers:

String s = "123456789012345678901234567890.12345";
s = new BigDecimal(s).add(BigDecimal.ONE).toString();

JavaScript[edit]

ES6[edit]

Using implicit coercion:

let s = '9999';
let splusplus = (+s+1)+""

console.log([splusplus, typeof splusplus]) // 10000,string

Or, expanding the range of a stringSucc function to allow for non-numeric noise, and also for multiple numeric expressions in a single string:

Translation of: Python
Translation of: Haskell
(() => {
    'use strict';

    // succString :: Bool -> String -> String
    const succString = blnPruned => s => {
        const go = w => {
            const
                v = w.includes('.') ? (
                    parseFloat(w)
                ) : parseInt(w);
            return isNaN(v) ? (
                blnPruned ? [] : [w]
            ) : [(1 + v).toString()];
        };
        return unwords(concatMap(go, words(s)));
    };

    // TEST -----------------------------------------------
    const main = () =>
        console.log(
            unlines(
                ap(
                    map(succString, [true, false]),
                    ['41 pine martens in 1491.3 -1.5 mushrooms ≠ 136']
                )
            )
        );


    // GENERIC FUNCTIONS ----------------------------------

    // Each member of a list of functions applied to each
    // of a list of arguments, deriving a list of new values.

    // ap (<*>) :: [(a -> b)] -> [a] -> [b]
    const ap = (fs, xs) => //
        fs.reduce((a, f) => a.concat(
            xs.reduce((a, x) => a.concat([f(x)]), [])
        ), []);

    // concatMap :: (a -> [b]) -> [a] -> [b]
    const concatMap = (f, xs) =>
        xs.reduce((a, x) => a.concat(f(x)), []);

    // map :: (a -> b) -> [a] -> [b]
    const map = (f, xs) => xs.map(f);

    // unlines :: [String] -> String
    const unlines = xs => xs.join('\n');

    // unwords :: [String] -> String
    const unwords = xs => xs.join(' ');

    // words :: String -> [String]
    const words = s => s.split(/\s+/);

    // MAIN ---
    return main();
})();
Output:
42 1492.3 -0.5 137
42 pine martens in 1492.3 -0.5 mushrooms ≠ 137

jq[edit]

tonumber[edit]

jq's string-to-number filter is called tonumber. For example, if we have a file named input.txt consisting of string representations of numbers, one per line, we could compute the sum as follows:

$ jq -n -M -s 'map(tonumber) | add' input.txt

More precisely, tonumber will convert string representations of JSON numbers (integers and decimals) to numbers, but very large integers will be converted to decimals with possible loss of precision, and similar problems will be noticeable for very small and very large decimals.

tostring can be used to convert numbers to strings.

long_add[edit]

# This function assumes its string arguments represent non-negative decimal integers.
def long_add(num1; num2):
  if (num1|length) < (num2|length) then long_add(num2; num1)
  else  (num1 | explode | map(.-48) | reverse) as $a1
      | (num2 | explode | map(.-48) | reverse) as $a2
      | reduce range(0; num1|length) as $ix
          ($a2;  # result
           ( $a1[$ix] + .[$ix] ) as $r
           | if $r > 9 # carrying
             then
               .[$ix + 1] = ($r / 10 | floor) +
                 (if $ix + 1 >= length then 0 else .[$ix + 1] end )
               | .[$ix] = $r - ( $r / 10 | floor ) * 10
             else
               .[$ix] = $r
             end )
      | reverse | map(.+48) | implode
  end ;

Example

long_add("9" * 100; "1")
Output:
"10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"

Jsish[edit]

var a = "1"
a = String(Number(a) + 1)

Julia[edit]

import Base.+
Base.:+(s::AbstractString, n::Real) = string((x = tryparse(Int, s)) isa Int ? x + 1 : parse(Float64, s) + 1)
@show "125" + 1
@show "125.15" + 1
@show "1234567890987654321" + 1
Output:
"125" + 1 = "126"
"125.15" + 1 = "126.15"
"1234567890987654321" + 1 = "1234567890987654322"

K[edit]

"." is a built-in function that evaluates a valid K expression.

   1 + ."1234"
1235
   1 + ."1234.56"
1235.56

   / As a function
   inc:{1 + . x}
   inc "1234"
1235

Some other examples.

   1 + .:' ("1";"2";"3";"4")
2 3 4 5

   1 + . "123 456"
124 457

   . "1","+","-10"
-9

Kotlin[edit]

// version 1.0.5-2

/** overload ++ operator to increment a numeric string */
operator fun String.inc(): String =
    try {
        val num = this.toInt()
        (num + 1).toString()
    }
    catch(e: NumberFormatException) {
        this  // return string unaltered
    }

fun main(args: Array<String>) {
    var ns = "12345"
    println(++ns)
    ns = "ghijk"  // not numeric, so won't be changed by increment operator
    println(++ns)
}
Output:
12346
ghijk

Lambdatalk[edit]

In lambdatalk every expression is a word or an S-expression, so:

{b hello world}     // means "boldify the words hello and world"
-> < b>hello world< /b>     // HTML expression

{+ hello world}     // means "add the words hello and world"
-> NaN              // can't do the job and returns Not a Number

{+ 123 1}           // means "add the words 123 and 1"
-> 124              // can do the job and returns the result as a word

LabVIEW[edit]

This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
LabVIEW Increment a numerical string.png

Lasso[edit]

(integer('123') + 1) -> asstring

-> 124

LaTeX[edit]

\documentclass{minimal}
\newcounter{tmpnum}
\newcommand{\stringinc}[1]{%
    \setcounter{tmpnum}{#1}%
    \stepcounter{tmpnum}%
    \arabic{tmpnum}%
}
\begin{document}
The number 12345 is followed by \stringinc{12345}.
\end{document}

Liberty BASIC[edit]

'   [RC] Increment a numerical string.

o$ ="12345"
print o$

v  =val( o$)
o$ =str$( v +1)
print o$

end

LIL[edit]

##
   Increment a numerical string, in LIL
##
set a "41"
inc a
print $a
Output:
prompt$ lil incrementNumericalString.lil
42

Lingo[edit]

put integer("123")+1
-- 124

LiveCode[edit]

LiveCode casts types transparently. When storing a number in a variable, the internal representation is numeric (a double, I think), and if the variable is used as a number, there is no type conversion. If the variable is used as a string, the conversion is automatic; likewise if a string variable containing a number is used as a number:

put "0" & "1234" into myString -- I think this will result in an internal string representation
add 1 to myString -- automatically converts to a number
put "The number is:" && myString
-- outputs "The number is: 1235"

[edit]

Logo is weakly typed, so numeric strings can be treated as numbers and numbers can be treated as strings.

show "123 + 1  ; 124
show word? ("123 + 1) ;  true

Logtalk[edit]

number_chars(Number, "123"), Number2 is Number+1, number_chars(Number2, String2)

LOLCODE[edit]

LOLCODE is weakly typed, so the arithmetic operators work "as expected" on strings.

HAI 1.3

I HAS A foo ITZ "1234"
foo R SUM OF foo AN 1
VISIBLE foo BTW, prints 1235

KTHXBYE

LSL[edit]

To test it yourself; rez a box on the ground, and add the following as a New Script.

default {
	state_entry() {
		llListen(PUBLIC_CHANNEL, "", llGetOwner(), "");
		llOwnerSay("Say a Number and I'll Increment it.");
	}
	listen(integer iChannel, string sName, key kId, string sMessage) {
		llOwnerSay("You said '"+sMessage+"' + 1 = "+(string)(((integer)sMessage)+1));
	}
}
Output:
Increment_a_Numerical_String: You said '99999999' + 1 = 100000000
Increment_a_Numerical_String: You said '-100000000' + 1 = -99999999

Lua[edit]

Lua will attempt an implicit type conversion if an arithmetic operator is used with a string. This is illustrated by the following interactive session (revised for Lua 5.4):

> -- A STRING THAT CAN BE IMPLICITLY CONVERTED TO A NUMBER
> s = "1234"
> s+1 -- implicitly convert to number, add 1, remain a number
1235
> type(s+1)
number
> (s+1)..'' -- implicitly convert to number, add 1, implicitly convert back to string
1235
> type((s+1)..'')
string
> tostring(s+1) -- implicitly convert to number, add 1, explicitly convert back to string
1235
> type(tostring(s+1))
string
> -- A STRING THAT CANNOT BE IMPLICITLY CONVERTED TO A NUMBER
> s = "hello"
> s+1
stdin:1: attempt to add a 'string' with a 'number'
stack traceback:
        [C]: in metamethod 'add'
        stdin:1: in main chunk
        [C]: in ?
> -- ONE-LINER EXPLICIT VERSION
> tostring(tonumber("1234")+1)
1235

M2000 Interpreter[edit]

Using Str$( stringexpr, "") we trim leading space for positive numbers. We can use a number as locale id, 1032 for Greece, so Str$(12.1212, 1032) return without leading space "12,1212".

Str$(mumberexpression) return always dot for decimal point Val(stringexpression) read dot as decimal point Val(stringexpression, ",") use "," as decimal point Val(stringexpression, 1032) use Locale 1032 (maybe this can change by OS user), so we get "." or "," (the later is by default the decimal point for 1032).

We can use Eval("1212211212122112215@") which evaluate expressions in strings (among other duties when we use objects), and we can use letters to indicate the type of number Val can return type using a special form, using a numeric expression as first parameter: Local m=Val(112+1.12->Decimal) make a new variable m type of decimal (96-bit integer with a variable power of 10).

Module CheckIt {
      s$ = "12345"
      s$ = STR$(VAL(s$) + 1,"")
      Print S$
      \\ using , for decimal point like in Locale 1032 for Greece
      s$ = "123,45"
      \\ we get value in Locale 1032
      S$=Str$(VAL(s$,",") + 1, 1032)
}
CheckIt

M4[edit]

M4 can handle only integer signed 32 bit numbers, and they can be only written as strings

define(`V',`123')dnl
define(`VN',`-123')dnl
eval(V+1)
eval(VN+1)

If the expansion of any macro in the argument of eval gives something that can't be interpreted as an expression, an error is raised (but the interpretation of the whole file is not stopped)

Maple[edit]

s := "12345";
s := convert(parse(s)+1, string);

Mathematica / Wolfram Language[edit]

FromDigits["1234"] + 1

MATLAB[edit]

function numStr = incrementNumStr(numStr)
    numStr = num2str(str2double(numStr) + 1);
end

MAXScript[edit]

str = "12345"
str = ((str as integer) + 1) as string

Metafont[edit]

string s;
s := "1234";
s := decimal(scantokens(s)+1);
message s;

min[edit]

Works with: min version 0.19.3
(int succ string) :next

MIPS Assembly[edit]

Translation of: Z80 Assembly
.include "\SrcAll\Header.asm"   ;defines the UserRam label (address 0xA0001000 on N64)
.include "\SrcAll\BasicMacros.asm"
.include "\SrcALL\AdvancedMacros.asm"
.include "\SrcALL\MemoryMap.asm"

CursorX equ 0x100 ;offset from label UserRam, used for tracking where to print to the tv screen
CursorY equ 0x101 ;offset from label UserRam, used for tracking where to print to the tv screen
main:
	;copy the string to ram.
	la $t0,0x00393939	;store 0,0x39,0x39,0x39 ;n64 is big-endian
	la $t1,0x31000000	
	
	la $t2,UserRam
	sw $t0,0($t2)
	nop
	sw $t1,4($t2)
	nop
	
	;string ram now looks like this:
	;	byte 0
	;	byte "9991"
	;	byte 0
	; it was more convenient to store the numeric string little-endian,
        ; the leading terminator lets us easily print it in reverse.
	

	la $t1,UserRam+1	;read past the terminator placed at the front.
	li $t2,0x3A
incStr:
	lbu $t0,($t1)
	beqz $t0,display
	nop
	addiu $t0,1
	bltu $t0,$t2,noCarry
	nop
	;carry it forward
	li $t0,0x30
	sb $t0,($t1)
	addiu $t1,1
	j incStr
	nop
	
noCarry:
	sb $t0,($t1)
	addiu $t1,1
	j incStr
	
display:
	la $t1,UserRam+4
display_loop:
	lbu $t0,($t1)
	beqz $t0,shutdown
	nop
	move $a1,$t0
	jal PrintChar       ;takes $a1 as argument, prints the ascii character in $a1 to the television screen
	nop
	subiu $t1,1
	j display_loop
        nop
shutdown:
	nop                 ;not required on real hardware, but project 64 throws a fit if I don't have this.
	b shutdown
	nop
Output:
2000


mIRC Scripting Language[edit]

var %n = 12345
inc %n
echo -ag %n

ML[edit]

mLite[edit]

ntos ` ston "1234" + 1;

Standard ML[edit]

Int.toString (1 + valOf (Int.fromString "1234"))

Modula-2[edit]

MODULE addstr;

IMPORT  InOut, NumConv, Strings;

VAR     str1, str2      : Strings.String;
        num             : CARDINAL;
        ok              : BOOLEAN;

BEGIN
  str1 := "12345";
  InOut.Write ('"');    InOut.WriteString (str1);       InOut.WriteString ('" + 1 = ');
  NumConv.Str2Num (num, 10, str1, ok);
  INC (num);
  NumConv.Num2Str (num, 10, str2,  ok);
  InOut.WriteString (str2);
  InOut.WriteLn
END addstr.
"12345" + 1 = 12346

Modula-3[edit]

Modula-3 provides the module Scan for lexing.

MODULE StringInt EXPORTS Main;

IMPORT IO, Fmt, Scan;

VAR string: TEXT := "1234";
    num: INTEGER := 0;

BEGIN
  num := Scan.Int(string);
  IO.Put(string & " + 1 = " & Fmt.Int(num + 1) & "\n");
END StringInt.
Output:
1234 + 1 = 1235

MUMPS[edit]

Just add. MUMPS has strings of characters as its native datatype. The "+" (plus) binary operator interprets its two arguments as numbers, so the MUMPS system does incrementing a string naturally. MUMPS portability standards require that the result must have at least 15 significant digits. Some implementations use Binary Coded Digits (BCD) and long fixed point (64 bit) integers to accomplish this.

 SET STR="123"
 WRITE STR+1

Nanoquery[edit]

num = "123"
num = str(int(num) + 1)

Neko[edit]

var str = "123";
var str = $string($int(str) + 1);

$print(str);

Nemerle[edit]

mutable str = "12345";
str = $"$(Int32.Parse(str)+1)";

NetRexx[edit]

In concert with Rexx, NetRexx can use typeless variables. Typeless variable support is provided through the default NetRexx Rexx object. Values are stored as variable length character strings and can be treated as either a string or a numeric value, depending on the context in which they are used.

/* NetRexx */

options replace format comments java crossref savelog symbols nobinary

numbers = '12345'
say numbers
numbers = numbers + 1
say numbers

return
Output:
12345
12346

NewLISP[edit]

(string (++ (int "123")))

Nim[edit]

import strutils
let next = $(parseInt("123") + 1)

NS-HUBASIC[edit]

10 S$ = "12345"
20 S$ = STR$(VAL(s$) + 1)

Oberon-2[edit]

MODULE addstr;

IMPORT  Out, Strings;

VAR     str1, str2      : ARRAY 9 OF CHAR;
        num, pos        : INTEGER;
        carry           : BOOLEAN;
        ch              : CHAR;

BEGIN
  str1 := "9999";
  Out.Char ('"');       Out.String (str1);      Out.String ('" + 1 = ');
  num := Strings.Length (str1) - 1;
  pos := num;
  IF  str1 [0] = '9'  THEN  INC (pos)  END;
  str2 [pos + 1] := 0X;
  carry := TRUE;
  REPEAT
    ch := str1 [num];
    IF  carry  THEN
      ch := CHR (ORD (ch) + 1)
    END;
    IF  ch > '9'  THEN
      carry := TRUE;
      ch := '0'
    ELSE
      carry := FALSE
    END;
    str2 [pos] := ch;
    DEC (num);
    DEC (pos)
  UNTIL num < 0;
  IF  carry  THEN  str2 [0] := '1'  END;
  Out.String (str2);
  Out.Ln
END addstr.

Producing:

jan@Beryllium:~/Oberon/obc$ Add
"12345" + 1 = 12346
"9999" + 1 = 10000

Objeck[edit]

s := "12345";
i := int->ToInt(s) + 1;
s := i->ToString();

Objective-C[edit]

NSString *s = @"12345";
int i = [s intValue] + 1;
s = [NSString stringWithFormat:@"%i", i]

OCaml[edit]

string_of_int (succ (int_of_string "1234"))

Octave[edit]

We convert the string to a number, increment it, and convert it back to a string.

nstring = "123";
nstring = sprintf("%d", str2num(nstring) + 1);
disp(nstring);

Oforth[edit]

+ on strings is a concatenation, not an addition. To increment, the string is converted as integer then as string again.

"999" 1 + println
"999" asInteger 1 + asString println
Output:
9991
1000

OoRexx[edit]

ooRexx supports the += etc. operators:

i=1
i+=1
Say i
Output:
2

OpenEdge/Progress[edit]

DEFINE VARIABLE cc AS CHARACTER INITIAL "12345".

MESSAGE 
   INTEGER( cc ) + 1 
VIEW-AS ALERT-BOX.

Oz[edit]

{Int.toString {String.toInt "12345"} + 1}

PARI/GP[edit]

foo(s)=Str(eval(s)+1);

Pascal[edit]

See also Free Pascal and Delphi

Works with: Extended Pascal
program TestIncNumString;
type
	tMyNumString = string(20);

procedure IncMyString(var NumString: tMyNumString);
var
	i: integer;
begin
	readStr(NumString, i);
	writeStr(NumString, succ(i))
end;
//example 
var
  MyNumString :tMyNumString;
BEGIN
  MyNumString := '12345';
  write(MyNumString,' turns into ');
  IncMyString(MyNumString);
  write(MyNumString);
END.
Output:
12345 turns into 12346

Free Pascal[edit]

not like Delphi doing two conversion, but increment a string by 1 is much faster. Here with different bases upto 10.After this there must be a correction to convert values > '9' to 'A'... Only for positive integer strings as high speed counter.

program StrInc;
//increments a positive numerical string in different bases.
//the string must be preset with a value, length >0 ; 
{$IFDEF WINDOWS}
  {$APPTYPE CONSOLE}
{$ENDIF}
{$IFDEF FPC}
  {$Mode Delphi} {$Optimization ON,ALL}{$Align 32}
  uses
    sysutils;
{$ELSE}
  uses
    system.SysUtils;
{$ENDIF}
type
  myString =  AnsiString; // String[32];//
 
function IncLoop(ps: pChar;le,Base: NativeInt):NativeInt;inline;
//Add 1 and correct carry
//returns 0, if no overflow, else 1
var
  dg: nativeInt;
Begin
  dec(le);//ps is 0-based
  dg := ord(ps[le])+(-ord('0')+1);        
  result := 0;    

  repeat
    IF dg < base then
    begin
      ps[le] := chr(dg+ord('0'));
      EXIT;
    end; 
    ps[le] := '0';
    dec(le);
    dg := ord(ps[le])+(-ord('0')+1);        
  until (le<0);
  result:= 1;
end;
 
procedure IncIntStr(base:NativeInt;var s:myString);
var
  le: NativeInt;
begin
  le := length(s);
  //overflow -> prepend a '1' to string
  if (IncLoop(pChar(@s[1]),le,base) <>0) then
  Begin
//    s := '1'+s;
    setlength(s,le+1);
    move(s[1],s[2],le);
    s[1] := '1';
  end;  
end;
 
const
  ONE_BILLION = 1000*1000*1000;
  strLen = 26;
  MAX = 1 shl strLen -1;
 
var
  s  : myString;
  i,base : nativeInt;
  T0: TDateTime;
Begin
  writeln(MAX,' increments in base');
  For base := 2 to 10 do
  Begin
    //s := '0' doesn't work
    setlength(s,1);
    s[1]:= '0';
{   //Zero pad string
    setlength(s,strLen);fillchar(s[1],strLen,'0');
}
    T0 := time;
    For i := 1 to MAX do
      IncIntStr(Base,s);
    T0 := (time-T0)*86400;
    writeln(s:strLen,' base ',base:2,T0:8:3,' s');
  end;
 
  writeln;
  writeln('One billion digits "9"');
  setlength(s,ONE_BILLION+1);
  s[1]:= '0';//don't measure setlength in IncIntStr
  fillchar(s[2],length(s)-1,'9');
  writeln('first 5 digits ',s[1],s[2],s[3],s[4],s[5]);
  T0 := time;
  IncIntStr(10,s);
  T0 := (time-T0)*86400;
  writeln(length(s):10,T0:8:3,' s');
  writeln('first 5 digits ',s[1],s[2],s[3],s[4],s[5]);
  s:='';
  {$IFDEF WINDOWS}
    readln;
  {$ENDIF}
end.
@TIO.RUN:
//sys time for allocating 1 Gb 
Real time: 5.512 s User time: 4.068 s Sys. time: 1.288 s CPU share: 97.17 %

67108863 increments in base
11111111111111111111111111 base  2   0.395 s
         11200021111001110 base  3   0.351 s
             3333333333333 base  4   0.301 s
              114134440423 base  5   0.348 s
               10354213103 base  6   0.290 s
                1443262443 base  7   0.281 s
                 377777777 base  8   0.279 s
                 150244043 base  9   0.271 s
                  67108863 base 10   0.267 s

One billion digits "9"
first 5 digits 09999
1000000001   1.382 s
first 5 digits 10000

Perl[edit]

my $s = "12345";
$s++;

Phix[edit]

integer {{n}} = scanf("2047","%d")
printf(1,"%d\n",{n+1})
Output:
2048

Phixmonti[edit]

"12345" tonum 1 + tostr

PHP[edit]

$s = "12345";
$s++;

Picat[edit]

parse_term/1[edit]

parse_term/1 is the best to use if there can be no assumption of the type of the number (integer or float). For integers to_int/1 is better to use, and for floats to_float/1.

go =>

  % integer
  Int = "123",
  println(int=Int),
  println(parse_term=Int.parse_term+1),
  println(to_int=Int.to_int+1), % assumes integer
  nl,

  % float
  Float = "122.5",
  println(float=Float),
  println(parse_term=Float.parse_term+1),
  println(to_float=Float.to_float+1),  
  nl.
Output:
int = 123
parse_term = 124
to_int = 124

float = 122.5
parse_term = 123.5
to_float = 123.5

parse_term/3[edit]

parse term/3 can evaluate numeric expressions with the help of apply/1:

go2 =>
  T = "2**16+1",
  println(t=T),
  parse_term(T,Term, _Vars),
  println(term=Term),
  println(apply=Term.apply).
Output:
t = 2**16+1
term = 2 ** 16 + 1
apply = 65537

PicoLisp[edit]

(format (inc (format "123456")))

Pike[edit]

string number = "0";
number = (string)((int)number+1);
Result: "1"

PL/I[edit]

declare s picture '999999999';
s = '123456789';
s = s + 1;
put skip list (s);
Note:
SIZE is enabled by default in Windows PL/I.
Therefore, with s='999999999',
the SIZE condition is raised at execution time,
and execution terminates.

Plain English[edit]

To increment a numerical string:
Convert the numerical string to a number.
Add 1 to the number.
Put the number into the numerical string.

Plain TeX[edit]

\newcount\acounter
\def\stringinc#1{\acounter=#1\relax%
\advance\acounter by 1\relax%
\number\acounter}
The number 12345 is followed by \stringinc{12345}.
\bye

The generated page will contain the text:

The number 12345 is followed by 12346.

Pop11[edit]

lvars s = '123456789012123456789999999999';
(strnumber(s) + 1) >< '' -> s;

PowerShell[edit]

The easiest way is to cast the string to int, incrementing it and casting back to string:

$s = "12345"
$t = [string] ([int] $s + 1)

One can also take advantage of the fact that PowerShell casts automatically according to the left-most operand to save one cast:

$t = [string] (1 + $s)

Prolog[edit]

Works with SWI-Prolog.

incr_numerical_string(S1, S2) :-
	string_to_atom(S1, A1),
	atom_number(A1, N1),
	N2 is N1+1,
	atom_number(A2, N2),
	string_to_atom(S2, A2).
Output:
 ?- incr_numerical_string("123", S2).
S2 = "124".

PureBasic[edit]

string$="12345"
string$=Str(Val(string$)+1)
Debug string$

Python[edit]

Works with: Python version 2.3 through 3.4
next = str(int('123') + 1)

Or, preserving the distinction between integer and floating point numeric values, while also allowing for noisy or multi-number numerical strings, and providing the option of retaining or pruning out any non-numeric parts of the string.

# Dropping or keeping any non-numerics in the string


# succString :: Bool -> String -> String
def succString(blnPruned):
    def go(x):
        try:
            return [str(1 + (float(x) if '.' in x else int(x)))]
        except ValueError:
            return [] if blnPruned else [x]
    return lambda s: ' '.join(concatMap(go)(s.split()))


# TEST ----------------------------------------------------
def main():
    print(
        '\n'.join(
            [succString(bln)(
                '41.0 pine martens in 1491 -1.5 mushrooms ≠ 136'
            ) for bln in [False, True]]
        )
    )


# GENERIC ---------------------------------------------------

# concatMap :: (a -> [b]) -> [a] -> [b]
def concatMap(f):
    return lambda xs: (
        [ys[0] for ys in [f(x) for x in xs] if ys]
    )


# MAIN ---
if __name__ == '__main__':
    main()
Output:
42.0 pine martens in 1492 -0.5 mushrooms ≠ 137
42.0 1492 -0.5 137

Quackery[edit]

As a dialogue in the Quackery shell.

$->n attempts to convert a string to an integer in the current base (default is decimal). It leaves 0 (i.e. false) on the top of the data stack if the string was not a valid integer, and 1 (i.e. true) if it was. Underneath the flag is the converted integer, or the routine's best guess, if the string was not a valid integer. When the first conversion fails, we can see in the problem report that the best guess was 12345.

/O> $ "1.2.3.4.5" $->n
... not if [ $ "not a valid integer" fail ]  
... 1+
... number$ echo$
... 

       Problem: not a valid integer
Quackery Stack: 12345
  Return stack: {[...] 0} {quackery 1} {[...] 11} {shell 5} {quackery 1} {[...] 4}

/O> $ "12345" $->n
... not if [ $ "not a valid integer" fail ]  
... 1+
... number$ echo$
... 
12346
Stack empty.

R[edit]

s = "12345"
s <- as.character(as.numeric(s) + 1)

Racket[edit]

#lang racket
(define next (compose number->string add1 string->number))

Raku[edit]

(formerly Perl 6)

Works with: Rakudo version #22 "Thousand Oaks"
my $s = "12345";
$s++;

Rascal[edit]

import String;

public str IncrNumStr(str s) = "<toInt(s) + 1>";
Output:
rascal>IncrNumStr("123")
str: "124"

REBOL[edit]

REBOL [
	Title: "Increment Numerical String"
	URL: http://rosettacode.org/wiki/Increment_numerical_string
]

; Note the use of unusual characters in function name. Also note that
; because REBOL collects terms from right to left, I convert the
; string argument (s) to integer first, then add that result to one.

s++: func [s][to-string 1 + to-integer s]

; Examples. Because the 'print' word actually evaluates the block
; (it's effectively a 'reduce' that gets printed space separated),
; it's possible for me to assign the test string to 'x' and have it
; printed as a side effect. At the end, 'x' is available to submit to
; the 's++' function. I 'mold' the return value of s++ to make it
; obvious that it's still a string.

print [x: "-99" "plus one equals" mold s++ x]
print [x: "42" "plus one equals" mold s++ x]
print [x: "12345" "plus one equals" mold s++ x]
Output:
-99 plus one equals "-98"
42 plus one equals "43"
12345 plus one equals "12346"

Retro[edit]

'123 s:to-number n:inc n:to-string

REXX[edit]

REXX, like many other scripting languages, uses typeless variables.
Typeless variables are stored as variable length character strings and can be treated as
either a string or a numeric value, depending on the context in which they are used.

version 1[edit]

/*REXX program demonstrates a method how to increment a numerical string*/
count = "3"      /*REXX variables (and constants) are character strings.*/
count =  3       /*(identical to the above statement.)                  */
count = count+1  /*strings in a numerical context are treated as numbers*/
say 'sum=' count /*display the value of  COUNT  to the terminal (screen)*/

/*────────────────── The default numeric digits for REXX is  9  digits. */
/*────────────────── However, that can be increased with NUMERIC DIGITS.*/

numeric digits 15000   /*let's go ka-razy with fifteen thousand digits. */

count=copies(2,15000)  /*stressing REXX's brains with lots of  two's,   */
                       /*the above is considered a number in REXX.      */
count=count+3          /*make that last digit of  COUNT  a  "5".        */

if 1==0  then          /*let's not display this gihugeic number to term,*/
say  'count='  count   /*ya most likely don't want to display this thing*/

                       /* [↓]  show the six leftmost and rightmost digs.*/
say  'count='  left(count,6)'···'right(count,6)
                                       /*stick a fork in it, we're done.*/
Output:
sum= 4
count= 222222···222225

version 2[edit]

Looking at the PL/I code I started investigating this situation in Rexx. These are my findings:

/* REXX ************************************************************
* There is no equivalent to PL/I's SIZE condition in REXX.
* The result of an arithmetic expression is rounded
* according to the current setting of Numeric Digits.
* ooRexx introduced, however, a LOSTDIGITS condition that checks
* if any of the OPERANDS exceeds this number of digits.
*      Unfortunately this check is currently a little too weak
*      and will not recognise a 10-digit number to be too large.
*      This little bug will be fixed in the next release of ooRexx.
**********************************************************************/
Parse Version v .
Say v
z=999999998
Do i=1 To 3
  z=z+1
  Say z
  End
Numeric Digits 20
z=999999998
Do i=1 To 3
  z=z+1
  Say z
  End
Numeric Digits 9
If left(v,11)='REXX-ooRexx' Then
  Signal On Lostdigits
z=100000000012
Say z
z=z+1
Say z
Exit
lostdigits:
  Say 'LOSTDIGITS condition raised in line' sigl
  Say 'sourceline='sourceline(sigl)
  Say "condition('D')="condition('D')
Output:
REXX-ooRexx_4.1.2(MT)
999999999
1.00000000E+9
1.00000000E+9
999999999
1000000000
1000000001
100000000012
LOSTDIGITS condition raised in line 30
sourceline=z=z+1
condition('D')= 100000000012    

Ring[edit]

x = "1234"  See 1+x  # print 1235

Ruby[edit]

If a string represents a number, the succ method will increment the number:

'1234'.succ #=> '1235'
'99'.succ #=> '100'

Run BASIC[edit]

Run BASIC has trim command for left and right

string$ = "12345"
numeric = val(string$)
numeric = numeric + 1
string$ = str$(numeric)
print string$
12346

Rust[edit]

fn next_string(input: &str) -> String {
    (input.parse::<i64>().unwrap() + 1).to_string()
}

fn main() {
    let s = "-1";
    let s2 = next_string(s);
    println!("{:?}", s2);
}
Output:
"0"

Scala[edit]

The string needs to be converted to a numeric type. BigDecimal should handle most numeric strings. We define a method to do it.

implicit def toSucc(s: String) = new { def succ = BigDecimal(s) + 1 toString }

Usage:

scala> "123".succ
res5: String = 124

Scheme[edit]

(number->string (+ 1 (string->number "1234")))

Sed[edit]

Reads a decimal integer from stdin and outputs the same with the magnitude incremented by one.

(TODO: Since it deals only with the magnitude, the result is incorrect for negative numbers—though adding this support is definitely possible.)

The routine starts by suffixing the input number with a carry mark (a : in this case) indicating that the digit to its left still needs to be incremented. In a loop, the following happens:

  • If there is a carry mark on the far left, replace it with a 1.
  • If there are no more carry marks, exit the loop.
  • Hold the current number. (h)
  • Extract the digit to the left of the first carry mark. (s)
  • Replace the digit with the same digit incremented by one, with 9 incrementing to a carry mark (i.e. 10). (y)
  • If the result of such replacement was a carry mark, suffix the mark with a 0, indicating that the digit has rolled over and the digit to the left must be incremented. (s)
  • Retrieve the held number (G) and replace the first carry mark and the digit to its left with the result of the computation. (s)
  • Repeat. (b)
s/^.*$/&:/
:bubble
s/^:/1/
/.:/ {
    h
    s/^.*\(.\):.*$/\1/
    y/0123456789/123456789:/
    s/:/:0/
    G
    s/\(.*\)\n\(.*\).:\(.*\)$/\2\1\3/
    b bubble
}

Seed7[edit]

var string: s is "12345";

s := str(succ(integer parse s));

SenseTalk[edit]

put "123" + 1  // 124

SequenceL[edit]

import <Utilities/Conversion.sl>;

increment(input(1)) := intToString(stringToInt(input) + 1);

Sidef[edit]

say '1234'.inc;    #=> '1235'
say '99'.inc;      #=> '100'

Slate[edit]

((Integer readFrom: '123') + 1) printString

Smalltalk[edit]

('123' asInteger + 1) printString

(a note to non-smalltalkers: "printString" does not print, but return the "printString")

SNOBOL4[edit]

     output = trim(input) + 1
     output = "123" + 1
end
Input:
 123

Output:
 124
 124

Sparkling[edit]

function numStrIncmt(s) {
    return fmtstr("%d", toint(s) + 1);
}

spn:1> numStrIncmt("12345")
= 12346

SuperTalk[edit]

put 0 into someVar
add 1 to someVar
-- without "into [field reference]" the value will appear
-- in the message box
put someVar -- into cd fld 1

Swift[edit]

Works with: Swift version 2.x+
let s = "1234"
if let x = Int(s) {
  print("\(x + 1)")
}
Works with: Swift version 1.x
let s = "1234"
if let x = s.toInt() {
  println("\(x + 1)")
}

Tcl[edit]

In the end, all variables are strings in Tcl. A "number" is merely a particular interpretation of a string of bytes.

set str 1234
incr str

TI-83 BASIC[edit]

There is no single command to convert a number to a string; you have to store it to one of the Function variables which acts as both a number and a string.

:"1"→Str1
:expr(Str1)+1→A
:{0,1}→L₁
:{0,A}→L₂
:LinReg(ax+b) Y₁
:Equ►String(Y₁,Str1)
:sub(Str1,1,length(Str1)-3)→Str1

TI-89 BASIC[edit]

string(expr(str)+1)

Toka[edit]

" 100" >number drop 1 + >string

TorqueScript[edit]

To increment by 1:

 $string = "12345";
 $string++;

$string is now 12346.

To increment by more than 1:

 $string = "12345";
 $string += 10;

$string is now 12355.

Transd[edit]

(with s "12345"
    (= s String((+ (to-Int s) 1))))
    (textout s))
Output:
12346

TUSCRIPT[edit]

$$ MODE TUSCRIPT
teststring="0'1'-1'12345'10000000'-10000000"
LOOP/CLEAR n=teststring
n=n+1
PRINT n
ENDLOOP
Output:
1
2
0
12346
10000001
-9999999 

TXR[edit]

Two implementations of what the task says: incrementing a numerical string. (Not: converting a string to a number, then incrementing the number, then converting back to string.)

TXR Lisp[edit]

@(do (defun inc-num-str (str-in)
       (let ((len (length str-in))
             (str (copy-str str-in)))
         (for ((i (- len 1)))
              ((>= i 0) `1@str`)
              ((dec i))
           (if (<= (inc [str i]) #\9)
             (return str)
             (set [str i] #\0))))))
@(bind a @(inc-num-str "9999"))
@(bind b @(inc-num-str "1234"))
$ ./txr -B incnum.txr 
a="10000"
b="1235"

No TXR Lisp[edit]

@(deffilter incdig ("0" "1") ("1" "2") ("2" "3") ("3" "4") ("4" "5")
                   ("5" "6") ("6" "7") ("7" "8") ("8" "9"))
@(define increment (num out))
@  (local prefix dig junk)
@  (next :string num)
@  (cases)
9
@    (bind out "10")
@  (or)
@*{prefix}@{dig /[0-8]/}
@    (bind out `@prefix@{dig :filter incdig}`)
@  (or)
@*{prefix}9
@    (bind out `@{prefix :filter (:fun increment)}0`)
@  (or)
@junk
@    (throw error `bad input: @junk`)
@  (end)
@(end)
@in
@(increment in out)
$ echo 1 | ./txr -B incnum.txr -
input="1"
result="2"
$ echo 123 | ./txr -B incnum.txr -
input="123"
result="124"
$ echo 899999 | ./txr -B incnum.txr -
input="899999"
result="900000"
$ echo 999998 | ./txr -B incnum.txr -
input="999998"
result="999999"
$ echo 999999 | ./txr -B incnum.txr -
input="999999"
result="1000000"

UNIX Shell[edit]

Traditional Unix shell does not directly support arithmetic operations, so external tools, such as expr are used to perform arithmetic calculations when required. The following example demonstrates how a variable can be incremented by using the expr function:

Works with: Bourne Shell
# All variables are strings within the shell
# Although num look like a number, it is in fact a numerical string
num=5
num=`expr $num + 1`    # Increment the number

The Korn Shell and some newer shells do support arithmetic operations directly, and several syntax options are available:

Works with: bash
Works with: ksh93
Works with: pdksh
Works with: zsh
num=5
let num=num+1          # Increment the number
let "num = num + 1"    # Increment again. (We can use spaces inside quotes)
((num = num + 1))      # This time we use doublebrackets
let num+=1             # This time we use +=
let "num += 1"
((num += 1))
Works with: ksh93
Works with: pdksh
Works with: zsh
integer num=5          # Declare an integer...
num=$num+1             # ...then increment without the let keyword.

C Shell[edit]

The @ assignment command uses strings as integers.

@ num = 5
@ num += 1

Ursa[edit]

decl string num
set num "123"
set num (int (+ (int num) 1))

Ursala[edit]

#import nat

instring = ~&h+ %nP+ successor+ %np@iNC      # convert, do the math, convert back

test program:

#cast %sL

tests = instring* <'22435','4','125','77','325'>
Output:
<'22436','5','126','78','326'>

VBA[edit]

The easy method assumes that the number can be represented as a Long integer:

Public Function incr(astring As String) As String
'simple function to increment a number string
   incr = CStr(CLng(astring) + 1)
End Function

Examples:

print incr("345343434")
345343435
print incr("-10000000")
-9999999

The long version handles arbitrary-length strings:

Public Function Lincr(astring As String) As String
'increment a number string, of whatever length
'calls function "increment" or "decrement"
Dim result As String

'see if it is a negative number
If left$(astring, 1) = "-" Then
  'negative x: decrease |x| by 1, then add "-"
  '(except if the result is zero)
  result = decrement(Mid$(astring, 2))
  If result <> "0" Then result = "-" & result
Else
  '0 or positive x: increase x by 1
  If left$(astring, 1) = "+" Then  'allow a + before the number
    result = increment(Mid$(astring, 2))
  Else
    result = increment(astring)
  End If
End If
Lincr = result
End Function

Public Function increment(astring) As String
Dim result As String
'increment a string representing a positive number
'does not work with negative numbers
carry = 1
L = Len(astring)
result = ""
For j = L To 1 Step -1
  digit = Val(Mid$(astring, j, 1)) + carry
  If digit > 9 Then
    digit = digit - 10
    carry = 1
  Else
    carry = 0
  End If
  result = CStr(digit) & result
Next
If carry = 1 Then result = CStr(carry) & result
increment = result
End Function

Public Function decrement(astring) As String
Dim result As String
'decrement a string representing a positive number
'does not work with zero or negative numbers
borrow = 1
L = Len(astring)
result = ""
For j = L To 1 Step -1
  digit = Val(Mid$(astring, j, 1)) - borrow
  If digit < 0 Then
    digit = digit + 10
    borrow = 1
  Else
    borrow = 0
  End If
  result = CStr(digit) & result
Next
'remove leading zero, if necessary
If (Len(result) > 1) And (left$(result, 1) = "0") Then result = Mid$(result, 2)
decrement = result
End Function

Examples:

print Lincr("99999999999999999")
100000000000000000
print Lincr("-10000000000000000")
-9999999999999999
print Lincr("-1")
0
print Lincr("0")
1
print Lincr("+1234567890987654321009")
1234567890987654321010

Vedit macro language[edit]

This example increments numeric string by converting it into numeric value, as most other language examples do. The string is located in text register 10.

itoa(atoi(10)+1, 10)

The following example increments unsigned numeric string of unlimited length. The current line in the edit buffer contains the string.

EOL
do {
    if (At_BOL) {
	Ins_Char('1')		// add new digit
	Break
    }
    Char(-1)
    #1 = Cur_Char+1		// digit
    #2 = 0			// carry bit
    if (#1 > '9') {
	#1 = '0'
	#2 = 1
    }
    Ins_Char(#1, OVERWRITE)
    Char(-1)
} while (#2)			// repeat until no carry

Visual Basic .NET[edit]

    Dim s As String = "123"

    s = CStr(CInt("123") + 1)
    ' or
    s = (CInt("123") + 1).ToString

V (Vlang)[edit]

// Increment a numerical string in V
module main

// V int conversion will give 0 for nonnumeric strings
pub fn main() {
    mut numstr := "-5"
    print("numstr: ${numstr:-5} ")
    numstr = (numstr.int()+1).str()
    println("numstr: $numstr")

    // Run a few tests
    for testrun in ["0", "100", "00110", "abc", "41"] {
        print("numstr: $testrun  ")
        numstr = (testrun.int()+1).str()
        println("numstr: $numstr")
    }
}
Output:
prompt$ v run increment-a-numerical-string.v
numstr: -5    numstr: -4
numstr: 0  numstr: 1
numstr: 100  numstr: 101
numstr: 00110  numstr: 111
numstr: abc  numstr: 1
numstr: 41  numstr: 42

Wren[edit]

var ns = "41"
var n = Num.fromString(ns) + 1
var ns2 = "%(n)"
System.print("%(ns) + 1 = %(ns2)")
Output:
41 + 1 = 42

XLISP[edit]

(DEFUN INCREMENT-STRING (X)
    (NUMBER->STRING (+ (STRING->NUMBER X) 1)))

XPL0[edit]

string 0;               \use zero-terminated string convention
code Text=12;

func StrLen(A);         \Return number of characters in an ASCIIZ string
char A;
int  I;
for I:= 0 to -1>>1-1 do
        if A(I) = 0 then return I;

proc IncStr(S);         \Increment a numeric string
char S;
int  I;
[for I:= StrLen(S)-1 downto 0 do
        [S(I):= S(I)+1;
        if S(I) > ^9 then S(I):= S(I)-10 else return;
        ];
];

char Str;
[Str:= "0123999999999"; \MSD first (big endian)
IncStr(Str);  IncStr(Str);
Text(0, Str);
]
Output:
0124000000001

Z80 Assembly[edit]

As a test case, we'll start with 1999 and increment it to 2000.

;;;;;;;;;;;;;;;;;;; HEADER ;;;;;;;;;;;;;;;;;;;
read "\SrcCPC\winape_macros.asm"
read "\SrcCPC\MemoryMap.asm"
read "\SrcALL\winapeBuildCompat.asm"
;;;;;;;;;;;;;;;;;;; PROGRAM  ;;;;;;;;;;;;;;;;;;;

org &1000
ld hl,NumericString

incstring:
ld a,(hl)
cp 255
jr z,displaystring
add &01
cp &3A
jr nz,displaystring
;carry forward
ld a,&30
ld (hl),a
inc hl
jr incstring
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
displaystring:
ld (hl),a	;store the last addition.
ld hl,NumericString_End
dec hl
disploop:
ld a,(hl)
cp 255
ret z
call &bb5a
dec hl
jr disploop
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
db 255 ;terminator when reading in reverse
NumericString:
;stored little-endian for convenience
db &39,&39,&39,&31
NumericString_End:
db 255 ;terminator
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
read "\SrcCPC\winape_showhex.asm"
read "\SrcCPC\winape_stringop.asm"
Output:
2000

zkl[edit]

In zkl, the first operand "wins" and transforms the second. So 5+"1"-->6

fcn numStringPlusOne(s){1+s}
numStringPlusOne("123") //-->124

Zoea[edit]

program: increment_a_numerical_string
  case: 1
    input: '1234'
    output: '1235'
  case: 2
    input: '19'
    output: '20'

Zoea Visual[edit]

Increment a numerical string