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



Sample input:
101


Sample output:
4

Submission status: Wrong Answer

Solution code:
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
mod = 10 ** 9 + 7
mod1 = 998244353

# ------------------------------warmup----------------------------
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")


# -------------------game starts now----------------------------------------------------import math
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


# -----------------------------------------------binary seacrh tree---------------------------------------
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)


# -------------------game starts now----------------------------------------------------import math
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)


# -------------------------------iye ha chutiya zindegi-------------------------------------
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)  # To make sure already calculated n^-1
        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


# --------------------------------------iye ha combinations ka zindegi---------------------------------
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


# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
    zipped_pairs = zip(list2, list1)

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

    return z


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


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

    count = 0

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

        # Check if middle element is
        # less than or equal to key
        if (arr[mid] < key):
            count = mid + 1
            left = mid + 1

        # If key is smaller, ignore right half
        else:
            right = mid - 1

    return count


# --------------------------------------------------binary----------------------------------------
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

    # Stores the index of the left most element
    # from the array which is greater than k
    leftGreater = n

    # Finds number of elements greater than k
    while (l <= r):
        m = int(l + (r - l) / 2)
        if (arr[m] >= k):
            leftGreater = m
            r = m - 1

        # If mid element is less than
        # or equal to k update l
        else:
            l = m + 1

    # Return the count of elements
    # greater than k
    return (n - leftGreater)


# --------------------------------------------------binary------------------------------------
n=int(input())
e=len(str(n))
e1=int('1'*e)
if e1<n:
    e1=e1*10+1
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+1
    t=e1%n
    ans+=1
if tr==0:
    print(-1)
else:
    print(ans)

Submission status: Wrong Answer

Solution code:
import sys

K = int(input())

# branch = ['7']
# for i in range(10 ** 6):
#     branch.append(branch[-1] + '7')
#
# ans = -1
#
# for i, b in enumerate(branch):
#     if int(b) % K == 0:
#         ans = i + 1
#         break
#
# print(ans)

b = '7'
ans = -1

for i in range(10 ** 6):
    b += '7'
    if int(b) % K == 0:
        ans = i + 2
        break

print(ans)

Submission status: Wrong Answer

Solution code:
K = int(input())
count = 0
for sev in range(10**3):
  sev = sev *10 + 7
  count += 1
  if sev % K == 0:
    pass
  elif sev >10**6:
    count = -1
    pass
print(count)

Submission status: Wrong Answer

Solution code:
from collections import defaultdict
import sys
mod = int(input())
d = defaultdict(int)
s = 7
c = 1
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)

Submission status: Wrong Answer

Solution code:
K = int(input())

s = 0
if K%2 == 0:
    print(-1)
else:
    flag = 1
    for i in range(1, 20):
        s += 7*10**(i-1)
        if s%K == 0:
            print(i)
            flag = 0
            break
    if flag == 1:
        print(-1)

Submission status: Wrong Answer

Solution code:
k = int(input())

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

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

Submission status: Wrong Answer

Solution code:
# def div(n):
#     ans = []
#     for i in range(1,int(n**(1/2)+2)):
#         if n%i == 0:
#             ans.append(i)
#             ans.append(n//i)
#     ans = set(ans)
#     return ans

k = int(input())
# print(div(k))
a = 1
for i in range(1,10**7+2):
    if a%k == 0:
        print(i)
        exit()
    a=a*10+1
    a %= k
print(-1)
# print(div(k))

Submission status: Wrong Answer

Solution code:
k = int(input())
cnt = 0
tmp = 0
while cnt < k:
  tmp += 7 * pow(10, cnt, k)
  cnt += 1
  tmp %= k
  if tmp == 0:
    break
if cnt == k:
  print(-1)
else:
  print(cnt)

Submission status: Wrong Answer

Solution code:
import math
def is_prime(n):
    if n == 1: return False
    for k in range(2, int(math.sqrt(n)) + 1):
        if n % k == 0:
            return False
    return True

K = int(input())
if K==1:
    print(1)
if K==2:
    print(-1)
elif K==3:
    print(3)
elif K==5:
    print(-1)
elif K==7:
    print(1)
elif K==11:
    print(2)
elif K==77:
    print(2)
elif K==111:
    print(3)
elif K==777:
    print(3)
elif K==1111:
    print(4)
elif K==7777:
    print(4)
elif K==11111:
    print(5)
elif K==77777:
    print(5)
elif K==111111:
    print(6)
elif K==777777:
    print(6)
elif K==1111111:
    print(7)
elif K==7777777:
    print(7)
elif is_prime(K):
    print(K-1)
else:
    print(-1)

Submission status: Wrong Answer

Solution code:
K = int(input())

cnt = 1
num = 7 % K

flag = False

remainderList = {num}

while True:
    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")

Submission status: Wrong Answer

Solution code:
K = int(input())

cnt = 0
n = 7
while cnt < K:
    cnt += 1
    if n % K == 0:
        break
    n = (10 * n + 7) % K

if cnt == K:
    print(-1)
else:
    print(cnt)

Submission status: Wrong Answer

Solution code:
import sys
K=int(input())
rest = 7 % K
if rest == 0:
  print(1)
  sys.exit()
for i in range(2,K): 
  rest = (rest*10+7) % K
  if rest == 0:
    print(i)
    sys.exit()
else:
  print(-1)

Submission status: Wrong Answer

Solution code:
k = int(input())
if k % 2 == 0:
    print(-1)
if k % 7 == 0:
    k //= 7
x = 1
s = 0
for i in range(1, 1000005):
    s += x
    s %= k
    if s == 0:
        print(i)
        exit()
    x *= 10
    x %= k

Submission status: Wrong Answer

Solution code:
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()
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)

Submission status: Wrong Answer

Solution code:
K = int(input())

maxLoop = 1000000
cnt = 1
num = 7 % K

flag = False

remainderList = {num}

while cnt < maxLoop:
    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")

Submission status: Wrong Answer

Solution code:
import sys
k=int(input())
n=7
if k%2==0:
    print(-1)
for i in range(1,k+1):
    if n%k==0:
        print(i)
        sys.exit()
    else:
        n=(10*(n%k)+7)%k
print(-1)

Submission status: Wrong Answer

Solution code:
K = int(input())

v = 0
for i in range(1, K):
    v = (v * 10 + 7) % K
    if v == 0:
        print(i)
        exit(0)
print(-1)

Submission status: Wrong Answer

Solution code:
k=int(input())
mod=0
ans=0
for i in range(1000000):
    ans+=1
    mod=(mod*10+7)%k

    if mod==0:
        break
print(ans if ans!=1000001 else -1)

Submission status: Wrong Answer

Solution code:
from itertools import count

K = int(input())
f = lambda x: (x*10+7)%K

a = 7%K
b = 7%K


for t in count(1):
    if a == 0:
        print(t)
        break
    if t > 1 and a == b:
        print(t,a,b)
        print(-1)
        break
    a = f(a)
    b = f(f(b))

Submission status: Wrong Answer

Solution code:
K = int(input())
count = 0
for sev in range(10**3):
  sev = sev *10 + 7
  count += 1
  if sev % K == 0:
    pass
  elif sev >10**6:
    count = -1
    pass
print(-1)

Submission status: Wrong Answer

Solution code:
import sys
k = int(input())
if k % 7 == 0:
    k = k // 7
tmp = 1
for i in range(k+2):
    if tmp == 0:
        print(i+1)
        sys.exit()
    tmp = (tmp * 10 + 1) % k
print(-1)

Submission status: Wrong Answer

Solution code:
import time

k = int(input())

tick = time.time()
idx = 0
while True:
    if time.time() - tick > 1.80:
        ans = -1
        break
    idx += 1
    tgt = int("7" * idx)
    if tgt % k == 0:
        ans = idx
        break

print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys

R=list()
N=int(input())
if N%7==0:
  N=N//7
if N==1:
  print(1)
  sys.exit()
if N%2==0 or N%5==0:
  print(-1)
else:
  r=1
  for i in range(1, N):
    R.append(r)
    r=(r*10)%N
  print(len(set(R)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# Problem Code: abc174_c

def C(K):
	cnt = 1
	num = 7
	while num % K != 0:
		cnt += 1
		num = 10 * num + 7
		if cnt >= 10 ** 4:
			return -1
	return cnt

if __name__ == '__main__':
	K = int(input())
	print(C(K))

Submission status: Wrong Answer

Solution code:
k = int(input())
if k%2==0:
    print(-1)
elif k==1:
    print(1)
else:
    x = 7
    c=1
    while True:
        x = 10*x+7
        x%=k
        if x==0:
            print(c+1)
            break
        c+=1

Submission status: Wrong Answer

Solution code:
k=int(input())
if k%2<1:
  print(-1)
  exit()
a=1
t=7
m=0
while 1:
  t=t*10%k
  m+=t
  if m%k: a+=1
  else: break
print(a)

Submission status: Wrong Answer

Solution code:
k = int(input())
if k % 2 == 0 or k % 5 == 0:
    print(-1)
    exit()
    
while k % 7 == 0:
    k //= 7

num = 1
plus = 10
for i in range(1, k):
    if int(num) % k == 0:
        print(i)
        exit()
    num += plus
    num %= k
    plus *= 10
    plus %= k

print(-1)

Submission status: Wrong Answer

Solution code:
k=int(input())

a = 0
flag = False
for i in range(10000):
    a = 10 * a + 7
    if a % k == 0:
        flag = True
        break
if flag:
    print(i+1)
else:
    print(-1)

Submission status: Wrong Answer

Solution code:
K=int(input())
nana=7
count=1
if K==7:
  print(1)
for i in range(5*10**6):
  count+=1
  nana=(nana*10+7)%K
  if nana==0:
    print(count)
    exit()

print(-1)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
k = int(input())
if(k&2==0):
  print(-1)
else:
  i = 1
  while True:
    m = 7
    if(m%k==0):
      ans = i
      print(ans)
      break
    m = m*10 + 7
    i += 1

Submission status: Wrong Answer

Solution code:
K = int(input())
X = 1
temp = 7
ans = 1

if K == 7:
  print(ans)
  exit()

for i in range(10**6+1):
  X = X * 10 % K
  temp += X * 7
  temp %= K
  ans += 1
  if temp == 0:
    print(ans)
    break
  if i == 10**6:
    print(-1)

Submission status: Wrong Answer

Solution code:
#from math import *
from collections import *
from random import *
from bisect import *
import sys
input=sys.stdin.readline
def lis():
    return list(map(int,input().split()))
def ma():
    return map(int,input().split())
def inp():
    return int(input())
n=inp()
if(n%2==0):
    print(-1)
co=1
while(1):
    r=int('7'*co)
    if(co>n):
        co=-1
        break
    if(r%n==0):
        break
    co+=1
print(co)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
def main():
    K = int(input())

    if K % 2 == 0:
        v = 7
        for i in range(1, 1000000):
            if v % K == 0:
                print(i)
                return

            v = (v * 10 + 7) % K
        
    print(-1)

main()

Submission status: Wrong Answer

Solution code:
k = int(input())
#a,b = map(int,input().split())
#a_L = list(map(int,input().split()))

sevn = "7"
i = 1
for i in range(1,10**4+1):
    tmp = int(sevn)
    if tmp%k==0:
        print(i)
        exit()
    sevn += "7"
    #i += 1

print(-1)

Submission status: Wrong Answer

Solution code:
K = int(input())

n = 7
ans = 0
i = 1
if K%2==0:
    ans = -1
else:
    for i in range(K*2+10):
        if n%K==0:
            ans = i+1
            break
        n *= 10
        n += 7
        n %= K
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
K = int(input())
count = 0
for sev in range(10**3):
  sev = sev *10 + 7
  count += 1
  if K % sev == 0:
    pass
  elif sev >10**6:
    count = -1
    pass
print(-1)

Submission status: Wrong Answer

Solution code:
K=int(input())

D=7
for i in range(10000000):
    if D%K==0:
        print(i)
        break
#    print(D)
    D=D*10+7
    D%=K
else:
    print(-1)

Submission status: Wrong Answer

Solution code:
n = int(input())

if( n%2 == 0 ):
	print("-1")
else :
  k = 7
  t=0
  while(n%k != 0):
    t+=1;
    k += pow(10,t)*(7)
  print(t)

Submission status: Wrong Answer

Solution code:
k=int(input())
mod=7
ans=1
for i in range(1000000):
    ans+=1
    mod=(mod*10+7)%k

    if mod==0:
        break
print(ans if ans!=1000001 else -1)

Submission status: Wrong Answer

Solution code:
K = int(input())
a = 0
num=[7,77,777,7777,77777,777777]
for i in num:
  if i%K==0:
    print(i)
    a = 1
    break

if a==0:
  print(-1)

Submission status: Wrong Answer

Solution code:
# coding: utf-8
import numpy as np

k = int(input())

s = 0
cnt = 0
flg = False
# while (s < 1e10):
while (True):
    cnt += 1
    s = s * 10 + 7 
    # print(s)

    if s % k == 0:
        flg = True
        break

    if k < 7:
        flg = False
        break

    if k % 2 == 0:
        flg = False
        break


if flg == True:
    print(cnt)
else:
    print(-1)

Submission status: Wrong Answer

Solution code:
import sys
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr
R=list()
N=int(input())
if N==1:
  print(1)
  sys.exit()
L=factorization(N)
if len(L)==2 and  L[0][0]==2 and L[1][0]==5:
  print(-1)
elif len(L)==1 and (L[0][0]==2 or L[0][0]==5):
  print(-1)
else:
  r=1
  for i in range(1, N):
    R.append(r)
    r=(r*10)%N
  print(len(set(R)))

Submission status: Wrong Answer

Solution code:
def resolve():
    N = int(input())
    count = 7
    if N%2 == 0:
        print("-1")
    else:
        for i in range(10**6):
            count += 10**i
            if count % N == 0:
                print(i+1)
                exit()
resolve()

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
#%% for atcoder uniittest use
import sys
input= lambda: sys.stdin.readline().rstrip()
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))
#%%code
def resolve():
    N,=pin()
    if N%2==0: print(-1) #10の倍数も含まれる
    cnt=7%N
    if cnt==0:
        print(1)
        return
    for i in range(2,10**7):
        cnt=cnt*10+7
        cnt%=N
        if cnt==0:
            print(i)
            return
#%%submit!
resolve()

Submission status: Wrong Answer

Solution code:
k = int(input())
if 7 % k == 0:
  print(1)
elif 77 % k == 0:
  print(2)
elif 777 % k == 0:
  print(3)
elif 7777 % k == 0:
  print(4)
elif 77777 % k == 0:
  print(5)
elif 777777 % k == 0:
  print(6)
elif 7777777 % k == 0:
  print(7)
else:
  print(-1)