Nth Digit

                                            
class Solution {
public:
    int findNthDigit(int n) {
        long len = 1, count = 9, start = 1;
        while (n > len * count) {
            n -= len * count;
            len++;
            count *= 10;
            start *= 10;
        }
        start += (n - 1) / len;
        string s = to_string(start);
        return s[(n - 1) % len] - '0';
    }
};

                                            
class Solution {
    public int findNthDigit(int n) {
        int len = 1;
        long count = 9;
        int start = 1;
        
        while (n > len * count) {
            n -= len * count;
            len++;
            count *= 10;
            start *= 10;
        }
        
        start += (n - 1) / len;
        String s = Integer.toString(start);
        return Character.getNumericValue(s.charAt((n - 1) % len));
    }
}

                                            
class Solution(object):
    def findNthDigit(self, n):
        if n < 10:
            return n
        n -= 1
        length = 1
        count = 9
        while n > length * count:
            n -= length * count
            length += 1
            count *= 10
        
        num = 10 ** (length - 1) + n // length
        return int(str(num)[n % length])

                                            
int findNthDigit(int n) {
    long len = 1, count = 9, start = 1;

    while (n > len * count) {
        n -= len * count;
        len += 1;
        count *= 10;
        start *= 10;
    }

    start += (n - 1) / len;
    int digit = (start / (int)pow(10, (len - 1 - (n - 1) % len))) % 10;
    
    return digit;
}

                                            
public class Solution {
    public int FindNthDigit(int n) {
        int length = 1;
        long count = 9;
        int start = 1;

        while (n > length * count) {
            n -= length * (int)count;
            length++;
            count *= 10;
            start *= 10;
        }

        start += (n - 1) / length;
        string s = start.ToString();
        return s[(n - 1) % length] - '0';
    }
}

                                            
/**
 * @param {number} n
 * @return {number}
 */
var findNthDigit = function(n) {
    let len = 1;
    let start = 1;
    let count = 9;
    
    while (n > len * count) {
        n -= len * count;
        len++;
        start *= 10;
        count *= 10;
    }
    
    start += Math.floor((n - 1) / len);
    const str = start.toString();
    return +str[(n - 1) % len];
};

                                            
function findNthDigit(n: number): number {
    let len = 1;
    let count = 9;
    let start = 1;

    while (n > len * count) {
        n -= len * count;
        len++;
        count *= 10;
        start *= 10;
    }

    start += Math.ceil(n / len) - 1;
    const s = start.toString();
    return parseInt(s.charAt((n - 1) % len));
};

                                            
class Solution {
    /**
     * @param Integer $n
     * @return Integer
     */
    function findNthDigit($n) {
        $len = 1;
        $count = 9;
        $start = 1;
        
        while ($n > $len * $count) {
            $n -= $len * $count;
            $len++;
            $count *= 10;
            $start *= 10;
        }
        
        $num = $start + intval(($n - 1) / $len);
        $pos = ($n - 1) % $len;
        
        return intval(strval($num)[$pos]);
    }
}

                                            
class Solution {
    func findNthDigit(_ n: Int) -> Int {
        var n = n
        var len = 1
        var count = 9
        var start = 1

        while n > len * count {
            n -= len * count
            len += 1
            count *= 10
            start *= 10
        }

        start += (n - 1) / len
        let s = String(start)
        let index = (n - 1) % len
        return Int(String(s[s.index(s.startIndex, offsetBy: Int(index))]))!
    }
}

                                            
class Solution {
  int findNthDigit(int n) {
    int len = 1;
    int start = 1;
    int count = 9;

    while (n > len * count) {
      n -= len * count;
      len++;
      start *= 10;
      count *= 10;
    }

    start += (n - 1) ~/ len;
    return int.parse(start.toString().substring((n - 1) % len, (n - 1) % len + 1));
  }
}

                                            
func findNthDigit(n int) int {
    if n < 10 {
        return n
    }
    
    base := 1
    digits := 1
    for n > 9*base*digits {
        n -= 9 * base * digits
        base *= 10
        digits++
    }
    
    num := base + (n-1)/digits
    index := (n - 1) % digits
    return int(strconv.Itoa(num)[index] - '0')
}

                                            
# @param {Integer} n
# @return {Integer}
def find_nth_digit(n)
    n -= 1
    digits = 1
    while n > 9 * 10 ** (digits - 1) * digits
        n -= 9 * 10 ** (digits - 1) * digits
        digits += 1
    end
    num = 10 ** (digits - 1) + n / digits
    return num.to_s[n % digits].to_i
end

To solve this coding challenge, we need to take the

n

th digit of the concatenated sequence of positive integers [1, 2, 3, ..., 10, 11, ...] and return that specific digit. The challenge requires an understanding of how numbers grow in size as they are concatenated and how to locate the

n

th digit in this continually growing series.

Explanation

Problem Breakdown

Initial Cases: For small values of
n

directly less than 10, the result is simply
n

itself.
Dissect Number Lengths:

Single-digit numbers contribute directly to the sequence.
Starting from two-digit numbers, entries significantly grow. For example, once we pass 9, we get "10," "11," "12," and so on.

Increment Through Lengths:

Determine how many digits are covered by numbers with a varying number of digits (e.g., 1-9, 10-99, 100-999).

Steps to Solve

Adjust
n

To A Base : Subtract 1 from
n

to convert it into a zero-indexed position for easier calculations.
Identify Number Length :

Identify the range by increasing the length of numbers and keep decrementing
n

by the product of the current length and the count of such length numbers till
n

remains within a valid range.

Determine Exact Number :

Determine the exact number that contains the
n

th digit.
Find the exact index of the
n

th digit in that number.

Detailed Steps in Pseudocode

                                            
# Step-by-step Explanation

function findNthDigit(n):
# If n is less than 10, it is a single-digit number
if n < 10:
return n

# Convert n to zero-based to facilitate easier calculation
n = n - 1

# Initialize lengths and counts
length = 1  # Represents the current length of numbers we are checking
count = 9  # Numbers 1-9 have 9 digits total

# Loop to determine the length range of the digit's position
while n > length * count:
n = n - (length * count)  # Decrease n by the total digit count in this length range
length = length + 1  # Increase the length (1 digit numbers to 2 digit, etc)
count = count * 10  # 9, 90, 900... (numbers in current length range)

# Determine the actual number containing the nth digit
# The initial number of length 'length' in current range
start_number = 10 ** (length - 1)

# Locate the exact number containing the n-th digit
# '/' gives the number's relative position
number_containing_nth_digit = start_number + (n // length)

# Determine the exact digit within number_containing_nth_digit
# '%' gives the digit's index
digit_index_in_number = n % length

# Convert number_containing_nth_digit to string to access the specific digit and convert back to integer
result_digit = int(str(number_containing_nth_digit)[digit_index_in_number])

return result_digit

Explanation Based on Provided Example

Example 1:

Input:
n = 3
Output:
3

Explanation:

The sequence is
1, 2, 3, ...

; third digit is obviously
3

.

Example 2:

Input:
n = 11
Output:
0

Explanation:

The sequence is
1, 2, ..., 9, 10, 11, ...

. The 11th digit is
0

from
10

.

Detailed Breakdown

Small
n

Case : Direct return.
While Loop : Decreases
n

until it fits within the digit count of a specific length.
Calculate Exact Number : Using zero-based index and division, then using modulus to locate digit within this number.

This explanation and pseudocode should provide a clear step-by-step method for identifying the nth digit in the infinite concatenated sequence of integers.