N-th character in the string made by concatenating natural numbers
Last Updated :
20 Apr, 2023
Given an integer N, the task is to find the N-th character in the string made by concatenating natural numbers (Integers beginning from 1). The starting string will be “12345678910111213..”.
Examples:
Input: N = 3
Output: 3
3rd character in the string "12345678910111213.." is 3.
Input: N = 11
Output: 0
11th character in the string "12345678910111213..." is 0
The idea is to generate the required string until string length does exceed N.
- Initialize a Null string and c=1
- Add the c to the string by type-casting it to a character
- If c is a single-digit number, append it to the string
- if c is greater than 9, then store it in a temporary string and reverse it and append to the original string
- If at any moment the string length exceeds N, then return s[n-1].
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
char NthCharacter(int n)
{
string s = "";
int c = 1;
for (int i = 1;; i++) {
if (c < 10)
s += char(48 + c);
else
{
string s1 = "";
int dup = c;
while (dup) {
s1 += char((dup % 10) + 48);
dup /= 10;
}
reverse(s1.begin(), s1.end());
s += s1;
}
c++;
if (s.length() >= n) {
return s[n - 1];
}
}
}
int main()
{
int n = 11;
cout << NthCharacter(n);
return 0;
}
|
Java
class GFG
{
static char NthCharacter(int n)
{
String s = "";
int c = 1;
for (int i = 1;; i++) {
if (c < 10)
s += Integer.toString(c);
else
{
String s1 = "";
int dup = c;
while (dup >0) {
s1 += Integer.toString(dup % 10);
dup /= 10;
}
StringBuilder temp = new StringBuilder();
temp.append(s1);
temp = temp.reverse();
s += temp;
}
c++;
if (s.length() >= n) {
return s.charAt(n - 1);
}
}
}
public static void main(String []args)
{
int n = 11;
System.out.println( NthCharacter(n));
}
}
|
Python3
def NthCharacter(n):
s = ""
c = 1
while(True) :
if (c < 10):
s += chr(48 + c)
else:
s1 = ""
dup = c
while (dup > 0):
s1 += chr((dup % 10) + 48)
dup //= 10
s1 = "".join(reversed(s1))
s += s1
c += 1
if (len(s) >= n):
return s[n - 1]
if __name__ == "__main__":
n = 11
print(NthCharacter(n))
|
C#
using System;
class GFG
{
static char NthCharacter(int n)
{
String s = "";
int c = 1;
for (int i = 1;; i++)
{
if (c < 10)
s += c.ToString();
else
{
String s1 = "";
int dup = c;
while (dup > 0)
{
s1 += (dup % 10).ToString();
dup /= 10;
}
String temp = reverse(s1);
s += temp;
}
c++;
if (s.Length >= n)
{
return s[n - 1];
}
}
}
static String reverse(String input)
{
char[] a = input.ToCharArray();
int l, r = 0;
r = a.Length - 1;
for (l = 0; l < r; l++, r--)
{
char temp = a[l];
a[l] = a[r];
a[r] = temp;
}
return String.Join("", a);
}
public static void Main(String []args)
{
int n = 11;
Console.WriteLine( NthCharacter(n));
}
}
|
Javascript
<script>
function NthCharacter(n)
{
let s = "";
let c = 1;
for (let i = 1;; i++) {
if (c < 10)
s += c.toString();
else
{
let s1 = "";
let dup = c;
while (dup >0) {
s1 += (dup % 10).toString();
dup = Math.floor(dup/10);
}
s1=s1.split("").reverse().join("");
s += s1;
}
c++;
if (s.length >= n) {
return s[n-1];
}
}
}
let n = 11;
document.write( NthCharacter(n));
</script>
|
Complexity Analysis:
- Time Complexity: O(N2), as we are traversing N times using a loop and in each traversal we are using reverse function which will cost O (N), so in the worst case the program will effectively cost O (N*N).
- Auxiliary Space: O(N), as we are using extra space for the string.
New Approach:-
- Calculate the length of the number where the N-th character is present and store it in variable “length”.
- Find the actual number where the N-th character is present and store it in variable “number”.
- Calculate the position of the N-th character in the “number” and store it in variable “position”.
- Return the character at the “position” in the “number”.
Below is the implementation of the above approach :
C++
#include <bits/stdc++.h>
using namespace std;
char NthCharacter(int n) {
int length = 0;
int number = 1;
while (length < n) {
int currentLength = (int) log10(number) + 1;
if (length + currentLength >= n) {
break;
}
length += currentLength;
number++;
}
int position = n - length - 1;
string numStr = to_string(number);
return numStr[position];
}
int main() {
int n = 11;
cout << NthCharacter(n) << endl;
return 0;
}
|
Python3
import math
def NthCharacter(n):
length = 0
number = 1
while length < n:
currentLength = int(math.log10(number)) + 1
if length + currentLength >= n:
break
length += currentLength
number += 1
position = n - length - 1
numStr = str(number)
return numStr[position]
if __name__ == '__main__':
n = 11
print(NthCharacter(n))
|
Java
class GFG {
static char NthCharacter(int n) {
int length = 0;
int number = 1;
while (length < n) {
int currentLength = (int) Math.log10(number) + 1;
if (length + currentLength >= n) {
break;
}
length += currentLength;
number++;
}
int position = n - length - 1;
String numStr = Integer.toString(number);
return numStr.charAt(position);
}
public static void main(String []args) {
int n = 11;
System.out.println(NthCharacter(n));
}
}
|
C#
using System;
class Program {
static char NthCharacter(int n)
{
int length = 0;
int number = 1;
while (length < n) {
int currentLength = (int)Math.Log10(number) + 1;
if (length + currentLength >= n) {
break;
}
length += currentLength;
number++;
}
int position = n - length - 1;
string numStr = number.ToString();
return numStr[position];
}
static void Main(string[] args)
{
int n = 11;
Console.WriteLine(NthCharacter(n));
}
}
|
Javascript
function NthCharacter(n) {
let length = 0;
let number = 1;
while (length < n) {
let currentLength = Math.floor(Math.log10(number)) + 1;
if (length + currentLength >= n) {
break;
}
length += currentLength;
number++;
}
let position = n - length - 1;
let numStr = number.toString();
return numStr[position];
}
let n = 11;
console.log(NthCharacter(n));
|
Time Complexity:- The time complexity of the given code is O(log n) because the loop iterates until the length of the concatenated string is less than or equal to n. The number of iterations in the loop is proportional to the logarithm of n.
Auxiliary Space:- The auxiliary space complexity of the code is O(1) because it uses a constant amount of extra space regardless of the input size. The variables used in the code are of fixed size, and no extra space is allocated dynamically. Therefore, the space used by the code remains constant.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...