Calculate sum of all numbers present in a string
Last Updated :
20 Mar, 2023
Given a string S containing alphanumeric characters, The task is to calculate the sum of all numbers present in the string.
Examples:
Input: 1abc23
Output: 24
Explanation: 1 + 23 = 24
Input: geeks4geeks
Output: 4
Input: 1abc2x30yz67
Output: 100
Approach:
Scan each character of the input string and if a number is formed by consecutive characters of the string, then increment the result by that amount. The only tricky part of this question is that multiple consecutive digits are considered one number.
Follow the below steps to implement the idea:
- Create an empty string temp and an integer sum.
- Iterate over all characters of the string.
- If the character is a numeric digit add it to temp.
- Else convert temp string to number and add it to sum, empty temp.
- Return sum + number obtained from temp.
Below is the implementation of the above approach:
C++
// C++ program to calculate sum of all numbers present
// in a string containing alphanumeric characters
#include <iostream>
using namespace std;
// Function to calculate sum of all numbers present
// in a string containing alphanumeric characters
int findSum(string str)
{
// A temporary string
string temp = "";
// holds sum of all numbers present in the string
int sum = 0;
// read each character in input string
for (char ch : str) {
// if current character is a digit
if (isdigit(ch))
temp += ch;
// if current character is an alphabet
else {
// increment sum by number found earlier
// (if any)
sum += atoi(temp.c_str());
// reset temporary string to empty
temp = "";
}
}
// atoi(temp.c_str()) takes care of trailing
// numbers
return sum + atoi(temp.c_str());
}
// Driver code
int main()
{
// input alphanumeric string
string str = "12abc20yz68";
// Function call
cout << findSum(str);
return 0;
}
// Java program to calculate sum of all numbers present
// in a string containing alphanumeric characters
import java.io.*;
class GFG {
// Function to calculate sum of all numbers present
// in a string containing alphanumeric characters
static int findSum(String str)
{
// A temporary string
String temp = "0";
// holds sum of all numbers present in the string
int sum = 0;
// read each character in input string
for (int i = 0; i < str.length(); i++) {
char ch = str.charAt(i);
// if current character is a digit
if (Character.isDigit(ch))
temp += ch;
// if current character is an alphabet
else {
// increment sum by number found earlier
// (if any)
sum += Integer.parseInt(temp);
// reset temporary string to empty
temp = "0";
}
}
// atoi(temp.c_str()) takes care of trailing
// numbers
return sum + Integer.parseInt(temp);
}
// Driver code
public static void main(String[] args)
{
// input alphanumeric string
String str = "12abc20yz68";
// Function call
System.out.println(findSum(str));
}
}
// This code is contributed by AnkitRai01
# Python3 program to calculate sum of
# all numbers present in a string
# containing alphanumeric characters
# Function to calculate sum of all
# numbers present in a string
# containing alphanumeric characters
def findSum(str1):
# A temporary string
temp = "0"
# holds sum of all numbers
# present in the string
Sum = 0
# read each character in input string
for ch in str1:
# if current character is a digit
if (ch.isdigit()):
temp += ch
# if current character is an alphabet
else:
# increment Sum by number found
# earlier(if any)
Sum += int(temp)
# reset temporary string to empty
temp = "0"
# atoi(temp.c_str1()) takes care
# of trailing numbers
return Sum + int(temp)
# Driver code
# input alphanumeric string
str1 = "12abc20yz68"
# Function call
print(findSum(str1))
# This code is contributed
# by mohit kumar
// C# program to calculate sum of
// all numbers present in a string
// containing alphanumeric characters
using System;
class GFG {
// Function to calculate sum of
// all numbers present in a string
// containing alphanumeric characters
static int findSum(String str)
{
// A temporary string
String temp = "0";
// holds sum of all numbers
// present in the string
int sum = 0;
// read each character in input string
for (int i = 0; i < str.Length; i++) {
char ch = str[i];
// if current character is a digit
if (char.IsDigit(ch))
temp += ch;
// if current character is an alphabet
else {
// increment sum by number found earlier
// (if any)
sum += int.Parse(temp);
// reset temporary string to empty
temp = "0";
}
}
// atoi(temp.c_str()) takes care of trailing
// numbers
return sum + int.Parse(temp);
}
// Driver code
public static void Main(String[] args)
{
// input alphanumeric string
String str = "12abc20yz68";
// Function call
Console.WriteLine(findSum(str));
}
}
// This code is contributed by PrinciRaj1992
<script>
// Javascript program to calculate
// sum of all numbers present
// in a string containing
// alphanumeric characters
// Function to calculate sum
// of all numbers present
// in a string containing
// alphanumeric characters
function findSum(str)
{
// A temporary string
let temp = "0";
// holds sum of all numbers
// present in the string
let sum = 0;
// read each character in input string
for (let i = 0; i < str.length; i++) {
let ch = str[i];
// if current character is a digit
if (!isNaN(String(ch) * 1))
temp += ch;
// if current character is an alphabet
else {
// increment sum by number found earlier
// (if any)
sum += parseInt(temp);
// reset temporary string to empty
temp = "0";
}
}
// atoi(temp.c_str()) takes care of trailing
// numbers
return sum + parseInt(temp);
}
// Driver code
// input alphanumeric string
let str = "12abc20yz68";
// Function call
document.write(findSum(str));
// This code is contributed by unknown2108
</script>
Time complexity: O(N) where n is length of the string.
Auxiliary Space: O(N) where n is length of the string.
Calculate sum of all numbers present in a string using recursion
The idea is to recursively traverse over the string and find out the numbers then add these numbers to the result, at last return the result.
Follow the below steps to implement the idea:
- Create an empty string temp and an integer sum.
- Recursively traverse the characters for every index i from 0 to length - 1.
- If i = N-1 then check if current character is a digit return str[i] - '0'.
- Else return 0.
- If str[i] is a digit.
- Run a for loop with counter j from i to N - 1.
- If the character is a numeric digit add it to temp.
- Else break.
- Return sum of numeric value of temp + recur for index j.
Below is the implementation of the above approach:
C++
// C++ program to calculate sum of all numbers
// present in a string containing alphanumeric
// characters
#include <iostream>
using namespace std;
int solve(string& str, int i, int n)
{
// if string is empty
if (i >= n)
return 0;
// if on the last index
if (i == n - 1) {
// if last digit is numeric
if (isdigit(str[i])) {
return str[i] - '0';
}
else {
return 0;
}
}
// if current char is digit
// then sum the consecutive digits
if (isdigit(str[i])) {
// declared an empty string
string temp = "";
int j;
// start from that index
// sum all the consecutive digits
for (j = i; j < n; j++) {
// if current char is digit
// add it to the temp string
if (isdigit(str[j]))
temp += str[j];
// if it is not a digit
// break instantly
else
break;
}
// add the number associated to temp
// with the answer recursion will bring
return stoi(temp) + solve(str, j, n);
}
// else call from the next index
else {
solve(str, i + 1, n);
}
}
int findSum(string str)
{
// recursiven function
return solve(str, 0, str.size());
}
// Driver code
int main()
{
// input alphanumeric string
string str = "12abc20yz68";
// Function call
cout << findSum(str);
return 0;
}
import java.util.Scanner;
class Main {
static int solve(String str, int i, int n) {
// if string is empty
if (i >= n)
return 0;
// if on the last index
if (i == n - 1) {
// if last digit is numeric
if (Character.isDigit(str.charAt(i))) {
return str.charAt(i) - '0';
}
else {
return 0;
}
}
// if current char is digit
// then sum the consecutive digits
if (Character.isDigit(str.charAt(i))) {
// declared an empty string
String temp = "";
int j;
// start from that index
// sum all the consecutive digits
for (j = i; j < n; j++) {
// if current char is digit
// add it to the temp string
if (Character.isDigit(str.charAt(j)))
temp += str.charAt(j);
// if it is not a digit
// break instantly
else
break;
}
// add the number associated to temp
// with the answer recursion will bring
return Integer.parseInt(temp) + solve(str, j, n);
}
// else call from the next index
else {
return solve(str, i + 1, n);
}
}
static int findSum(String str) {
// recursiven function
return solve(str, 0, str.length());
}
// Driver code
public static void main(String[] args) {
// input alphanumeric string
String str = "12abc20yz68";
// Function call
System.out.println(findSum(str));
}
}
// This code contributed by Ajax
def findSum(str):
# variable to store sum
result = 0
temp = ""
for i in range(len(str)):
if str[i].isnumeric():
temp += str[i]
if i == len(str) - 1:
result += int(temp)
else:
if temp != "":
result += int(temp)
temp = ""
return result
# driver code
if __name__ == "__main__":
# input alphanumeric string
str = "12abc20yz68"
print(findSum(str))
#This code contributed by Shivam Tiwari
// C# program to calculate sum of all numbers
// present in a string containing alphanumeric
// characters
using System;
using System.Linq;
using System.Collections.Generic;
class GFG
{
static bool isdigit(char c)
{
if(c>='0' && c<='9')
return true;
return false;
}
static int solve(string str, int i, int n)
{
// if string is empty
if (i >= n)
return 0;
// if on the last index
if (i == n - 1) {
// if last digit is numeric
if (isdigit(str[i])) {
return str[i];
}
else {
return 0;
}
}
// if current char is digit
// then sum the consecutive digits
if (isdigit(str[i])) {
// declared an empty string
string temp = "";
int j;
// start from that index
// sum all the consecutive digits
for (j = i; j < n; j++) {
// if current char is digit
// add it to the temp string
if (isdigit(str[j]))
temp += str[j];
// if it is not a digit
// break instantly
else
break;
}
// add the number associated to temp
// with the answer recursion will bring
return Int32.Parse(temp) + solve(str, j, n);
}
// else call from the next index
else {
return solve(str, i + 1, n);
}
}
static int findSum(string str)
{
// recursiven function
return solve(str, 0, str.Length);
}
// Driver code
static public void Main()
{
// input alphanumeric string
string str = "12abc20yz68";
// Function call
Console.Write(findSum(str));
}
}
function findSum(str) {
// variable to store sum
let result = 0;
let temp = "";
for (let i = 0; i < str.length; i++) {
if (!isNaN(str[i])) {
temp += str[i];
if (i === str.length - 1) {
result += parseInt(temp);
}
} else {
if (temp !== "") {
result += parseInt(temp);
temp = "";
}
}
}
return result;
}
// driver code
console.log(findSum("12abc20yz68"));
// This code is contributed by Shivam Tiwari
Time Complexity: O(N), where N is the size of the given string.
Auxiliary Space: O(N), in worst case it can cost O(N) recursive calls
Calculate sum of all numbers present in a string using Regex in Python:
The idea is to use inbuilt function Python RegEx.
Below is the Implementation of above approach:
C++14
#include <iostream>
#include <regex>
// Function to calculate sum of all
// numbers present in a string
// containing alphanumeric characters
int findSum(std::string str) {
// Regular Expression that matches
// digits in between a string
std::regex pattern("\\d+");
std::smatch match;
int sum = 0;
while (std::regex_search(str, match, pattern)) {
sum += stoi(match[0].str());
str = match.suffix().str();
}
return sum;
}
// Driver code
int main() {
// input alphanumeric string
std::string str = "12abc20yz68";
// Function call
std::cout << findSum(str) << std::endl;
return 0;
}
// This code is contributed by Shivam Tiwari
# Python3 program to calculate sum of
# all numbers present in a string
# containing alphanumeric characters
# Function to calculate sum of all
# numbers present in a string
# containing alphanumeric characters
import re
def find_sum(str1):
# Regular Expression that matches
# digits in between a string
return sum(map(int, re.findall('\d+', str1)))
# Driver code
# input alphanumeric string
str1 = "12abc20yz68"
# Function call
print(find_sum(str1))
# This code is contributed
# by Venkata Ramana B
// JavaScript program to calculate sum of
// all numbers present in a string
// containing alphanumeric characters
// Function to calculate sum of all
// numbers present in a string
// containing alphanumeric characters
function find_sum(str1) {
// Regular Expression that matches
// digits in between a string
return str1.match(/\d+/g).reduce((acc, val) => acc + parseInt(val), 0);
}
// Driver code
// input alphanumeric string
const str1 = "12abc20yz68";
// Function call
console.log(find_sum(str1));
import java.util.regex.*;
public class Main {
// Function to calculate sum of all
// numbers present in a string
// containing alphanumeric characters
public static int findSum(String str)
{
// Regular Expression that matches
// digits in between a string
Pattern pattern = Pattern.compile("\\d+");
Matcher matcher = pattern.matcher(str);
int sum = 0;
while (matcher.find()) {
sum += Integer.parseInt(matcher.group());
str = matcher.replaceFirst("");
matcher = pattern.matcher(str);
}
return sum;
}
// Driver code
public static void main(String[] args)
{
// input alphanumeric string
String str = "12abc20yz68";
// Function call
System.out.println(findSum(str));
}
}
using System;
using System.Text.RegularExpressions;
public class GFG
{
// Function to calculate sum of all
// numbers present in a string
// containing alphanumeric characters
public static int FindSum(string str)
{
// Regular Expression that matches
// digits in between a string
Regex pattern = new Regex(@"\d+");
Match matcher = pattern.Match(str);
int sum = 0;
while (matcher.Success)
{
sum += Int32.Parse(matcher.Value);
str = pattern.Replace(str, "", 1, matcher.Index);
matcher = pattern.Match(str);
}
return sum;
}
// Main method
static public void Main()
{
// input alphanumeric string
string str = "12abc20yz68";
// Function call
Console.WriteLine(FindSum(str));
}
}
Time complexity: O(n) where n is length of the string.
Auxiliary Space: O(n) where n is length of the string.
Similar Reads
Basics & Prerequisites
Data Structures
Array Data StructureIn this article, we introduce array, implementation in different popular languages, its basic operations and commonly seen problems / interview questions. An array stores items (in case of C/C++ and Java Primitive Arrays) or their references (in case of Python, JS, Java Non-Primitive) at contiguous
3 min read
String in Data StructureA string is a sequence of characters. The following facts make string an interesting data structure.Small set of elements. Unlike normal array, strings typically have smaller set of items. For example, lowercase English alphabet has only 26 characters. ASCII has only 256 characters.Strings are immut
2 min read
Hashing in Data StructureHashing is a technique used in data structures that efficiently stores and retrieves data in a way that allows for quick access. Hashing involves mapping data to a specific index in a hash table (an array of items) using a hash function. It enables fast retrieval of information based on its key. The
2 min read
Linked List Data StructureA linked list is a fundamental data structure in computer science. It mainly allows efficient insertion and deletion operations compared to arrays. Like arrays, it is also used to implement other data structures like stack, queue and deque. Here’s the comparison of Linked List vs Arrays Linked List:
2 min read
Stack Data StructureA Stack is a linear data structure that follows a particular order in which the operations are performed. The order may be LIFO(Last In First Out) or FILO(First In Last Out). LIFO implies that the element that is inserted last, comes out first and FILO implies that the element that is inserted first
2 min read
Queue Data StructureA Queue Data Structure is a fundamental concept in computer science used for storing and managing data in a specific order. It follows the principle of "First in, First out" (FIFO), where the first element added to the queue is the first one to be removed. It is used as a buffer in computer systems
2 min read
Tree Data StructureTree Data Structure is a non-linear data structure in which a collection of elements known as nodes are connected to each other via edges such that there exists exactly one path between any two nodes. Types of TreeBinary Tree : Every node has at most two childrenTernary Tree : Every node has at most
4 min read
Graph Data StructureGraph Data Structure is a collection of nodes connected by edges. It's used to represent relationships between different entities. If you are looking for topic-wise list of problems on different topics like DFS, BFS, Topological Sort, Shortest Path, etc., please refer to Graph Algorithms. Basics of
3 min read
Trie Data StructureThe Trie data structure is a tree-like structure used for storing a dynamic set of strings. It allows for efficient retrieval and storage of keys, making it highly effective in handling large datasets. Trie supports operations such as insertion, search, deletion of keys, and prefix searches. In this
15+ min read
Algorithms
Searching AlgorithmsSearching algorithms are essential tools in computer science used to locate specific items within a collection of data. In this tutorial, we are mainly going to focus upon searching in an array. When we search an item in an array, there are two most common algorithms used based on the type of input
2 min read
Sorting AlgorithmsA Sorting Algorithm is used to rearrange a given array or list of elements in an order. For example, a given array [10, 20, 5, 2] becomes [2, 5, 10, 20] after sorting in increasing order and becomes [20, 10, 5, 2] after sorting in decreasing order. There exist different sorting algorithms for differ
3 min read
Introduction to RecursionThe process in which a function calls itself directly or indirectly is called recursion and the corresponding function is called a recursive function. A recursive algorithm takes one step toward solution and then recursively call itself to further move. The algorithm stops once we reach the solution
14 min read
Greedy AlgorithmsGreedy algorithms are a class of algorithms that make locally optimal choices at each step with the hope of finding a global optimum solution. At every step of the algorithm, we make a choice that looks the best at the moment. To make the choice, we sometimes sort the array so that we can always get
3 min read
Graph AlgorithmsGraph is a non-linear data structure like tree data structure. The limitation of tree is, it can only represent hierarchical data. For situations where nodes or vertices are randomly connected with each other other, we use Graph. Example situations where we use graph data structure are, a social net
3 min read
Dynamic Programming or DPDynamic Programming is an algorithmic technique with the following properties.It is mainly an optimization over plain recursion. Wherever we see a recursive solution that has repeated calls for the same inputs, we can optimize it using Dynamic Programming. The idea is to simply store the results of
3 min read
Bitwise AlgorithmsBitwise algorithms in Data Structures and Algorithms (DSA) involve manipulating individual bits of binary representations of numbers to perform operations efficiently. These algorithms utilize bitwise operators like AND, OR, XOR, NOT, Left Shift, and Right Shift.BasicsIntroduction to Bitwise Algorit
4 min read
Advanced
Segment TreeSegment Tree is a data structure that allows efficient querying and updating of intervals or segments of an array. It is particularly useful for problems involving range queries, such as finding the sum, minimum, maximum, or any other operation over a specific range of elements in an array. The tree
3 min read
Pattern SearchingPattern searching algorithms are essential tools in computer science and data processing. These algorithms are designed to efficiently find a particular pattern within a larger set of data. Patten SearchingImportant Pattern Searching Algorithms:Naive String Matching : A Simple Algorithm that works i
2 min read
GeometryGeometry is a branch of mathematics that studies the properties, measurements, and relationships of points, lines, angles, surfaces, and solids. From basic lines and angles to complex structures, it helps us understand the world around us.Geometry for Students and BeginnersThis section covers key br
2 min read
Interview Preparation
Practice Problem