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 (Python):
K = int(input())

ans = 0
num = 0

for _ in range(2*K):
    num = 10*num+7
    num %= K
    ans += 1
    if num == 0:
        break

if ans == 2*K:
    ans = -1
print(ans)

Solution (Python):
import sys
input = sys.stdin.readline
from math import gcd


def read():
    K = int(input().strip())
    return K,


def solve(K):
    seven = 0
    for i in range(1, K+1):
        seven = seven * 10 + 7
        seven %= K
        if seven == 0:
            return i
    return -1


if __name__ == '__main__':
    inputs = read()
    outputs = solve(*inputs)
    if outputs is not None:
        print("%s" % str(outputs))

Solution (Python):
K = int(input())
A = list()
i = 1
mod = 7%K
while i <= 10**6+5:
    if mod ==0:
        break
    else:
        mod = ((mod*10) + 7)%K
        i += 1
if i >= 10**6+1:
    i = -1
print(i)

Solution (Python):
K=int(input())
t=7
for i in range(10**6):
    if t%K==0:
        print(i+1)
        exit()
    t*=10
    t+=7
    t%=K
print(-1)

Solution (Python):
import time

start = time.time()
K = int(input())

n = 7
cnt = 1

n %= K

while n:
    n *= 10
    n += 7
    cnt += 1
    n %= K
    if time.time() - start > 1.95:
        print(-1)
        break

else:
    print(cnt)

Solution (Python):
MOD = int(input())

if MOD%2 == 0:
  print(-1)
  exit()
if MOD == 7 or MOD == 1:
  print(1)
  exit()
  
def mod(n):         
  return n % MOD

def modpow(a, n):   
    res = 1  
    digit = len(str(bin(n))) - 2
    for i in range(digit):
      if (n >> i) & 1:
        res *= mod(a)
        res = mod(res)
      a = mod(a**2)
    return mod(res)
  
res = mod(7)
count = 1

while count <= 10**6:
  res += mod(modpow(10, count)*7)
  res = mod(res)
  count += 1
  if res == 0:
    print(count)
    exit()
    
print(-1)

Solution (Python):
k=int(input())
k9=k*9
l=10
for n in range(1,k+5):
    if l*7%k9==7%k9:
        print(n)
        break
    l=l*10%k9
else:
    print(-1)

Solution (Python):
def main():
  k = int(input())
  num = 7 % k
  first = num
  ans = 1
  while num != 0:
    ans += 1
    num = (num*10 + 7)%k
    if num == first or ans > 2000000:
      ans = -1
      break
  print(ans)
    
    
if __name__ == "__main__":
  main()

Solution (Python):
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: map(int, read().split())


def main():

    K = in_n()

    t = 7 % K
    x = 7 % K
    for i in range(10000000):
        if t == 0:
            print(i + 1)
            exit()
        x = (x * 10) % K
        t += x
        t = t % K

    print(-1)


if __name__ == '__main__':
    main()

Solution (Python):
K = int(input())
cur = 7
count = 1
digit = 10
X = K
if X % 2 == 0 or X % 5 == 0 :
    print(-1)
else:
    while cur % K != 0:
        count += 1
        cur += 7*digit
        digit = (digit*10)%K
    print(count)

Solution (Python):
import sys
input=sys.stdin.readline

k=int(input())
if k%7==0:
    k=k//7
if k==1:
    now=0
else:
    now=1
s=now
for i in range(k+100):
    if s==0:
        print(i+1)
        sys.exit()
    now=(now*10)%k
    s+=now
    s=s%k
print(-1)

Solution (Python):
def main():
    k = int(input())

    a = 0
    for i in range(1, 10 ** 6):
        a = (a * 10 + 7) % k
        if a == 0:
            print(i)
            exit()

    print(-1)


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    K = int(input())
    cnt = 1
    now_mod10 = 1
    mod10 = 1
    while cnt <= K:
        md = 7 * now_mod10
        if md % K == 0:
            return cnt
        mod10 = (mod10 * 10) % K
        now_mod10 = (now_mod10 + mod10) % K
        cnt += 1
    return -1

if __name__ == '__main__':
    print(main())

Solution (Python):
k = int(input())

ans = 1
used = [False]*k
now = 7%k
pow7 = 7
while not used[now]:
    if now == 0:
        print(ans)
        exit()
    used[now]=True
    pow7 = (pow7*10)%k
    now = (now+pow7)%k
    ans+=1
print(-1)

Solution (Python):
from collections import defaultdict

def main():
    k = int(input())
    dic = defaultdict(bool)
    sev = 7
    i = 1
    while(True):
        sev = sev%k
        if sev == 0:
            print(i)
            return
        if(dic[sev]):
            print(-1)
            return
        dic[sev] = True
        sev = (sev + 7*pow(10,i,k))%k
        i += 1

if __name__ == "__main__":
    main()

Solution (Python):
k = int(input())

if k % 2 == 0:
    print('-1')
elif k % 5 == 0:
    print('-1')
else:
    n = 7
    ans = 1
    while n % k != 0:
        n = n * 10 + 7
        n %= k
        ans += 1
    
    print(ans)

Solution (Python):
k=int(input())
sev=0
for i in range(k):
    sev=(sev+(7*pow(10,i,k)))%k
    if sev==0:
        print(i+1)
        exit()
print(-1)

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce


sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().rstrip().split()
def S(): return sys.stdin.readline().rstrip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 998244353


k = I()
now = 0
for i in range(k):
    now = (now * 10 + 7) % k
    if now == 0:
        print(i + 1)
        exit()
print(-1)

Solution (Python):

import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
mod = 10 ** 9 + 7
mod1 = 998244353


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")



class TreeNode:
    def __init__(self, k, v):
        self.key = k
        self.value = v
        self.left = None
        self.right = None
        self.parent = None
        self.height = 1
        self.num_left = 1
        self.num_total = 1


class AvlTree:

    def __init__(self):
        self._tree = None

    def add(self, k, v):
        if not self._tree:
            self._tree = TreeNode(k, v)
            return
        node = self._add(k, v)
        if node:
            self._rebalance(node)

    def _add(self, k, v):
        node = self._tree
        while node:
            if k < node.key:
                if node.left:
                    node = node.left
                else:
                    node.left = TreeNode(k, v)
                    node.left.parent = node
                    return node.left
            elif node.key < k:
                if node.right:
                    node = node.right
                else:
                    node.right = TreeNode(k, v)
                    node.right.parent = node
                    return node.right
            else:
                node.value = v
                return

    @staticmethod
    def get_height(x):
        return x.height if x else 0

    @staticmethod
    def get_num_total(x):
        return x.num_total if x else 0

    def _rebalance(self, node):

        n = node
        while n:
            lh = self.get_height(n.left)
            rh = self.get_height(n.right)
            n.height = max(lh, rh) + 1
            balance_factor = lh - rh
            n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
            n.num_left = 1 + self.get_num_total(n.left)

            if balance_factor > 1:
                if self.get_height(n.left.left) < self.get_height(n.left.right):
                    self._rotate_left(n.left)
                self._rotate_right(n)
            elif balance_factor < -1:
                if self.get_height(n.right.right) < self.get_height(n.right.left):
                    self._rotate_right(n.right)
                self._rotate_left(n)
            else:
                n = n.parent

    def _remove_one(self, node):
        """
        Side effect!!! Changes node. Node should have exactly one child
        """
        replacement = node.left or node.right
        if node.parent:
            if AvlTree._is_left(node):
                node.parent.left = replacement
            else:
                node.parent.right = replacement
            replacement.parent = node.parent
            node.parent = None
        else:
            self._tree = replacement
            replacement.parent = None
        node.left = None
        node.right = None
        node.parent = None
        self._rebalance(replacement)

    def _remove_leaf(self, node):
        if node.parent:
            if AvlTree._is_left(node):
                node.parent.left = None
            else:
                node.parent.right = None
            self._rebalance(node.parent)
        else:
            self._tree = None
        node.parent = None
        node.left = None
        node.right = None

    def remove(self, k):
        node = self._get_node(k)
        if not node:
            return
        if AvlTree._is_leaf(node):
            self._remove_leaf(node)
            return
        if node.left and node.right:
            nxt = AvlTree._get_next(node)
            node.key = nxt.key
            node.value = nxt.value
            if self._is_leaf(nxt):
                self._remove_leaf(nxt)
            else:
                self._remove_one(nxt)
            self._rebalance(node)
        else:
            self._remove_one(node)

    def get(self, k):
        node = self._get_node(k)
        return node.value if node else -1

    def _get_node(self, k):
        if not self._tree:
            return None
        node = self._tree
        while node:
            if k < node.key:
                node = node.left
            elif node.key < k:
                node = node.right
            else:
                return node
        return None

    def get_at(self, pos):
        x = pos + 1
        node = self._tree
        while node:
            if x < node.num_left:
                node = node.left
            elif node.num_left < x:
                x -= node.num_left
                node = node.right
            else:
                return (node.key, node.value)
        raise IndexError("Out of ranges")

    @staticmethod
    def _is_left(node):
        return node.parent.left and node.parent.left == node

    @staticmethod
    def _is_leaf(node):
        return node.left is None and node.right is None

    def _rotate_right(self, node):
        if not node.parent:
            self._tree = node.left
            node.left.parent = None
        elif AvlTree._is_left(node):
            node.parent.left = node.left
            node.left.parent = node.parent
        else:
            node.parent.right = node.left
            node.left.parent = node.parent
        bk = node.left.right
        node.left.right = node
        node.parent = node.left
        node.left = bk
        if bk:
            bk.parent = node
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
        node.num_left = 1 + self.get_num_total(node.left)

    def _rotate_left(self, node):
        if not node.parent:
            self._tree = node.right
            node.right.parent = None
        elif AvlTree._is_left(node):
            node.parent.left = node.right
            node.right.parent = node.parent
        else:
            node.parent.right = node.right
            node.right.parent = node.parent
        bk = node.right.left
        node.right.left = node
        node.parent = node.right
        node.right = bk
        if bk:
            bk.parent = node
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
        node.num_left = 1 + self.get_num_total(node.left)

    @staticmethod
    def _get_next(node):
        if not node.right:
            return node.parent
        n = node.right
        while n.left:
            n = n.left
        return n



class SegmentTree1:
    def __init__(self, data, default='z', func=lambda a, b: min(a, b)):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)



class SegmentTree:
    def __init__(self, data, default=0, func=lambda a, b: a + b):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)



class Factorial:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorials = [1, 1]
        self.invModulos = [0, 1]
        self.invFactorial_ = [1, 1]

    def calc(self, n):
        if n <= -1:
            print("Invalid argument to calculate n!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.factorials):
            return self.factorials[n]
        nextArr = [0] * (n + 1 - len(self.factorials))
        initialI = len(self.factorials)
        prev = self.factorials[-1]
        m = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = prev * i % m
        self.factorials += nextArr
        return self.factorials[n]

    def inv(self, n):
        if n <= -1:
            print("Invalid argument to calculate n^(-1)")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        p = self.MOD
        pi = n % p
        if pi < len(self.invModulos):
            return self.invModulos[pi]
        nextArr = [0] * (n + 1 - len(self.invModulos))
        initialI = len(self.invModulos)
        for i in range(initialI, min(p, n + 1)):
            next = -self.invModulos[p % i] * (p // i) % p
            self.invModulos.append(next)
        return self.invModulos[pi]

    def invFactorial(self, n):
        if n <= -1:
            print("Invalid argument to calculate (n^(-1))!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.invFactorial_):
            return self.invFactorial_[n]
        self.inv(n)  
        nextArr = [0] * (n + 1 - len(self.invFactorial_))
        initialI = len(self.invFactorial_)
        prev = self.invFactorial_[-1]
        p = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
        self.invFactorial_ += nextArr
        return self.invFactorial_[n]


class Combination:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorial = Factorial(MOD)

    def ncr(self, n, k):
        if k < 0 or n < k:
            return 0
        k = min(k, n - k)
        f = self.factorial
        return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD



def powm(a, n, m):
    if a == 1 or n == 0:
        return 1
    if n % 2 == 0:
        s = powm(a, n // 2, m)
        return s * s % m
    else:
        return a * powm(a, n - 1, m) % m



def sort_list(list1, list2):
    zipped_pairs = zip(list2, list1)

    z = [x for _, x in sorted(zipped_pairs)]

    return z



def product(l):
    por = 1
    for i in range(len(l)):
        por *= l[i]
    return por



def binarySearchCount(arr, n, key):
    left = 0
    right = n - 1

    count = 0

    while (left <= right):
        mid = int((right + left) / 2)

        
        
        if (arr[mid] < key):
            count = mid + 1
            left = mid + 1

        
        else:
            right = mid - 1

    return count



def countdig(n):
    c = 0
    while (n > 0):
        n //= 10
        c += 1
    return c
def binary(x, length):
    y = bin(x)[2:]
    return y if len(y) >= length else "0" * (length - len(y)) + y

def countGreater(arr, n, k):
    l = 0
    r = n - 1

    
    
    leftGreater = n

    
    while (l <= r):
        m = int(l + (r - l) / 2)
        if (arr[m] >= k):
            leftGreater = m
            r = m - 1

        
        
        else:
            l = m + 1

    
    
    return (n - leftGreater)



n=int(input())
e=len(str(n))
e1=int('7'*e)
if e1<n:
    e1=e1*10+7
tr=1
s=set()
t=e1%n
ans=len(str(e1))
while(t!=0):
    if t in s:
        tr=0
        break
    s.add(t)
    e1=t*10+7
    t=e1%n
    ans+=1
if tr==0:
    print(-1)
else:
    print(ans)

Solution (Python):
K = int(input())

if K % 2 == 0 or K % 5 == 0:
    print(-1)
    exit()
rest = 7 % K
x = rest
ans = 1
while rest:
    ans += 1
    x = x*10 % K
    rest = (rest + x) % K
print(ans)

Solution (Python):
k = int(input())
x = 7 % k
for i in range(10**6+10):
    if x == 0:
        print(i+1)
        break
    x = (10*x+7) % k
else:
    print(-1)

Solution (Python):
k = int(input())
if k%2==0 or k%5==0:
    print(-1)
    exit()
s=7
cnt=1
while s%k!=0:
    s=s%k*10+7
    cnt+=1
    
print(cnt)

Solution (Python):
k=int(input())
if k==1:
  print(1)
  exit()
if k%2==0:
  print(-1)
  exit()
if k%5==0:
  print(-1)
  exit()
if k==7:
  print(1)
  exit()
a=7%k
for i in range(10**6+50):
  a=(a*10+7)%k
  if a==0:
    break
print(i+2)

Solution (Python):
from collections import defaultdict
import sys
mod = int(input())
d = defaultdict(int)
s = 7
c = 1
s %= mod
while(True):
    if s == 0:
        break
    if s in d:
        print(-1)
        sys.exit()
    d[s] = 1
    s = (s*10 + 7) % mod
    c += 1

print(c)

Solution (Python):
import os
import heapq
import sys
import math
import operator
from collections import defaultdict
from io import BytesIO, IOBase


"""def gcd(a,b):
    if b==0:
        return a
    else:
        return gcd(b,a%b)"""

"""def pw(a,b):
    result=1
    while(b>0):
        if(b%2==1): result*=a
        a*=a
        b//=2
    return result"""



def inpt():
    return [int(k) for k in input().split()]


def main():
    n=int(input())
    d={}
    seven=7
    q=0
    ok=True
    while(True):
        r=seven%n
        q+=1
        if(r==0):
            break
        if(r in d):
            ok=False
            break
        d[r]=True
        seven=r*10+7
    if(not ok):
        print(-1)
    else:
        print(q)

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

if __name__ == "__main__":
    main()

Solution (Python):
K = int(input())

if K % 2 == 0 or K % 5 == 0:
    print(-1)
    exit()

i = 0
A = 0
B = 7
while True:
    A += B
    A %= K
    
    B *= 10
    B %= K
    i += 1
    if A == 0:
        break
print(i)

Solution (Python):
import sys
K=int(input())
A=[0 for i in range(K)]
a=7
for i in range(K+5):
    if a%K==0:
        print(i+1)
        sys.exit()
    else:
        if A[a%K]>0:
            print(-1)
            sys.exit()
        A[a%K]+=1
        a=(a%K)*10+7

Solution (Python):
def readinput():
    k=int(input())
    return k

def main(k):
    amari=[0]*k
    r=0
    count=0
    for i in range(1,k+1):
        count+=1
        r=(10*r+7)%k
        if r==0:
            return count
        if amari[r]>0:
            return -1
        amari[r]+=1
    return -1

if __name__=='__main__':
    k=readinput()
    ans=main(k)
    print(ans)

Solution (Python):
if __name__ == '__main__':
	K = int(input())
	dls = [0] * (K+1)
	d = 7 % K
	dls[d] = 1
	c = 1
	if K % 2 == 0:
		c = -1
		d = 0
	while(d != 0):
		d = (d*10 + 7)%K
		if dls[d] == 1:
			c = -1
			break
		else:
			dls[d] = 1
			c += 1
	print(c)

Solution (Python):
def solve():
    k = int(input())
    curr_num = 7
    for count in range(1, 10 ** 6 + 100):
        if curr_num % k == 0:
            print(count)
            return
        curr_num *= 10
        curr_num += 7
        curr_num %= k
    print(-1)


if __name__ == '__main__':
    solve()

Solution (Python):

k = int(input())
count = 1
cur_remainder = 7%k
if cur_remainder==0:
    print(count)
    exit()
remainder_set=set([cur_remainder])
while True:
    cur_remainder = (cur_remainder*10+7)%k
    count += 1
    if cur_remainder==0:
        print(count)
        exit()
    if cur_remainder in remainder_set:
        print(-1)
        exit()
    remainder_set.add(cur_remainder)

Solution (Python):
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0

n = int(readline())
if even(n):
    print(-1)
    exit()
elif n%5==0:
    print(-1)
    exit()
s = "7"
count = 1
while True:
    if int(s) < n:
        s = s+"7"
        count += 1
        continue
    else:
        res = int(s)%n
        if res == 0:
            print(count)
            exit()
        s = str(int(s)%n)

Solution (Python):
I=lambda:list(map(int,input().split()))
k,=I()
ans=-1
s=7%k
c=0
while c<=10**6:
	c+=1
	if s==0:
		ans=c
		break
	s=(s*10+7)%k
print(ans)

Solution (Python):
K = int(input())

def solve():
    if 7 % K == 0:
        return 1

    val = 7
    for i in range(2, K + 1):
        val = val * 10 + 7
        val = val % K
        if val == 0:
            return i
    
    return -1

print(solve())

Solution (Python):
k=int(input())
if k%7==0:
    k//=7
tmp=0
for i in range(10**6+1):
    tmp=(tmp+pow(10,i,k))%k
    if tmp==0:
        print(i+1)
        exit()

print(-1)

Solution (Python):
k = int(input())
now = 7
for i in range(1, k+1):
    if int(now) % k == 0:
        print(i)
        break
    now = 10 * now + 7
    now %= k
else:
    print(-1)

Solution (Python):
k = int(input())

rem = 0
for i in range(k*10+1):
    rem = rem*10 + 7
    rem %= k
    if rem==0:
        break

if i==(k*10):
    print(-1)
else:
    print(i+1)

Solution (Python):
k = int(input())

r = 7
count = 1
found = 0
for i in range(k):
    if r % k == 0:
        print(count)
        found = 1
        break
    r = (10 * r + 7) % k
    count += 1
if found == 0:
    print(-1)

Solution (Python):
n=int(input())*9


vis={}
flag=1
a=1
t=10
while((7*(t))%n not in vis):
	k=(7*(t))%n
	vis[k]=1
	if(k==7):
		flag=0
		print(a)
		break
	a+=1
	t=(t*10)%n
	
if(flag):
	print(-1)

Solution (Python):
def main():
    k = int(input())
    a = 7
    c = 1
    b = 7
    if k == 2 or k == 5:
        print(-1)
        exit()
    while True:
        if a%k== 0:
            print(c)
            break
        else:
            b = (b*10)%k
            a = b+a
            a = a %k
            c += 1
            if c > k:
                print(-1)
                exit()

main()

Solution (Python):
k = int(input())

num = 0
res = 0
cnt = [0] * k
while True:
    num = (num * 10 % k + 7) % k
    res += 1

    if num == 0:
        print(res)
        break

    if cnt[num] == 1:
        print(-1)
        break

    cnt[num] += 1

Solution (Python):
import sys


def main():
    input = sys.stdin.buffer.readline
    k = int(input())
    s = set()
    i = 1
    a = 7
    while True:
        a %= k
        if a in s:
            print(-1)
            break
        if a == 0:
            print(i)
            break
        s.add(a)
        i += 1
        a = 10 * a + 7


if __name__ == "__main__":
    main()

Solution (Python):
K = int(input())


def check(k):
    if k & 1 == 0:
        return -1
    if k % 7 == 0:
        k //= 7

    a = 1

    for i in range(k + 1):
        if a % k == 0:
            return i + 1
        else:
            a = (10 * a + 1) % k

    return -1


print(check(K))

Solution (Python):
K = int(input())
L = [False]*K
X = 7
ans = 0
R = 0
while not L[0]:
    ans += 1
    X %= K
    R = (R+X)%K
    X *= 10
    if L[R]:
        ans = -1
        break
    L[R] = True
    

print(ans)

Solution (Python):
k = int(input())

if k % 5 == 0 or k % 2 == 0:
  print(-1)
  exit()

n = 7 % k
m = 70 % k
ans = 1
while True:
  if n == 0:
    print(ans)
    break
  
  n += m
  n %= k
  m *= 10
  m %= k
  ans += 1

Solution (Python):

def inputlist(): return [int(j) for j in input().split()]

K = int(input())
if K % 2 == 0:
    print(-1)
    exit()
s = 7
for i in range(K):
    if s % K == 0:
        print(i+1)
        exit()
    if s % K != s:
        s = 10*(s%K) + 7
        continue
    s = 10*s + 7
print(-1)

Solution (Python):
K = int(input())

cnt = 1
num = 7 % K

flag = False

if num == 0:
    flag = True

remainderList = {num}

while not flag:
    cnt += 1
    
    num = ((num * 10) % K + 7) % K
    if num == 0:
        flag = True
        break
    if num in remainderList:
        break
    remainderList.add(num)

if flag:
    print(cnt)
else:
    print("-1")