Increment a numerical string: Difference between revisions

=={{header|11l}}==

{{trans|Python}}

 

=={{header|8080 Assembly}}==

jmp demo

;;; Increment the number in the $-terminated string under HL.

pop d ; Print the string

mvi c,9

 

=={{header|8086 Assembly}}==

bits 16

section .text

mov ah,9 ; Print the string

int 21h

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program incstring64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}

<pre>

 

=={{header|ABAP}}==

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

 

write / lv_string.

endform.

 

{{Out}}

 

=={{header|Action!}}==

INT val

 

Test("-2")

Test("-10000")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Increment_a_numerical_string.png Screenshot from Atari 8-bit computer]

 

=={{header|ActionScript}}==

{

return String(Number(str)+1);

 

=={{header|Ada}}==

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

 

=={{header|Aime}}==

o_text(itoa(atoi("2047") + 1));

o_byte('\n');

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

associate(f, s); get(f,i);

i+:=1;

s:=""; reset(f); put(f,i);

{{Out}}

<pre>

=={{header|ALGOL W}}==

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

% returns a string representing the number in s incremented %

% As strings are fixed length, the significant length of s must %

write( " 123456789 + 1: " ); writeonToBlank( increment( "123456789", 9 ) );

write( "99999999999999999999 + 1: " ); writeonToBlank( increment( "99999999999999999999", 20 ) )

{{out}}

<pre>

 

=={{header|Apex}}==

string count = '12345';

count = String.valueOf(integer.valueOf(count)+1);

system.debug('Incremental Value : '+count);

{{Out}}

<pre>12346</pre>

 

=={{header|APL}}==

{{Out}}

<pre>12346</pre>

 

=={{header|AppleScript}}==

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:

{{Trans|Python}}

{{Trans|Haskell}}

{{Trans|JavaScript}}

use framework "Foundation"

use scripting additions

filteredArrayUsingPredicate:(ca's ¬

NSPredicate's predicateWithFormat:"0 < length")) as list

{{Out}}

<pre>42 1492.3 -0.5 137

42 pine martens in 1492.3 -0.5 mushrooms ≠ 137</pre>

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

.align 4

.Ls_magic_number_10: .word 0x66666667

 

 

=={{header|Arturo}}==

 

 

{{out}}

 

=={{header|Asymptote}}==

cadena = string((real)cadena + 1);

{{out}}

<pre>12346.78</pre>

 

=={{header|AutoHotkey}}==

{{Out}}

<pre>12346</pre>

 

=={{header|AutoIt}}==

$x += 1

{{Out}}

<pre>12346</pre>

 

=={{header|Avail}}==

 

=={{header|AWK}}==

The example shows that the string ''s'' can be incremented,

but after that still is a string of length 2.

 

=={{header|BASIC}}==

{{works with|BaCon}}

 

{{works with|Yabasic}}

 

 

==={{header|BASIC256}}===

cadena$ = string(val(cadena$) + 1)

#or also

 

==={{header|OxygenBasic}}===

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

string s="122"

s=val(s)+1

print s 'result: "123"

 

==={{header|True BASIC}}===

{{works with|QBasic}}

LET cadena$ = STR$(VAL(cadena$) + 1)

PRINT cadena$

 

==={{header|Yabasic}}===

 

==={{header|IS-BASIC}}===

 

==={{header|ZX Spectrum Basic}}===

The ZX Spectrum needs line numbers and a let statement,

but the same technique can be used:

 

=={{header|Batch File}}==

 

{{works with|Windows NT|4}}

 

=={{header|BBC BASIC}}==

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

REPEAT

PRINT num$

UNTIL A$<>"0" OR I%=0

IF A$="0" n$ = "1" + n$

 

=={{header|Boo}}==

 

=={{header|BQN}}==

 

=={{header|Bracmat}}==

&!n+1:?n

&out$!n

 

35664871829866234762193710913385490405823/6172839450617283945

 

=={{header|Brat}}==

 

=={{header|Burlesque}}==

ri?ish

 

=={{header|C}}==

#include <string.h>

#include <stdlib.h>

 

return 0;

{{Out}}<pre>

text: +0

 

=={{header|C sharp|C#}}==

s = (int.Parse(s) + 1).ToString();

// The above functions properly for strings >= Int32.MinValue and

bis = (BigInteger.Parse(bis) + 1).ToString();

// Note that extremely long strings will take a long time to parse

 

=={{header|C++}}==

#include <cstdlib>

#include <string>

 

std::ostringstream oss;

 

{{works with|C++11}}

 

std::string s = "12345";

 

{{libheader|Boost}}

#include <cstdlib>

#include <string>

std::string s = "12345";

int i = boost::lexical_cast<int>(s) + 1;

 

{{libheader|Qt}}

{{uses from|Library|Qt|component1=QString}}

QString num1 = "12345";

 

{{Libheader|MFC}}

{{uses from|Library|C Runtime|component1=_ttoi|component2=_tcstoul}} <!-- They're Microsoft-specific extensions exported in tchar.h. That'll be noted on their relevant pages.-->

 

CString s = "12345";

int i = _ttoi(s) + 1;

int i = _tcstoul(s, NULL, 10) + 1;

 

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

 

{{works with|g++|4.0.2}}

#include <iostream>

#include <ostream>

increment_numerical_string(big_number);

std::cout << "after increment: " << big_number << "\n";

 

=={{header|Ceylon}}==

"Increments a numeric string by 1. Returns a float or integer depending on the string.

value d = inc(c);

print(d);

 

=={{header|Clojure}}==

 

=={{header|CMake}}==

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

 

math(EXPR string "${string} + 1")

 

<pre>-- 1600</pre>

 

=={{header|COBOL}}==

DATA DIVISION.

 

GOBACK

 

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

DATA DIVISION.

GOBACK

 

=={{header|Common Lisp}}==

 

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE Operations;

IMPORT StdLog,Args,Strings;

 

END Operations.

Execute: ^Q Operatiosn.DoIncString 124343~<br/>

{{Out}}

 

=={{header|D}}==

import std.string;

 

immutable s = "12349".succ;

assert(s == "12350");

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

 

Readln;

 

{{Out}}

<pre>"12345" + 1 = 123456</pre>

 

=={{header|Dyalect}}==

str = (parse(str) + 1).ToString()

 

str = "\(parse(str) + 1)"

 

 

=={{header|DWScript}}==

value := IntToStr(StrToInt(value) + 1);

 

=={{header|Déjà Vu}}==

 

{{out}}

 

=={{header|E}}==

 

=={{header|EasyLang}}==

 

a$ = number a$ + 1

 

=={{header|EchoLisp}}==

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

→ "666"

 

=={{header|Eero}}==

 

int main()

 

Log( '%@', s )

 

=={{header|EGL}}==

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

Output:

<pre>

=={{header|Elena}}==

ELENA 4.x:

public program()

console.printLine(s)

{{out}}

<pre>

=={{header|Elixir}}==

Values can be converted to integers then converted back after incrementing

# Or piped

increment2 = fn n -> n |> String.to_integer |> +1 |> to_string end

 

increment1.("1")

{{out}}

<pre>

 

'''Case of char list:'''

 

=={{header|Emacs Lisp}}==

 

 

=={{header|Erlang}}==

 

=={{header|ERRE}}==

....................

s$="12345"

s$=STR$(VAL(s$)+1)

....................

 

=={{header|Euphoria}}==

 

function val(sequence s)

 

s = "12345"

 

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

 

=={{header|Factor}}==

 

=={{header|Fantom}}==

Within 'fansh':

 

fansh> a := "123"

123

fansh> (a.toInt + 1).toStr

124

 

=={{header|Forth}}==

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.

 

dup >r dabs <# #s r> sign #> ;

 

: inc-string ( addr -- )

dup count number? not abort" invalid number"

 

Here is a version that can increment by any value

 

over count number? not abort" invalid number"

 

Test the first version like this:

 

pad inc-string

 

And the second one like this:

 

pad 1 inc-string

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

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

INTEGER :: i

REAL :: r

READ(realstr, "(F10.1)") r

r = r + 1.0

 

=={{header|FreeBASIC}}==

 

Function Increment (num As String) As String

Print

Print "Press any key to exit"

 

{{out}}

=={{header|Frink}}==

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

 

=={{header|FutureBasic}}==

include "NSLog.incl"

 

next

HandleEvents

 

Output:

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

 

 

 

 

=={{header|Gambas}}==

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

Dim vInput As Variant = "12345"

 

Print vInput

 

Output:

<pre>

 

=={{header|GAP}}==

Incr := s -> String(Int(s) + 1);

 

Increment(s);

s;

 

=={{header|Go}}==

Concise:

import "fmt"

import "strconv"

i, _ := strconv.Atoi("1234")

fmt.Println(strconv.Itoa(i + 1))

More:

 

import (

bs = b.Add(&b, &one).String()

fmt.Println("incremented:", bs)

{{out}}

<pre>

 

=={{header|Golfscript}}==

With a test framework to supply a number:

 

=={{header|Groovy}}==

Solution:

 

{{Out}}

 

=={{header|Haskell}}==

 

At least one type signature somewhere in the code is necessary, because otherwise there is no specification of what kind of value should be incremented; the operation is equally applicable to any instance of <tt>Enum</tt>:

 

 

 

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

 

 

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 Data.Maybe (mapMaybe)

 

(putStrLn . unlines) $

succString <$> [True, False] <*>

{{Out}}

<pre>42.0 1492 -0.5 137

 

=={{header|HicEst}}==

 

READ( Text=string) a, b

 

=={{header|HolyC}}==

 

s = "10";

s = "-10";

s = Str2I64(s) + 1;

 

=={{header|Hy}}==

Alternatively, with the "threading" macro:

 

=={{header|HyperTalk}}==

add 1 to someVar

-- without "into [field reference]" the value will appear

-- in the message box

 

=={{header|i}}==

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.

 

 

=={{header|IDL}}==

print, string(fix(str)+1)

 

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

 

 

=={{header|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]]).

 

To decide which indexed text is incremented (T - indexed text):

When play begins:

say incremented "12345";

 

=={{header|Io}}==

 

=={{header|J}}==

 

35.5

incrTextNum '7 0.2 3r5 2j4 5.7e_4'

 

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:

 

754 421

|.1+123 456

 

=={{header|Java}}==

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

 

Another solution that works with big decimal numbers:

 

=={{header|JavaScript}}==

Using implicit coercion:

 

let splusplus = (+s+1)+""

 

 

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

 

// MAIN ---

return main();

 

{{Out}}

<pre>42 1492.3 -0.5 137

42 pine martens in 1492.3 -0.5 mushrooms ≠ 137</pre>

 

=={{header|jq}}==

====tonumber====

jq's string-to-number filter is called <tt>tonumber</tt>. 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:

 

 

<tt>tostring</tt> can be used to convert numbers to strings.

====long_add====

def long_add(num1; num2):

if (num1|length) < (num2|length) then long_add(num2; num1)

end )

| reverse | map(.+48) | implode

'''Example'''

{{Out}}

"10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"

 

=={{header|Jsish}}==

 

=={{header|Julia}}==

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

<pre>"125" + 1 = "126"

"125.15" + 1 = "126.15"

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

 

1235

1 + ."1234.56"

inc:{1 + . x}

inc "1234"

 

Some other examples.

2 3 4 5

 

 

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

 

=={{header|Kotlin}}==

 

/** overload ++ operator to increment a numeric string */

ns = "ghijk" // not numeric, so won't be changed by increment operator

println(++ns)

 

{{out}}

</pre>

 

 

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

 

{+ 123 1} // means "add the words 123 and 1"

-> 124 // can do the job and returns the result as a word

 

 

=={{header|Lasso}}==

-> 124

 

=={{header|LaTeX}}==

\newcounter{tmpnum}

\newcommand{\stringinc}[1]{%

\begin{document}

The number 12345 is followed by \stringinc{12345}.

 

=={{header|Liberty BASIC}}==

 

o$ ="12345"

print o$

 

 

=={{header|LIL}}==

Increment a numerical string, in LIL

##

set a "41"

inc a

 

{{out}}

 

=={{header|Lingo}}==

 

=={{header|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:

add 1 to myString -- automatically converts to a number

put "The number is:" && myString

 

=={{header|Logo}}==

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

 

=={{header|Logtalk}}==

 

=={{header|LOLCODE}}==

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

 

 

I HAS A foo ITZ "1234"

VISIBLE foo BTW, prints 1235

 

 

=={{header|LSL}}==

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

state_entry() {

llListen(PUBLIC_CHANNEL, "", llGetOwner(), "");

llOwnerSay("You said '"+sMessage+"' + 1 = "+(string)(((integer)sMessage)+1));

}

{{Out}}

<pre>Increment_a_Numerical_String: You said '99999999' + 1 = 100000000

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"

}

CheckIt

 

=={{header|M4}}==

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

define(`VN',`-123')dnl

eval(V+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)

 

=={{header|Maple}}==

 

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

 

=={{header|MATLAB}}==

numStr = num2str(str2double(numStr) + 1);

 

=={{header|MAXScript}}==

 

=={{header|Metafont}}==

s := "1234";

s := decimal(scantokens(s)+1);

 

=={{header|min}}==

{{works with|min|0.19.3}}

 

=={{header|mIRC Scripting Language}}==

inc %n

 

=={{header|ML}}==

==={{header|mLite}}===

 

==={{header|Standard ML}}===

 

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

 

IMPORT InOut, NumConv, Strings;

InOut.WriteString (str2);

InOut.WriteLn

<pre>"12345" + 1 = 12346</pre>

 

=={{header|Modula-3}}==

Modula-3 provides the module <tt>Scan</tt> for lexing.

 

IMPORT IO, Fmt, Scan;

num := Scan.Int(string);

IO.Put(string & " + 1 = " & Fmt.Int(num + 1) & "\n");

{{Out}}

<pre>

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

 

=={{header|Nanoquery}}==

 

=={{header|Neko}}==

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

 

 

=={{header|Nemerle}}==

 

=={{header|NetRexx}}==

In concert with [[REXX|Rexx]], NetRexx can use typeless variables. Typeless variable support is provided through the default NetRexx <code>'''Rexx'''</code> 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.

 

options replace format comments java crossref savelog symbols nobinary

 

return

{{Out}}

<pre>

 

=={{header|NewLISP}}==

 

=={{header|Nim}}==

 

=={{header|NS-HUBASIC}}==

 

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

 

IMPORT Out, Strings;

Out.String (str2);

Out.Ln

Producing:

<pre>jan@Beryllium:~/Oberon/obc$ Add

 

=={{header|Objeck}}==

s := "12345";

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

s := i->ToString();

 

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

int i = [s intValue] + 1;

 

=={{header|OCaml}}==

 

=={{header|Octave}}==

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

 

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

 

=={{header|Oforth}}==

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

 

 

{{out}}

=={{header|OoRexx}}==

ooRexx supports the += etc. operators:

i+=1

{{Out}}

<pre>

 

=={{header|OpenEdge/Progress}}==

 

MESSAGE

INTEGER( cc ) + 1

 

=={{header|Oz}}==

 

=={{header|PARI/GP}}==

 

=={{header|Pascal}}==

''See also [[#Free Pascal|Free Pascal]] and [[#Delphi|Delphi]]''

{{works with|Extended Pascal}}

program TestIncNumString;

type

IncMyString(MyNumString);

write(MyNumString);

{{out}}

<pre>12345 turns into 12346</pre>

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.

//increments a positive numerical string in different bases.

//the string must be preset with a value, length >0 ;

{$ENDIF}

type

function IncLoop(ps: pChar;le,Base: NativeInt):NativeInt;inline;

//Add 1 and correct carry

var

dg: nativeInt;

Begin

dec(le);//ps is 0-based

repeat

dec(le);

end;

procedure IncIntStr(base:NativeInt;var s:myString);

begin

//overflow -> prepend a '1' to string

end;

const

ONE_BILLION = 1000*1000*1000;

writeln(s:strLen,' base ',base:2,T0:8:3,' s');

end;

writeln;

writeln('One billion digits "9"');

{$ENDIF}

end.

{{out|@TIO.RUN}}

<pre>

67108863 increments in base

 

One billion digits "9"

first 5 digits 09999

first 5 digits 10000

</pre>

=={{header|Perl}}==

 

=={{header|Phix}}==

<span style="color: #004080;">integer</span> <span style="color: #0000FF;">{{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">}}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">scanf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"2047"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

2048

</pre>

 

=={{header|PHP}}==

 

=={{header|Picat}}==

===parse_term/1===

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

 

% integer

println(to_float=Float.to_float+1),

nl.

 

{{out}}

===parse_term/3===

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

T = "2**16+1",

println(t=T),

parse_term(T,Term, _Vars),

println(term=Term),

 

{{out}}

 

=={{header|PicoLisp}}==

 

=={{header|Pike}}==

number = (string)((int)number+1);

 

=={{header|PL/I}}==

s = '123456789';

s = s + 1;

<pre>

Note:

 

=={{header|Plain English}}==

Convert the numerical string to a number.

Add 1 to the number.

 

=={{header|plainTeX}}==

\def\stringinc#1{\acounter=#1\relax%

\advance\acounter by 1\relax%

\number\acounter}

The number 12345 is followed by \stringinc{12345}.

 

The generated page will contain the text:

 

=={{header|Pop11}}==

 

=={{header|PowerShell}}==

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

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

 

=={{header|Prolog}}==

Works with SWI-Prolog.

string_to_atom(S1, A1),

atom_number(A1, N1),

atom_number(A2, N2),

string_to_atom(S2, A2).

{{Out}}

S2 = "124".

 

=={{header|PureBasic}}==

string$=Str(Val(string$)+1)

 

=={{header|Python}}==

{{works with|Python|2.3 through 3.4}}

 

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.

 

 

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>42.0 pine martens in 1492 -0.5 mushrooms ≠ 137

 

=={{header|Quackery}}==

As a dialogue in the Quackery shell.

 

 

=={{header|R}}==

 

=={{header|Racket}}==

#lang racket

(define next (compose number->string add1 string->number))

 

=={{header|Raku}}==

(formerly Perl 6)

 

 

=={{header|Rascal}}==

import String;

 

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

{{Out}}

<pre>

 

=={{header|REBOL}}==

Title: "Increment Numerical String"

URL: http://rosettacode.org/wiki/Increment_numerical_string

print [x: "-99" "plus one equals" mold s++ x]

print [x: "42" "plus one equals" mold s++ x]

 

{{Out}}

 

=={{header|Retro}}==

 

=={{header|REXX}}==

REXX, like many other scripting languages, uses typeless variables.

<br>Typeless variables are stored as variable length character strings and can be treated as

<br>either a string or a numeric value, depending on the context in which they are used.

===version 1===

count = "3" /*REXX variables (and constants) are character strings.*/

count = 3 /*(identical to the above statement.) */

/* [↓] show the six leftmost and rightmost digs.*/

say 'count=' left(count,6)'···'right(count,6)

{{out}}

<pre>

Looking at the PL/I code I started investigating this situation in Rexx.

These are my findings:

* There is no equivalent to PL/I's SIZE condition in REXX.

* The result of an arithmetic expression is rounded

Say 'LOSTDIGITS condition raised in line' sigl

Say 'sourceline='sourceline(sigl)

{{Out}}

<pre>

 

=={{header|Ring}}==

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

 

=={{header|Ruby}}==

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

 

=={{header|Run BASIC}}==

Run BASIC has trim command for left and right

numeric = val(string$)

numeric = numeric + 1

string$ = str$(numeric)

print string$

<pre>12346</pre>

 

=={{header|Rust}}==

(input.parse::<i64>().unwrap() + 1).to_string()

}

let s2 = next_string(s);

println!("{:?}", s2);

{{out}}

<pre>"0"</pre>

handle most numeric strings. We define a method to do it.

 

 

Usage:

 

=={{header|Scheme}}==

 

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

 

 

 

=={{header|Seed7}}==

 

 

=={{header|SenseTalk}}==

put "123" + 1 // 124

 

=={{header|SequenceL}}==

 

 

=={{header|Sidef}}==

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

 

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

 

=={{header|SNOBOL4}}==

output = trim(input) + 1

output = "123" + 1

 

<pre>

124

</pre>

 

=={{header|Sparkling}}==

return fmtstr("%d", toint(s) + 1);

}

 

spn:1> numStrIncmt("12345")

 

=={{header|SuperTalk}}==

add 1 to someVar

-- without "into [field reference]" the value will appear

-- in the message box

 

=={{header|Swift}}==

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

if let x = Int(s) {

print("\(x + 1)")

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

if let x = s.toInt() {

println("\(x + 1)")

 

=={{header|Tcl}}==

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

 

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

:expr(Str1)+1→A

:{0,1}→L₁

:LinReg(ax+b) Y₁

:Equ►String(Y₁,Str1)

 

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

 

 

=={{header|Toka}}==

 

=={{header|TorqueScript}}==

$string += 10;

$string is now 12355.

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

teststring="0'1'-1'12345'10000000'-10000000"

PRINT n

ENDLOOP

{{Out}}

<pre>

 

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

 

(let ((len (length str-in))

(str (copy-str str-in)))

(set [str i] #\0))))))

@(bind a @(inc-num-str "9999"))

 

<pre>$ ./txr -B incnum.txr

==== No TXR Lisp ====

 

("5" "6") ("6" "7") ("7" "8") ("8" "9"))

@(define increment (num out))

@(end)

@in

 

<pre>$ echo 1 | ./txr -B incnum.txr -

 

{{works with|Bourne Shell}}

# Although num look like a number, it is in fact a numerical string

num=5

 

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

{{works with|pdksh}}

{{works with|zsh}}

let num=num+1 # Increment the number

let "num = num + 1" # Increment again. (We can use spaces inside quotes)

let num+=1 # This time we use +=

let "num += 1"

 

{{works with|ksh93}}

{{works with|pdksh}}

{{works with|zsh}}

 

==={{header|C Shell}}===

The <code>@</code> assignment command uses strings as integers.

 

=={{header|Ursa}}==

set num "123"

 

=={{header|Ursala}}==

 

test program:

 

{{Out}}

<pre>

=={{header|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:

<pre>

 

The long version handles arbitrary-length strings:

Public Function Lincr(astring As String) As String

'increment a number string, of whatever length

decrement = result

End Function

Examples:

<pre>

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.

 

The following example increments unsigned numeric string of unlimited length.

The current line in the edit buffer contains the string.

do {

if (At_BOL) {

Ins_Char(#1, OVERWRITE)

Char(-1)

 

=={{header|Visual Basic .NET}}==

 

s = CStr(CInt("123") + 1)

' or

 

module main

 

println("numstr: $numstr")

}

 

{{out}}

 

=={{header|Wren}}==

var n = Num.fromString(ns) + 1

var ns2 = "%(n)"

 

{{out}}

 

=={{header|XLISP}}==

 

=={{header|XPL0}}==

code Text=12;

 

IncStr(Str); IncStr(Str);

Text(0, Str);

 

{{out}}

0124000000001

</pre>

 

=={{header|zkl}}==

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

 

=={{header|Zoea}}==

program: increment_a_numerical_string

case: 1

input: '19'

output: '20'

 

=={{header|Zoea Visual}}==