## Euphoria


```euphoria
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})

Factor

"1234" string>number 1 + number>string

Fantom

Within 'fansh':

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

=={{header|Fōrmulæ}}==

In [https://wiki.formulae.org/Increment_a_numerical_string this] page you can see the solution of this task.

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text ([http://wiki.formulae.org/Editing_F%C5%8Drmul%C3%A6_expressions more info]). 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 transportation effects more than visualization and edition.

The option to show Fōrmulæ programs and their results is showing images. Unfortunately images cannot be uploaded in Rosetta Code.

Forth

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

{{works with|Fortran|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

' 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

{{out}}

1 + 1          = 2
5 + 1          = 6
81 + 1         = 82
123.45 + 1     = 124.45
777.77 + 1     = 778.77
1000 + 1       = 1001

=={{header|F_Sharp|F#}}==

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

Frink

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

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

FutureBasic

include "ConsoleWindow"

dim as Str255 numStr
dim as long   numeric, i

numStr = "12345"
numeric = val(numStr)
numeric++
numStr = str$(numeric)
print numStr

print

for i = 0 to 10
   numeric++
   numStr = str$( numeric )
   print numStr
next

Output:

 12346

 12347
 12348
 12349
 12350
 12351
 12352
 12353
 12354
 12355
 12356
 12357

Gambas

'''[https://gambas-playground.proko.eu/?gist=e31b63f444c2c09c8b1436407020e216 Click this link to run this code]'''

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

Inc vInput
Print vInput

End

Output:

12346

GAP

# 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

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

{{out}}

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

~)`

With a test framework to supply a number:

"1234" ~)` p

Groovy

Solution:

println ((("23455" as BigDecimal) + 1) as String)
println ((("23455.78" as BigDecimal) + 1) as String)

{{Out}}

23456
23456.78

Haskell

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

{{Trans|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"

{{Out}}

42.0 1492 -0.5 137
42.0 pine martens in 1492 -0.5 mushrooms ≠ 137

HicEst

CHARACTER string = "123     -4567.89"

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

HolyC

I8 *s;

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

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

Hy

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

Alternatively, with the "threading" macro:

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

HyperTalk

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

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

=={{header|Icon}} and {{header|Unicon}}== 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

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

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

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

## J


```j>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.

   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

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

ES6

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:

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

{{Out}}

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

jq

=tonumber=

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

# 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")

{{Out}} "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"

Jsish

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

Julia

{{works with|Julia|0.6}}

Base.:+(s::AbstractString, n::Real) = string(parse(s) + n)

@show "125" + 1
@show "125.15" + 1
@show "1234567890987654321" + 1

{{out}}

"125" + 1 = "126"
"125.15" + 1 = "126.15"
"1234567890987654321" + 1 = "1234567890987654322"

K

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

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

{{out}}

12346
ghijk

LabVIEW

{{VI snippet}}
[[File:LabVIEW_Increment_a_numerical_string.png]]

Lasso

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

-> 124

LaTeX

\documentclass{article}

% numbers are stored in counters
\newcounter{tmpnum}

% macro to increment a string (given as argument)
\newcommand{\stringinc}[1]{%
\setcounter{tmpnum}{#1}%     setcounter effectively converts the string to a number
\stepcounter{tmpnum}%        increment the counter; alternatively: \addtocounter{tmpnum}{1}
\arabic{tmpnum}%             convert counter value to arabic (i.e. decimal) number string
}

%example usage
\begin{document}
The number 12345 is followed by \stringinc{12345}.
\end{document}

Liberty BASIC

'   [RC] Increment a numerical string.

o$ ="12345"
print o$

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

end

LIL

##
   Increment a numerical string, in LIL
##
set a "41"
inc a
print $a

{{out}}

prompt$ lil incrementNumericalString.lil
42

Lingo

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

LiveCode

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"

Logo

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

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

LOLCODE

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

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

{{Out}}

Increment_a_Numerical_String: You said '99999999' + 1 = 100000000
Increment_a_Numerical_String: You said '-100000000' + 1 = -99999999

Lua

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

> s = "2345"
> =type(s)
string
> n = s + 1
> =n
2346
> =type(n)
number
> s = "This string won't convert to a number."
> n = s + 1
stdin:1: attempt to perform arithmetic on global 's' (a string value)
stack traceback:
        stdin:1: in main chunk
        [C]: at 0x01271f20

M2000 Interpreter

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

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

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

=={{header|Mathematica}} / {{header|Wolfram Language}}==

FromDigits["1234"] + 1

MATLAB

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

MAXScript

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

Metafont

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

min

{{works with|min|0.19.3}}

(int succ string) :next

mIRC Scripting Language

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

ML

=

mLite

=

ntos ` ston "1234" + 1;

=

Standard ML

=

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

=={{header|Modula-2}}==

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

=={{header|Modula-3}}== 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.

{{Out}}

1234 + 1 = 1235

MUMPS

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

Neko

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

$print(str);

Nemerle

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

NetRexx

In concert with [[REXX|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

{{Out}}

12345
12346

NewLISP

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

Nim

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

=={{header|Oberon-2}}==

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

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

=={{header|Objective-C}}==

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

OCaml

string_of_int (succ (int_of_string "1234"))

Octave

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

• 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

{{out}}

9991
1000

OoRexx

ooRexx supports the += etc. operators:

i=1
i+=1
Say i

{{Out}}

2

OpenEdge/Progress

DEFINE VARIABLE cc AS CHARACTER INITIAL "12345".

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

Oz

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

PARI/GP

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

Pascal

{{works with| Free Pascal}} not like [[Increment_a_numerical_string#Delphi | 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;
{$IFDEF FPC}
  {$Mode Delphi}
  {$Optimization ON}{$Align 16}{$Codealign proc=16,loop=4}
{$ENDIF}

uses
  sysutils;

type
  myString =  AnsiString; // string[32];//

function InCLoop(ps: pChar;le,Base: NativeInt):NativeInt;
//Add 1 and correct carry
//returns 0, if no overflow, else -1
var
  dg: nativeInt;
Begin
  dec(le);//ps is 0-based
  repeat
    dg := ord(ps[le])+(-ord('0')+1);
    result  := -ord(dg>=base);// -1 or 0 -> $FF...FF or $00...00
    ps[le] := chr(-(result AND base)+dg+ord('0'));
    dec(le);
  until (result = 0) or (le<0);
end;

procedure IncIntStr(base:NativeInt;var s:myString);
var
  le :nativeInt;
begin
  le := length(s);
  IF le > 0 then
  Begin
    if (InCLoop(pChar(@s[1]),le,base) <>0) then
    begin
      setlength(s,le+1);
      move(s[1],s[2],le);
      s[1] := '1';
    end
  end
  else
  Begin
    setlength(s,1);
    s[1] := '1';
  end;
end;

const
  strLen = 26;
  MAX = 1 shl strLen -1;

var
  s  : myString;
  i,base : nativeInt;
  T1,T0: TDateTime;
Begin
  For base := 2 to 10 do
  Begin
    s:= '';
{
    //Zero pad string
    //s:= '0';// doesn't work for AnsiString for FPC 3.0 but for 2.6.4?
    //This works for all Ansi-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');
//One Billion Digits
  setlength(s,1000*1000*1000+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(s,10);
  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]);
  end;
end.

Output:

 ppc386 aka 32-Bit fpc 3.0.1
11111111111111111111111111 base  2   0.423 s
         11200021111001110 base  3   0.364 s
             3333333333333 base  4   0.331 s
              114134440423 base  5   0.345 s
               10354213103 base  6   0.325 s
                1443262443 base  7   0.318 s
                 377777777 base  8   0.312 s
                 150244043 base  9   0.308 s
                  67108863 base 10   0.305 s
first 5 digits 09999
1000000001   1.299 s
//4.55 cpu-cycles per digit == 3.5 Ghz [cycle/s]*1.3[s]/1e9[digits]  (IPC = 17/4.55 = 3.73 wow)
first 5 digits 10000

Perl

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

Perl 6

{{works with|Rakudo|#22 "Thousand Oaks"}}

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

Phix

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

{{out}}

2048

PHP

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

PicoLisp

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

Pike

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

PL/I

declare s picture '999999999';
s = '123456789';
s = s + 1;
put skip list (s);

Warning:
With s='999999999'
the result shown would be
000000000
It is advisable to enable the SIZE condition
(size):
 s = s + 1;
which will diagnose this problem:
IBM0342I  ONCODE=0340  The SIZE condition was raised.
   At offset +000000B9 in procedure with entry IB1

plainTeX

\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

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

PowerShell

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

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

{{Out}}

 ?- incr_numerical_string("123", S2).
S2 = "124".

PureBasic

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

Python

{{works with|Python|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()

{{Out}}

42.0 pine martens in 1492 -0.5 mushrooms ≠ 137
42.0 1492 -0.5 137

R

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

Racket

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

Rascal

import String;

public str IncrNumStr(str s) = "<toInt(s) + 1>";

{{Out}}

rascal>IncrNumStr("123")
str: "124"

REBOL

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]

{{Out}}

-99 plus one equals "-98"
42 plus one equals "43"
12345 plus one equals "12346"

Retro

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

REXX

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

/*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.*/

{{out}}

sum= 4
count= 222222···222225

version 2

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

{{Out}}

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

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

Ruby

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

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

Rust

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

{{out}}

"0"

Run BASIC

Run BASIC has trim command for left and right

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

12346

Scala

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

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

Sed

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

var string: s is "12345";

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

SequenceL

;

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

Sidef

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

Slate

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

Smalltalk

('123' asInteger + 1) printString

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

SNOBOL4

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

Input:
 123

Output:
 124
 124

Sparkling

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

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

SuperTalk

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

{{works with|Swift|2.x+}}

let s = "1234"
if let x = Int(s) {
  print("\(x + 1)")
}

{{works with|Swift|1.x}}

let s = "1234"
if let x = s.toInt() {
  println("\(x + 1)")
}

Tcl

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

=={{header|TI-89 BASIC}}==

string(expr(str)+1)

=={{header|TI-83 BASIC}}== 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

Toka

" 100" >number drop 1 + >string

TorqueScript

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.

TUSCRIPT

$$ MODE TUSCRIPT
teststring="0'1'-1'12345'10000000'-10000000"
LOOP/CLEAR n=teststring
n=n+1
PRINT n
ENDLOOP

{{Out}}

1
2
0
12346
10000001
-9999999

TXR

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 =

@(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 =

@(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

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

= The @ assignment command uses strings as integers.

@ num = 5
@ num += 1

Ursa

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

Ursala

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

{{Out}}

<'22436','5','126','78','326'>

VBA

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

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

    Dim s As String = "123"

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

XLISP

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

XPL0

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

{{out}}

0124000000001

zkl

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

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