Champernowne's Constant

// Answer: 210

// Authored by: Tim Varley 💘
// Assisted-by: Grok Code Fast via Crush 💘 <crush@charm.land>

#include <iostream>
#include <vector>
#include <string>

long long champernowne() {
    std::string s = "";
    long long num = 1;
    while(s.size() < 1000001) {
        s += std::to_string(num++);
    }
    long long product = 1;
    std::vector<int> positions = {1,10,100,1000,10000,100000,1000000};
    for(int pos : positions) {
        product *= s[pos-1] - '0';
    }
    return product;
}

#if ! defined UNITTEST_MODE
int main(int argc, char const *argv[]) {
    std::cout << champernowne() << std::endl;
}
#endif // UNITTEST_MODE

package org.tvarley.euler.solutions;

import org.tvarley.euler.Solution;

public class Solution040 implements Solution {
  public String solve() {
    StringBuilder sb = new StringBuilder();
    for (int i = 1; ; i++) {
      sb.append(i);
      if (sb.length() >= 1000000) break;
    }
    String s = sb.toString();
    int prod = 1;
    prod *= s.charAt(0) - '0';
    prod *= s.charAt(9) - '0';
    prod *= s.charAt(99) - '0';
    prod *= s.charAt(999) - '0';
    prod *= s.charAt(9999) - '0';
    prod *= s.charAt(99999) - '0';
    prod *= s.charAt(999999) - '0';
    return Integer.toString(prod);
  }
}

module.exports = {
  answer: () => {
    let s = '';
    let i = 1;
    while (s.length < 1000000) {
      s += i.toString();
      i++;
    }
    return parseInt(s[0]) * parseInt(s[9]) * parseInt(s[99]) * parseInt(s[999]) * parseInt(s[9999]) * parseInt(s[99999]) * parseInt(s[999999]);
  }
};

def solve():
    """
    Champernowne's Constant
    An irrational decimal fraction is created by concatenating the positive integers:

    0.123456789101112131415161718192021…

    It can be seen that the 12th digit of the fractional part is 1.

    If dn represents the nth digit of the fractional part, find the value of the following expression.

    d1 × d10 × d100 × d1000 × d10000 × d100000 × d1000000
    https://projecteuler.net/problem=40
    """
    champernowne = ''
    n = 1
    while len(champernowne) < 1000000:
        champernowne += str(n)
        n += 1
    positions = [1, 10, 100, 1000, 10000, 100000, 1000000]
    product = 1
    for pos in positions:
        product *= int(champernowne[pos - 1])
    return product

package main

import "fmt"

import "strconv"

func main() {
  s := ""
  for i := 1; len(s) < 1000000; i++ {
    s += strconv.Itoa(i)
  }
  product := 1
  for _, exp := range []int{1, 10, 100, 1000, 10000, 100000, 1000000} {
    d := int(s[exp-1] - '0')
    product *= d
  }
  fmt.Println(product)
}

// Answer: 210

pub fn champernownes_constant() -> u64 {
    let mut s = String::new();
    let mut n = 1;
    while s.len() < 1_000_000 {
        s += &format!("{}", n);
        n += 1;
    }
    let d1 = s.chars().nth(0).unwrap().to_digit(10).unwrap() as u64;
    let d10 = s.chars().nth(9).unwrap().to_digit(10).unwrap() as u64;
    let d100 = s.chars().nth(99).unwrap().to_digit(10).unwrap() as u64;
    let d1000 = s.chars().nth(999).unwrap().to_digit(10).unwrap() as u64;
    let d10000 = s.chars().nth(9999).unwrap().to_digit(10).unwrap() as u64;
    let d100000 = s.chars().nth(99999).unwrap().to_digit(10).unwrap() as u64;
    let d1000000 = s.chars().nth(999999).unwrap().to_digit(10).unwrap() as u64;
    d1 * d10 * d100 * d1000 * d10000 * d100000 * d1000000
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn euler_040() {
        assert_eq!(champernownes_constant(), 210);
    }
}