Lexicographically next string

Count number of binary strings without consecutive 1's

Last Updated : 16 Dec, 2024

Given a positive integer n, the task is to count all possible distinct binary strings of length n such that there are no consecutive 1's.

Examples:

Input: n = 3
Output: 5
Explanation: 5 strings are ("000", "001", "010", "100", "101").
Input: n = 2
Output: 3
Explanation: 3 strings are ("00", "01", "10").

Try it on GfG Practice

Table of Content

Using Recursion - O(2^n) Time and O(n) Space
Using Top-Down DP (Memoization) - O(n) Time and O(n) Space
Using Bottom-Up DP (Tabulation) - O(n) Time and O(n) Space
Using Space Optimized DP - O(n) Time and O(1) Space
Using Matrix Exponentiation - O(logn) Time and O(logn) Space

Using Recursion - O(2^n) Time and O(n) Space

The idea is to explore two possible choices at each step of building the binary string. When constructing a string of length n, at each index, we have two choices: either place a 0 or place a 1. If we choose to place a 0, we can proceed to the next index. However, if we choose to place a 1, we must ensure that the next index does not contain a 1, so we skip the next index.
Mathematically the recurrence relation will look like the following:
countStrings(i) = countStrings(i+1) + countStrings(i+2)
Base Case:
countStrings(i) = 1, if i >= n.

C++

// C++ program to count number of binary
// strings without consecutive 1's using recursion
#include <bits/stdc++.h>
using namespace std;

int countRecur(int i, int n) {
    
    // Base case
    if (i >= n) return 1;
    
    // If we take 1 at ith index, 
    // we cannot have 1 at (i-1)
    int take = countRecur(i+2, n);
    
    // If we skip 1, we can consider
    // 1 at i-1.
    int noTake = countRecur(i+1, n);
    
    return take + noTake;
}

int countStrings(int n) {
    return countRecur(0, n);
}

int main() {
    int n = 3;
    cout << countStrings(n);

    return 0;
}

 
// C++ program to count number of binary
// strings without consecutive 1's using recursion#include <bits/stdc++.h>using namespace std;​int countRecur(int i, int n) {        // Base case    if (i >= n) return 1;        // If we take 1 at ith index,     // we cannot have 1 at (i-1)    int take = countRecur(i+2, n);        // If we skip 1, we can consider    // 1 at i-1.    int noTake = countRecur(i+1, n);        return take + noTake;}​int countStrings(int n) {    return countRecur(0, n);}​int main() {    int n = 3;    cout << countStrings(n);​    return 0;}

Java

// Java program to count number of binary
// strings without consecutive 1's using recursion

class GfG {
    static int countRecur(int i, int n) {
      
        // Base case
        if (i >= n) return 1;

        // If we take 1 at ith index, 
        // we cannot have 1 at (i-1)
        int take = countRecur(i + 2, n);

        // If we skip 1, we can consider
        // 1 at i-1.
        int noTake = countRecur(i + 1, n);

        return take + noTake;
    }

    static int countStrings(int n) {
        return countRecur(0, n);
    }

    public static void main(String[] args) {
        int n = 3;
        System.out.println(countStrings(n));
    }
}

Python

# Python program to count number of binary
# strings without consecutive 1's using recursion

def countRecur(i, n):
  
    # Base case
    if i >= n:
        return 1

    # If we take 1 at ith index, 
    # we cannot have 1 at (i-1)
    take = countRecur(i + 2, n)

    # If we skip 1, we can consider
    # 1 at i-1.
    noTake = countRecur(i + 1, n)

    return take + noTake

def countStrings(n):
    return countRecur(0, n)

if __name__ == "__main__":
    n = 3
    print(countStrings(n))

C#

// C# program to count number of binary
// strings without consecutive 1's using recursion

using System;

class GfG {
    static int countRecur(int i, int n) {
      
        // Base case
        if (i >= n) return 1;

        // If we take 1 at ith index, 
        // we cannot have 1 at (i-1)
        int take = countRecur(i + 2, n);

        // If we skip 1, we can consider
        // 1 at i-1.
        int noTake = countRecur(i + 1, n);

        return take + noTake;
    }

    static int countStrings(int n) {
        return countRecur(0, n);
    }

    static void Main(string[] args) {
        int n = 3;
        Console.WriteLine(countStrings(n));
    }
}

JavaScript

// JavaScript program to count number of binary
// strings without consecutive 1's using recursion

function countRecur(i, n) {

    // Base case
    if (i >= n) return 1;

    // If we take 1 at ith index, 
    // we cannot have 1 at (i-1)
    let take = countRecur(i + 2, n);

    // If we skip 1, we can consider
    // 1 at i-1.
    let noTake = countRecur(i + 1, n);

    return take + noTake;
}

function countStrings(n) {
    return countRecur(0, n);
}

const n = 3;
console.log(countStrings(n));

Output

Using Top-Down DP (Memoization) - O(n) Time and O(n) Space

If we notice carefully, we can observe that the above recursive solution holds the following two properties of Dynamic Programming:

1. Optimal Substructure: Number of ways to make binary string at i'th index depends on the optimal solutions of countStrings(i+1) and countStrings(i+2). By combining these substructures, we can efficiently calculate number of ways to make binary strings with consecutive 1's at index i.
2. Overlapping Subproblems: While applying a recursive approach in this problem, we notice that certain subproblems are computed multiple times. For example, while calculating countStrings(3), countStrings(4) and countStrings(5) are called. countStrings(4) will again call countStrings(5) which will lead to Overlapping Subproblems.

There is only one parameter: i that changes in the recursive solution. So we create a 1D array of size n for memoization.
We initialize this array as -1 to indicate nothing is computed initially.
Now we modify our recursive solution to first check if the value is -1, then only make recursive calls. This way, we avoid re-computations of the same subproblems.

C++

// C++ program to count number of binary
// strings without consecutive 1's using memoization
#include <bits/stdc++.h>
using namespace std;

int countRecur(int i, int n, vector<int> &memo) {
    
    // Base case
    if (i >= n) return 1;
    
    // If value is memoized
    if (memo[i]!=-1) return memo[i];
    
    // If we take 1 at ith index, 
    // we cannot have 1 at (i-1)
    int take = countRecur(i+2, n, memo);
    
    // If we skip 1, we can consider
    // 1 at i-1.
    int noTake = countRecur(i+1, n, memo);
    
    return memo[i] = take + noTake;
}

int countStrings(int n) {
    
    vector<int> memo(n, -1);
    return countRecur(0, n, memo);
}

int main() {
    int n = 3;
    cout << countStrings(n);

    return 0;
}

 
// C++ program to count number of binary
// strings without consecutive 1's using memoization#include <bits/stdc++.h>using namespace std;​int countRecur(int i, int n, vector<int> &memo) {        // Base case    if (i >= n) return 1;        // If value is memoized    if (memo[i]!=-1) return memo[i];        // If we take 1 at ith index,     // we cannot have 1 at (i-1)    int take = countRecur(i+2, n, memo);        // If we skip 1, we can consider    // 1 at i-1.    int noTake = countRecur(i+1, n, memo);        return memo[i] = take + noTake;}​int countStrings(int n) {        vector<int> memo(n, -1);    return countRecur(0, n, memo);}​int main() {    int n = 3;    cout << countStrings(n);​    return 0;}

Java

// Java program to count number of binary
// strings without consecutive 1's using memoization

class GfG {
    static int countRecur(int i, int n, int[] memo) {
      
        // Base case
        if (i >= n) return 1;

        // If value is memoized
        if (memo[i] != -1) return memo[i];

        // If we take 1 at ith index, 
        // we cannot have 1 at (i-1)
        int take = countRecur(i + 2, n, memo);

        // If we skip 1, we can consider
        // 1 at i-1.
        int noTake = countRecur(i + 1, n, memo);

        return memo[i] = take + noTake;
    }

    static int countStrings(int n) {
        int[] memo = new int[n];
        for (int j = 0; j < n; j++) memo[j] = -1;
        return countRecur(0, n, memo);
    }

    public static void main(String[] args) {
        int n = 3;
        System.out.println(countStrings(n));
    }
}

Python

# Python program to count number of binary
# strings without consecutive 1's using memoization

def countRecur(i, n, memo):
  
    # Base case
    if i >= n:
        return 1

    # If value is memoized
    if memo[i] != -1:
        return memo[i]

    # If we take 1 at ith index, 
    # we cannot have 1 at (i-1)
    take = countRecur(i + 2, n, memo)

    # If we skip 1, we can consider
    # 1 at i-1.
    noTake = countRecur(i + 1, n, memo)

    memo[i] = take + noTake
    return memo[i]

def countStrings(n):
    memo = [-1] * n
    return countRecur(0, n, memo)

if __name__ == "__main__":
    n = 3
    print(countStrings(n))

C#

// C# program to count number of binary
// strings without consecutive 1's using memoization

using System;

class GfG {
    static int countRecur(int i, int n, int[] memo) {
      
        // Base case
        if (i >= n) return 1;

        // If value is memoized
        if (memo[i] != -1) return memo[i];

        // If we take 1 at ith index, 
        // we cannot have 1 at (i-1)
        int take = countRecur(i + 2, n, memo);

        // If we skip 1, we can consider
        // 1 at i-1.
        int noTake = countRecur(i + 1, n, memo);

        return memo[i] = take + noTake;
    }

    static int countStrings(int n) {
        int[] memo = new int[n];
        for (int j = 0; j < n; j++) memo[j] = -1;
        return countRecur(0, n, memo);
    }

    static void Main(string[] args) {
        int n = 3;
        Console.WriteLine(countStrings(n));
    }
}

JavaScript

// JavaScript program to count number of binary
// strings without consecutive 1's using memoization

function countRecur(i, n, memo) {

    // Base case
    if (i >= n) return 1;

    // If value is memoized
    if (memo[i] !== -1) return memo[i];

    // If we take 1 at ith index, 
    // we cannot have 1 at (i-1)
    let take = countRecur(i + 2, n, memo);

    // If we skip 1, we can consider
    // 1 at i-1.
    let noTake = countRecur(i + 1, n, memo);

    return memo[i] = take + noTake;
}

function countStrings(n) {
    let memo = Array(n).fill(-1);
    return countRecur(0, n, memo);
}

const n = 3;
console.log(countStrings(n));

Output

Using Bottom-Up DP (Tabulation) - O(n) Time and O(n) Space

The idea is to fill the DP table based on next values. For each index, we can either place 1 or 0. The array is filled in an iterative manner from i = n-1 to i = 0.
The dynamic programming relation is as follows:
dp[i] = dp[i+1] + dp[i+2]

C++

// C++ program to count number of binary
// strings without consecutive 1's using tabulation
#include <bits/stdc++.h>
using namespace std;

int countStrings(int n) {
    if (n == 1)
        return 2;
    if (n == 2)
        return 3;

    vector<int> dp(n);
    dp[n - 1] = 2;
    dp[n - 2] = 3;

    for (int i = n - 3; i >= 0; i--) {
        dp[i] = dp[i + 1] + dp[i + 2];
    }

    return dp[0];
}

int main() {
  
    int n = 3;
    cout << countStrings(n);

    return 0;
}

 
// C++ program to count number of binary
// strings without consecutive 1's using tabulation#include <bits/stdc++.h>using namespace std;​int countStrings(int n) {    if (n == 1)        return 2;    if (n == 2)        return 3;​    vector<int> dp(n);    dp[n - 1] = 2;    dp[n - 2] = 3;​    for (int i = n - 3; i >= 0; i--) {        dp[i] = dp[i + 1] + dp[i + 2];    }​    return dp[0];}​int main() {      int n = 3;    cout << countStrings(n);​    return 0;}

Java

// Java program to count number of binary
// strings without consecutive 1's using tabulation

class GfG {
    static int countStrings(int n) {
        if (n == 1) return 2;
        if (n == 2) return 3;

        int[] dp = new int[n];
        dp[n - 1] = 2;
        dp[n - 2] = 3;

        for (int i = n - 3; i >= 0; i--) {
            dp[i] = dp[i + 1] + dp[i + 2];
        }

        return dp[0];
    }

    public static void main(String[] args) {
        int n = 3;
        System.out.println(countStrings(n));
    }
}

Python

# Python program to count number of binary
# strings without consecutive 1's using tabulation

def countStrings(n):
    if n == 1:
        return 2
    if n == 2:
        return 3

    dp = [0] * n
    dp[n - 1] = 2
    dp[n - 2] = 3

    for i in range(n - 3, -1, -1):
        dp[i] = dp[i + 1] + dp[i + 2]

    return dp[0]

if __name__ == "__main__":
    n = 3
    print(countStrings(n))

C#

// C# program to count number of binary
// strings without consecutive 1's using tabulation

using System;

class GfG {
    static int countStrings(int n) {
        if (n == 1) return 2;
        if (n == 2) return 3;

        int[] dp = new int[n];
        dp[n - 1] = 2;
        dp[n - 2] = 3;

        for (int i = n - 3; i >= 0; i--) {
            dp[i] = dp[i + 1] + dp[i + 2];
        }

        return dp[0];
    }

    static void Main(string[] args) {
        int n = 3;
        Console.WriteLine(countStrings(n));
    }
}

JavaScript

// JavaScript program to count number of binary
// strings without consecutive 1's using tabulation

function countStrings(n) {
    if (n === 1) return 2;
    if (n === 2) return 3;

    const dp = new Array(n).fill(0);
    dp[n - 1] = 2;
    dp[n - 2] = 3;

    for (let i = n - 3; i >= 0; i--) {
        dp[i] = dp[i + 1] + dp[i + 2];
    }

    return dp[0];
}

const n = 3;
console.log(countStrings(n));

Output

Using Space Optimized DP - O(n) Time and O(1) Space

In previous approach of dynamic programming we have derive the relation between states as given below:
dp[i] = dp[i+1] + dp[i+2]
We observe that for calculating dp[i] state we only need dp[i+1] and dp[i+2]. There is no need to store all the next states.

C++

// C++ program to count number of binary
// strings without consecutive 1's
// using space optimised dp
#include <bits/stdc++.h>
using namespace std;

int countStrings(int n) {
    if (n == 1)
        return 2;
    if (n == 2)
        return 3;

    int prev1 = 3, prev2 = 2;

    for (int i = n - 3; i >= 0; i--) {
        int curr = prev1 + prev2;

        prev2 = prev1;
        prev1 = curr;
    }

    return prev1;
}

int main() {
    int n = 3;
    cout << countStrings(n);

    return 0;
}

 
// C++ program to count number of binary
// strings without consecutive 1's// using space optimised dp#include <bits/stdc++.h>using namespace std;​int countStrings(int n) {    if (n == 1)        return 2;    if (n == 2)        return 3;​    int prev1 = 3, prev2 = 2;​    for (int i = n - 3; i >= 0; i--) {        int curr = prev1 + prev2;​        prev2 = prev1;        prev1 = curr;    }​    return prev1;}​int main() {    int n = 3;    cout << countStrings(n);​    return 0;}

Java

// Java program to count number of binary
// strings without consecutive 1's
// using space optimised dp

class GfG {
    static int countStrings(int n) {
        if (n == 1)
            return 2;
        if (n == 2)
            return 3;

        int prev1 = 3, prev2 = 2;

        for (int i = n - 3; i >= 0; i--) {
            int curr = prev1 + prev2;

            prev2 = prev1;
            prev1 = curr;
        }

        return prev1;
    }

    public static void main(String[] args) {
        int n = 3;
        System.out.println(countStrings(n));
    }
}

Python

# Python program to count number of binary
# strings without consecutive 1's
# using space optimised dp

def countStrings(n):
    if n == 1:
        return 2
    if n == 2:
        return 3

    prev1, prev2 = 3, 2

    for i in range(n - 3, -1, -1):
        curr = prev1 + prev2

        prev2 = prev1
        prev1 = curr

    return prev1

if __name__ == "__main__":
    n = 3
    print(countStrings(n))

C#

// C# program to count number of binary
// strings without consecutive 1's
// using space optimised dp

using System;

class GfG {
    static int countStrings(int n) {
        if (n == 1)
            return 2;
        if (n == 2)
            return 3;

        int prev1 = 3, prev2 = 2;

        for (int i = n - 3; i >= 0; i--) {
            int curr = prev1 + prev2;

            prev2 = prev1;
            prev1 = curr;
        }

        return prev1;
    }

    static void Main(string[] args) {
        int n = 3;
        Console.WriteLine(countStrings(n));
    }
}

JavaScript

// JavaScript program to count number of binary
// strings without consecutive 1's
// using space optimised dp

function countStrings(n) {
    if (n === 1)
        return 2;
    if (n === 2)
        return 3;

    let prev1 = 3, prev2 = 2;

    for (let i = n - 3; i >= 0; i--) {
        let curr = prev1 + prev2;

        prev2 = prev1;
        prev1 = curr;
    }

    return prev1;
}

const n = 3;
console.log(countStrings(n));

Output

Using Matrix Exponentiation - O(logn) Time and O(logn) Space

The recurrence relation to count binary strings of length i is:
F(i) = F(i-1) + F(i-2)
with bases cases F(1) = 2 and F(2) = 3.
Matrix exponentiation can be used to solve this problem in O(logn) time. Refer to Matrix Exponentiation for detailed approach.

C++

// C++ program to count number of binary
// strings without consecutive 1's
#include <bits/stdc++.h>
using namespace std;

// Function to mutiply two matrices
vector<vector<int>> multiply(vector<vector<int>>& v1, vector<vector<int>>& v2) {
    vector<vector<int>> ans(2, vector<int>(2, 0));

    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            for (int k = 0; k < 2; k++) {
                ans[i][j] += v1[i][k] * v2[k][j];
            }
        }
    }

    return ans;
}

// Function to find matrix to the power n.
vector<vector<int>> power(vector<vector<int>> &v, int n) {
    if (n == 0) {
        return {{1, 0}, {0, 1}};
    }

    vector<vector<int>> res = power(v, n / 2);

    res = multiply(res, res);

    if (n % 2 == 1)
        res = multiply(res, v);

    return res;
}

int countStrings(int n) {
    if (n == 2)
        return 3;
    if (n == 1)
        return 2;
    vector<vector<int>> v = {{1, 1}, {1, 0}};
    vector<vector<int>> p = power(v, n - 2);

    int ans = p[0][0] * 3 + p[0][1] * 2;
    return ans;
}

int main() {
    int n = 3;
    cout << countStrings(n);

    return 0;
}

 
// C++ program to count number of binary
// strings without consecutive 1's#include <bits/stdc++.h>using namespace std;​// Function to mutiply two matricesvector<vector<int>> multiply(vector<vector<int>>& v1, vector<vector<int>>& v2) {    vector<vector<int>> ans(2, vector<int>(2, 0));​    for (int i = 0; i < 2; i++) {        for (int j = 0; j < 2; j++) {            for (int k = 0; k < 2; k++) {                ans[i][j] += v1[i][k] * v2[k][j];            }        }    }​    return ans;}​// Function to find matrix to the power n.vector<vector<int>> power(vector<vector<int>> &v, int n) {    if (n == 0) {        return {{1, 0}, {0, 1}};    }​    vector<vector<int>> res = power(v, n / 2);​    res = multiply(res, res);​    if (n % 2 == 1)        res = multiply(res, v);​    return res;}​int countStrings(int n) {    if (n == 2)        return 3;    if (n == 1)        return 2;    vector<vector<int>> v = {{1, 1}, {1, 0}};    vector<vector<int>> p = power(v, n - 2);​    int ans = p[0][0] * 3 + p[0][1] * 2;    return ans;}​int main() {    int n = 3;    cout << countStrings(n);​    return 0;}

Java

// Java program to count number of binary
// strings without consecutive 1's

class GfG {

    // Function to multiply two matrices
    static int[][] multiply(int[][] v1, int[][] v2) {
        int[][] ans = new int[2][2];

        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 2; k++) {
                    ans[i][j] += v1[i][k] * v2[k][j];
                }
            }
        }

        return ans;
    }

    // Function to find matrix to the power n
    static int[][] power(int[][] v, int n) {
        if (n == 0) {
            return new int[][] { { 1, 0 }, { 0, 1 } };
        }

        int[][] res = power(v, n / 2);
        res = multiply(res, res);

        if (n % 2 == 1) {
            res = multiply(res, v);
        }

        return res;
    }

    static int countStrings(int n) {
        if (n == 2)
            return 3;
        if (n == 1)
            return 2;

        int[][] v = { { 1, 1 }, { 1, 0 } };
        int[][] p = power(v, n - 2);

        int ans = p[0][0] * 3 + p[0][1] * 2;
        return ans;
    }

    public static void main(String[] args) {
        int n = 3;
        System.out.println(countStrings(n));
    }
}

Python

# Python program to count number of binary
# strings without consecutive 1's

# Function to multiply two matrices
def multiply(v1, v2):
    ans = [[0, 0], [0, 0]]

    for i in range(2):
        for j in range(2):
            for k in range(2):
                ans[i][j] += v1[i][k] * v2[k][j]

    return ans

# Function to find matrix to the power n
def power(v, n):
    if n == 0:
        return [[1, 0], [0, 1]]

    res = power(v, n // 2)
    res = multiply(res, res)

    if n % 2 == 1:
        res = multiply(res, v)

    return res

def countStrings(n):
    if n == 2:
        return 3
    if n == 1:
        return 2

    v = [[1, 1], [1, 0]]
    p = power(v, n - 2)

    ans = p[0][0] * 3 + p[0][1] * 2
    return ans

if __name__ == "__main__":
    n = 3
    print(countStrings(n))

C#

// C# program to count number of binary
// strings without consecutive 1's

using System;

class GfG {

    // Function to multiply two matrices
    static int[, ] multiply(int[, ] v1, int[, ] v2) {
        int[, ] ans = new int[2, 2];

        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 2; k++) {
                    ans[i, j] += v1[i, k] * v2[k, j];
                }
            }
        }

        return ans;
    }

    // Function to find matrix to the power n
    static int[, ] power(int[, ] v, int n) {
        if (n == 0) {
            return new int[, ] { { 1, 0 }, { 0, 1 } };
        }

        int[, ] res = power(v, n / 2);
        res = multiply(res, res);

        if (n % 2 == 1) {
            res = multiply(res, v);
        }

        return res;
    }

    static int countStrings(int n) {
        if (n == 2)
            return 3;
        if (n == 1)
            return 2;

        int[, ] v = { { 1, 1 }, { 1, 0 } };
        int[, ] p = power(v, n - 2);

        int ans = p[0, 0] * 3 + p[0, 1] * 2;
        return ans;
    }

    static void Main(string[] args) {
        int n = 3;
        Console.WriteLine(countStrings(n));
    }
}

JavaScript

// JavaScript program to count number of binary
// strings without consecutive 1's

// Function to multiply two matrices
function multiply(v1, v2) {
    let ans = [ [ 0, 0 ], [ 0, 0 ] ];

    for (let i = 0; i < 2; i++) {
        for (let j = 0; j < 2; j++) {
            for (let k = 0; k < 2; k++) {
                ans[i][j] += v1[i][k] * v2[k][j];
            }
        }
    }

    return ans;
}

// Function to find matrix to the power n
function power(v, n) {
    if (n === 0) {
        return [ [ 1, 0 ], [ 0, 1 ] ];
    }

    let res = power(v, Math.floor(n / 2));
    res = multiply(res, res);

    if (n % 2 === 1) {
        res = multiply(res, v);
    }

    return res;
}

function countStrings(n) {
    if (n === 2)
        return 3;
    if (n === 1)
        return 2;

    let v = [ [ 1, 1 ], [ 1, 0 ] ];
    let p = power(v, n - 2);

    let ans = p[0][0] * 3 + p[0][1] * 2;
    return ans;
}

const n = 3;
console.log(countStrings(n));

Output

Related article:

1 to n bit numbers with no consecutive 1s in binary representation.

Lexicographically next string

kartik

Improve

Article Tags :

Practice Tags :

Similar Reads

String in Data Structure

A 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

Introduction to Strings - Data Structure and Algorithm Tutorials

Strings are sequences of characters. The differences between a character array and a string are, a string is terminated with a special character â€˜\0â€™ and strings are typically immutable in most of the programming languages like Java, Python and JavaScript. Below are some examples of strings:"geeks"

Applications, Advantages and Disadvantages of String

The String data structure is the backbone of programming languages and the building blocks of communication. String data structures are one of the most fundamental and widely used tools in computer science and programming. They allow for the representation and manipulation of text and character sequ

Subsequence and Substring

What is a Substring? A substring is a contiguous part of a string, i.e., a string inside another string. In general, for an string of size n, there are n*(n+1)/2 non-empty substrings. For example, Consider the string "geeks", There are 15 non-empty substrings. The subarrays are: g, ge, gee, geek, ge

Storage for Strings in C

In C, a string can be referred to either using a character pointer or as a character array. Strings as character arrays C char str[4] = "GfG"; /*One extra for string terminator*/ /* OR */ char str[4] = {â€˜Gâ€™, â€˜fâ€™, â€˜Gâ€™, '\0'}; /* '\0' is string terminator */ When strings are declared as character arra