Problem:
Score : 300 points

Problem Statement

Takahashi loves the number 7 and multiples of K.

Where is the first occurrence of a multiple of K in the sequence 7,77,777,\ldots? (Also see Output and Sample Input/Output below.)

If the sequence contains no multiples of K, print -1 instead.

Constraints

1 \leq K \leq 10^6

K is an integer.

Input

Input is given from Standard Input in the following format:

K

Output

Print an integer representing the position of the first occurrence of a multiple of K. (For example, if the first occurrence is the fourth element of the sequence, print 4.)

Sample Input 1

101

Sample Output 1

4

None of 7, 77, and 777 is a multiple of 101, but 7777 is.

Sample Input 2

2

Sample Output 2

-1

All elements in the sequence are odd numbers; there are no multiples of 2.

Sample Input 3

999983

Sample Output 3

999982

Solution in Rust (1.42.0) (judge verdict: Wrong Answer)

#![allow(unused_imports, unused_macros)]

use kyoproio::*;
use std::{
    collections::*,
    io::{self, prelude::*},
    iter,
    mem::{replace, swap},
};

fn main() -> io::Result<()> {
    std::thread::Builder::new()
        .stack_size(64 * 1024 * 1024)
        .spawn(|| {
            let stdin = io::stdin();
            let stdout = io::stdout();
            run(KInput::new(stdin.lock()), io::BufWriter::new(stdout.lock()))
        })?
        .join()
        .unwrap()
}

fn run<I: Input, O: Write>(mut kin: I, mut out: O) -> io::Result<()> {
    macro_rules! output { ($($args:expr),+) => { write!(&mut out, $($args),+)?; }; }
    macro_rules! outputln {
        ($($args:expr),+) => { output!($($args),+); outputln!(); };
        () => { output!("\n"); if cfg!(debug_assertions) { out.flush()?; } }
    }

    let mut k: u64 = kin.input();
    if k % 2 == 0 || k % 5 == 0 {
        outputln!("-1");
        return Ok(());
    }
    if k % 7 == 0 {
        k /= 7;
    }
    let mut x = 1;
    let mut ans = 1;
    while x < 1 << 62 {
        if x % k == 0 {
            outputln!("{}", ans);
            return Ok(());
        }
        ans += 1;
        x = 10 * x + 1;
    }
    outputln!("{}", k - 1);

    Ok(())
}

fn factorize(n: u64, rand: &mut Pcg) -> Vec<u64> {
    let mut ds = vec![n];
    let mut fs = vec![];
    while let Some(d) = ds.pop() {
        if d == 1 {
            continue;
        }
        if d % 2 == 0 {
            fs.push(2);
            ds.push(d / 2);
            continue;
        }
        if miller_rabin(d, rand) {
            fs.push(d);
        } else {
            loop {
                let c = rand.next_u64() % d;
                let x = rho(d, rand.next_u64() % d, |x| {
                    ((x as u128 * x as u128 + c as u128) % d as u128) as u64
                });
                if x != d {
                    ds.push(x);
                    ds.push(d / x);
                    break;
                }
            }
        }
    }
    fs
}
fn rho<F: Fn(u64) -> u64>(n: u64, init: u64, f: F) -> u64 {
    let mut x = init;
    let mut y = init;
    loop {
        x = f(x);
        y = f(f(y));
        let d = gcd(x.max(y) - x.min(y), n);
        if d != 1 {
            return d;
        }
    }
}
fn miller_rabin(n: u64, rand: &mut Pcg) -> bool {
    if n % 2 == 0 {
        return n == 2;
    }
    let mut d = n - 1;
    let mut s = 0;
    while d % 2 == 0 {
        d /= 2;
        s += 1;
    }
    'test: for _ in 0..20 {
        let mut a = mod_pow(rand.next_u64() % (n - 2) + 1, d, n);
        if a == 1 {
            continue;
        }
        for _ in 0..s {
            if a == n - 1 {
                continue 'test;
            }
            a = (a as u128 * a as u128 % n as u128) as u64;
        }
        return false;
    }
    true
}

pub fn gcd(a: u64, b: u64) -> u64 {
    if b == 0 {
        a
    } else {
        gcd(b, a % b)
    }
}
pub fn mod_pow(mut a: u64, mut b: u64, m: u64) -> u64 {
    let mut y = 1;
    while b > 0 {
        if b & 1 == 1 {
            y = (y as u128 * a as u128 % m as u128) as u64;
        }
        a = (a as u128 * a as u128 % m as u128) as u64;
        b >>= 1;
    }
    y
}

pub struct Pcg(u64);
const MUL: u64 = 5129263795064623965;
const INC: u64 = 4280768313201238837;
impl Pcg {
    pub fn new(seed: u64) -> Self {
        Self(seed.wrapping_add(INC))
    }
    pub fn next_u32(&mut self) -> u32 {
        // PCG-XSH-RR
        let mut x = self.0;
        self.0 = x.wrapping_mul(MUL).wrapping_add(INC);
        x ^= x >> 18;
        ((x >> 27) as u32).rotate_right((x >> 59) as u32)
    }
    pub fn next_u64(&mut self) -> u64 {
        (self.next_u32() as u64) << 32 | self.next_u32() as u64
    }
    pub fn next_f32(&mut self) -> f32 {
        (self.next_u32() >> (32 - 23)) as f32 / (1 << 23) as f32
    }
    pub fn next_f64(&mut self) -> f64 {
        (self.next_u64() >> (64 - 52)) as f64 / (1u64 << 52) as f64
    }
}

// -----------------------------------------------------------------------------
pub mod kyoproio {
    use std::io::prelude::*;
    pub trait Input {
        fn str(&mut self) -> &str;
        fn input<T: InputParse>(&mut self) -> T {
            T::input(self)
        }
        fn iter<T: InputParse>(&mut self) -> Iter<T, Self> {
            Iter(self, std::marker::PhantomData)
        }
        fn seq<T: InputParse, B: std::iter::FromIterator<T>>(&mut self, n: usize) -> B {
            self.iter().take(n).collect()
        }
    }
    pub struct KInput<R> {
        src: R,
        buf: String,
        pos: usize,
    }
    impl<R: BufRead> KInput<R> {
        pub fn new(src: R) -> Self {
            Self {
                src,
                buf: String::with_capacity(1024),
                pos: 0,
            }
        }
    }
    impl<R: BufRead> Input for KInput<R> {
        fn str(&mut self) -> &str {
            loop {
                if self.pos >= self.buf.len() {
                    self.pos = 0;
                    self.buf.clear();
                    if self.src.read_line(&mut self.buf).expect("io error") == 0 {
                        return &self.buf;
                    }
                }
                let range = self.pos
                    ..self.buf[self.pos..]
                        .find(|c: char| c.is_ascii_whitespace())
                        .map(|i| i + self.pos)
                        .unwrap_or_else(|| self.buf.len());
                self.pos = range.end + 1;
                if range.end > range.start {
                    return &self.buf[range];
                }
            }
        }
    }
    pub struct Iter<'a, T, I: ?Sized>(&'a mut I, std::marker::PhantomData<*const T>);
    impl<'a, T: InputParse, I: Input + ?Sized> Iterator for Iter<'a, T, I> {
        type Item = T;
        fn next(&mut self) -> Option<T> {
            Some(self.0.input())
        }
    }
    pub trait InputParse: Sized {
        fn input<I: Input + ?Sized>(src: &mut I) -> Self;
    }
    impl InputParse for Vec<u8> {
        fn input<I: Input + ?Sized>(src: &mut I) -> Self {
            src.str().as_bytes().to_owned()
        }
    }
    macro_rules! from_str_impl {
        { $($T:ty)* } => {
            $(impl InputParse for $T {
                fn input<I: Input + ?Sized>(src: &mut I) -> Self {
                    src.str().parse::<$T>().expect("parse error")
                }
            })*
        }
    }
    from_str_impl! {
        String char bool f32 f64 isize i8 i16 i32 i64 i128 usize u8 u16 u32 u64 u128
    }
    macro_rules! tuple_impl {
        ($H:ident $($T:ident)*) => {
            impl<$H: InputParse, $($T: InputParse),*> InputParse for ($H, $($T),*) {
                fn input<I: Input + ?Sized>(src: &mut I) -> Self {
                    ($H::input(src), $($T::input(src)),*)
                }
            }
            tuple_impl!($($T)*);
        };
        () => {}
    }
    tuple_impl!(A B C D E F G);
    #[macro_export]
    macro_rules! kdbg {
        ($($v:expr),*) => {
            if cfg!(debug_assertions) { dbg!($($v),*) } else { ($($v),*) }
        }
    }
}