Problem:
 Score: 200 points    Problem Statement  The number 105 is quite special - it is odd but still it has eight divisors.
Now, your task is this: how many odd numbers with exactly eight positive divisors are there between 1 and N (inclusive)?      Constraints   N is an integer between 1 and 200 (inclusive).         Input  Input is given from Standard Input in the following format:  N       Output  Print the count.        Sample Input 1 105      Sample Output 1 1  Among the numbers between 1 and 105 , the only number that is odd and has exactly eight divisors is 105 .       Sample Input 2 7      Sample Output 2 0  1 has one divisor. 3 , 5 and 7 are all prime and have two divisors. Thus, there is no number that satisfies the condition.

Solution (Python):
def make_divisors(n):
    lower_divisors, upper_divisors = [], []
    i = 1
    while i*i <= n:
        if n % i == 0:
            lower_divisors.append(i)
            if i != n // i:
                upper_divisors.append(n//i)
        i += 1
    return lower_divisors + upper_divisors[::-1]


n = int(input())

ans = 0
for i in [2 * x + 1 for x in range((n + 1) // 2)]:
    if len(make_divisors(i)) == 8:
        ans += 1

print(ans)

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

c = 0
for i in range(1,n+1):
    cc = 0
    if i % 2 == 1:
        for j in range(1,i+1):
            if i % j == 0:
                cc += 1
        if cc == 8:
            c += 1

print(c)

Solution (Python):
n = int(input())
count = 0

for i in filter(lambda x : x % 2 == 1,range(1, n+1)):
    yakusu = 0
    for j in range(1,i+1):
        if i % j == 0:
            yakusu += 1
    if yakusu == 8:
        count += 1

print(count)

Solution (Python):
N = int(input())
def yakusuu(n):
    i = 1
    count = 0
    while i != n:
        if n % i == 0:
            count+=1
        i+=1
    return count+1

j = 0
n = 1
counter =0
while (n-1) != N:
    if n%2==1:
        if yakusuu(n)==8:
            counter +=1
    n+=1

print(counter)

Solution (Python):
N = int(input())
count = 0
flag = 0
for i in range(1, N+1):
    if i % 2 == 0:
        continue
    for j in range(1, i+1):
        if i % j == 0:
            count += 1
    if count == 8:
        flag += 1
    count = 0
print(flag)

Solution (Python):
n = int(input())
ans = 0
for i in range(1, n+1, 2):
    cnt = 0
    for j in range(1, n+1):
        if i % j == 0:
            cnt += 1
    if cnt == 8:
        ans += 1
print(ans)

Solution (Python):
n=int(input())
count=0
for i in range(n):
    yakusu=0
    if((i+1)%2==0):
        continue
    for j in range(i+1):
        if((i+1)%(j+1)==0):
            yakusu+=1
    if(yakusu==8):
        count+=1

print(count)

Solution (Python):
x = int(input())
line = []
for i in range(1, x+1):
    count = 0
    if i%2 == 0:
        continue
    for j in range(1, i+1):
        if i%j == 0:
            count += 1
    if count == 8:
        line.append(i)
print(len(line))

Solution (Python):
n = int(input())
ans = 0
for i in range(1, n + 1, 2):
    j = 1
    cnt = 0
    while j * j <= i:
        if i % j == 0:
            cnt += 1
            if j != i // j:
                cnt += 1
        j += 1
    if cnt == 8:
        ans += 1
print(ans)

Solution (Python):
N=int(input())
S=0
for i in range(1,N+1,2):
    count=0
    for j in range(1,i+1):
        if i%j==0:
            count+=1
    if count==8:
        S+=1
print(S)

Solution (Python):
import sys
sys.setrecursionlimit(10000000)
import numpy as np
from heapq import heapify, heappop, heappush
import copy
from math import ceil
from collections import deque

from bisect import bisect_left, bisect_right









def main():
    N = int(input())
    num = 0
    for i in range(9, N + 1):
        if i % 2 == 0:
            continue
        d = 0
        for j in range(1, N + 1):
            if i % j == 0:
                d += 1 
        if d == 8:
            num += 1
    print(num)

if __name__ == '__main__':
    main()

Solution (Python):
def divisor(m):
    cnt = 2
    for i in range(3, m, 2):
        if m % i == 0:
            cnt += 1
    return cnt

n = int(input())
if n < 105:
    print(0)
elif n == 105:
    print(1)
else:
    res = 1
    for i in range(107, n+1, 2):
        if divisor(i) == 8:
            res += 1
    print(res)

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

ans =0

for i in range(1,n+1,2):
  count =0
  for j in range(1,i+1):
    if i % j ==0:
      count +=1
  if count ==8:
    ans +=1
print(ans)

Solution (Python):
n=int(input())
ans=0
for i in range(1,n+1,2):
  count=0
  for j in range(1,i+1):
    if i%j==0:
      count=count+1
  if count==8:
    ans=ans+1
else:
  print(ans)

Solution (Python):
n = int(input()) 
def yakusu(num):
    list_a = []
    for i in range(1, num//2 + 1):
        if num % i == 0:
            list_a.append(i)
    list_a.append(num)
    return list_a
  
ans = 0
for i in range(1, n + 1):
    if len(yakusu(i)) == 8 and i % 2 ==1:
        ans += 1
        
print(ans)

Solution (Python):
n=int(input())
count=0
for i in range(1,n+1):
    if i%2==1:
        yakusuu=0
        for j in range(1,int((i**0.5)//1)+1):
            if i%j==0:
                if j**2==i:
                    yakusuu+=1
                else:
                    yakusuu+=2
        if yakusuu==8:
            count+=1
print(count)

Solution (Python):
N = int(input())
ans = 0

for x in range(1, N + 1, 2):
    cnt = 0
    for y in range(1, x + 1):
        if x % y == 0:
            cnt += 1
    if cnt == 8:
        ans += 1

print(ans)

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

out=0
for i in range(1,N+1):
    cnt = 0
    for j in range(1,i+1):
        if i%j==0:
            cnt+=1
    if cnt==8 and i%2==1:
        out+=1
print(out)

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

ans = 0
for i in range(1, n+1, 2):
    c = 0
    for k in range(1, i+1):
        if i % k == 0:
            c += 1
    if c == 8:
        ans += 1
print(ans)

Solution (Python):
import sys
import math
import collections
from collections import deque
from functools import reduce
import heapq
n = int(input())




ans = 0
for i in range(1, n+1):
    if i % 2 == 0:
        continue

    an = 0
    for j in range(1, i+1):
        if i % j == 0:
            an += 1

    if an == 8:
        ans += 1

print(ans)

Solution (Python):
N=int(input())
ans=0
for n in range(1,N+1,2):
  _ans=0
  for x in range(1,n+1):
    if n%x==0:
      _ans+=1
  if _ans==8:
    ans+=1
print(ans)

Solution (Python):
def get_divisors(n):
    div = []
    append = div.append
    for i in range(1, int(n ** 0.5) + 1):
        if n % i == 0:
            append(i)
            if i != n // i:
                append(n // i)
    div.sort()
    return div



N = int(input())


cnt = 0
for n in range(1, N + 1, 2):
    div = get_divisors(n)
    if len(div) == 8:
        cnt += 1

print(cnt)

Solution (Python):
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    
    return divisors

N = int(input())
ans = 0
for i in range(1, N+1, 2):
    if len(make_divisors(i)) == 8:
        ans += 1
print(ans)

Solution (Python):
n=int(input())
ans=0
for i in range(1,n+1,2):
    yaku=0
    for j in range(1,i+1):
        if i%j==0:
            yaku+=1
    if yaku==8:
        ans+=1
print(ans)

Solution (Python):
import math
N = int(input())

def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    return divisors

ans=0
for j in range(1,N+1,2):
    count = make_divisors(j)
    if len(count)==8:
        ans +=1

print(ans)

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

result = 0
for i in range(9, n + 1, 2):
    yakusu = 0
    for j in range(1, i + 1):
        if i % j == 0:
            yakusu += 1
    if yakusu == 8:
        result += 1
print(result)

Solution (Python):
N = int(input())
num = 0

def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    
    return divisors
  
for i in range(1, N+1):
  if len(make_divisors(i)) == 8 and i%2 == 1:
    num += 1
    
print(num)

Solution (Python):
n = int(input())
ans = 0

def get_yakusu_num(n):
    m = int(n ** (1/2))
    rep_list = []
    for i in range(1, m + 2):
        if n % i == 0:
            p = n // i
            rep_list.append(i)
            rep_list.append(p)
    return len(set(rep_list))

for i in range(1, n + 1):
    if get_yakusu_num(i) == 8 and i % 2 == 1:
        ans += 1
print(ans)

Solution (Python):
import math
n = int(input())

ans = 0

for i in range(1, n+1):
    if i % 2 == 0:
        continue
    num = 0
    for j in range(1, math.floor(i / 3) + 1):
        if i % j == 0:
            num += 1
    else:
        if num == 7:
            ans += 1

print(ans)

Solution (Python):
from sys import stdin
def main():
    
    readline=stdin.readline
    n=int(readline())

    cnt=0
    for i in range(1,n+1,2):
        if len(make_divisors(i))==8:
            cnt+=1

    print(cnt)

def make_divisors(n):
    if n==1:
        divisors=[1]
        return divisors
    else:
        divisors=[]
        for i in range(1,n):
            if i*i>n:
                break
            if n%i==0:
                divisors.append(i)
                if i!=n//i:
                    divisors.append(n//i)

        
        return divisors

if __name__=="__main__":
    main()

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

def div_count(i):
    count = 0
    for div in range(1, i+1):
        if i % div == 0:
            count += 1

    return count

ans = 0
for i in range(1, N+1, 2):
    if div_count(i) == 8:
        ans += 1

print(ans)

Solution (Python):
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy

def make_divisors(n):
    divisors = []
    for i in range(1,int(n**0.5)+1):
        if n%i == 0:
            divisors.append(i)
            if i != n//i:
                divisors.append(n//i)
    divisors.sort()
    return divisors
n = int(input())
cnt = 0
for i in range(1,n+1):
    if i%2 == 0:
        continue
    a = make_divisors(i)
    if len(a) == 8:
        cnt+=1
print(cnt)

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60


def divisors(n):
    lower = []
    upper = []
    for i in range(1, int(n ** 0.5) + 1):
        if n % i == 0:
            lower.append(i)
            if i != n // i:
                upper.append(n // i)

    lower.extend(reversed(upper))
    return lower


def main():
    N = int(readline())

    ans = 0
    for n in range(1, N + 1, 2):
        d = divisors(n)
        if len(d) == 8:
            ans += 1

    print(ans)

    return


if __name__ == '__main__':
    main()

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60


def divisors(n):
    lower = []
    upper = []
    for i in range(1, int(n ** 0.5) + 1):
        if n % i == 0:
            lower.append(i)
            if i != n // i:
                upper.append(n // i)

    lower.extend(reversed(upper))
    return lower


def main():
    N = int(readline())

    ans = 0
    for n in range(1, N + 1, 2):
        d = divisors(n)
        if len(d) == 8:
            ans += 1

    print(ans)

    return


if __name__ == '__main__':
    main()

Solution (Python):

N = int(input())


def make_divisor_list(num):
    divisor_list = []
    divisor_list.append(1)
    for i in range(2, num//2+1):
        if num % i == 0:
            divisor_list.append(i)
    divisor_list.append(num)
    return divisor_list


l = 0
for i in range(1, N+1):
    divisor_list = make_divisor_list(i)
    if len(divisor_list) == 8 and i % 2 != 0:
        l += 1

print(l)

Solution (Python):
n = int(input())
ans = 0
for j in range(1, n+1, 2):
    cnt = 0
    for i in range(1, j+1):
        if j % i == 0:
            cnt += 1
    if cnt == 8:
        ans += 1
print(ans)

Solution (Python):
n = int(input())
count = 0
def divisors(n):
    d=[]
    for i in range(1,int(n**0.5)+1):
        if n%i==0:
            d.append(i)
            if i!=n//i:
                d.append(n//i)
    d.sort()
    return d
for i in range(n+1):
    if i % 2 == 1:
        if len(divisors(i)) == 8:
            count += 1
    else:
        continue
print(count)

Solution (Python):
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy

def make_divisors(n):
    divisors = []
    for i in range(1,int(n**0.5)+1):
        if n%i == 0:
            divisors.append(i)
            if i != n//i:
                divisors.append(n//i)
    divisors.sort()
    return divisors

cnt = 0
n = int(input())
for i in range(1,n+1):
    if i%2 == 0:
        continue
    a = make_divisors(i)
    if len(a) == 8:
        cnt+=1
print(cnt)

Solution (Python):
n = int(input())
ans = 0
c = 0
for i in range(9, n+1, 2):
    for j in range(1, i+1):
        if i%j == 0:
            c += 1
    if c == 8:
        ans += 1
    c = 0

print(ans)

Solution (Python):
N = int(input())
sum_cnt = 0
for n in range(1, N+1):
  cnt = 0
  for i in range(1, n+1):
    if n % i == 0:
      cnt += 1
  if cnt == 8 and n % 2 == 1:
    sum_cnt += 1
print(sum_cnt)

Solution (Python):
def yakusuu(n):
    kosuu = 0
    for i in range(1, n+1 , 2):
        cnt = 0
        for j in range(1, n+1):
            if i % j == 0:
                cnt = cnt + 1
        if cnt == 8:
            kosuu = kosuu + 1
    return kosuu
    

def main():
    n = int(input())
    print(yakusuu(n))
    
if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
res = 0
for i in range(1,n+1,2):
  counts=0
  for j in range(1,i+1):
    if i%j == 0:
      counts+=1
    if counts==8:
      res+=1
print(res)

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]




def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors

N = ii()

cnt = 0
for i in range(1, N+1, 2):
    if len(make_divisors(i)) == 8:
        cnt += 1
print(cnt)

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

ans = 0

for i in range(1 , n+1 , 2):
    tmp = 0
    for j in range(1 , i+1):
        if i%j == 0:
            tmp += 1
    if tmp == 8:
        ans += 1

print(ans)

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 6)

int1 = lambda x: int(x) - 1
def II(): return int(input())

def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())

def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

def printlist(lst, k='\n'): print(k.join(list(map(str, lst))))
INF = float('inf')

def solve():
    n = II()

    ans = 0
    for i in range(n+1):
        if i % 2 == 0: continue
        cnt = 1
        for j in range(2, i+1):
            if i % j: continue
            cnt += 1
        if cnt == 8:
            ans += 1
        
    print(ans)



if __name__ == '__main__':
    solve()

Solution (Python):
n = int(input())
cnt = 0
for i in range(1, n + 1,2):
    temp = 0
    j = 1
    while j * j <= i:
        if i % j == 0:
            temp += 1
            if j != i // j:
                temp += 1
        j += 1
    if temp == 8:
        cnt += 1
print(cnt)

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

ans = 0
for i in range(1, N+1, 2):
    divisor = []
    for j in range(1, N+1):
        if i % j == 0:
            divisor.append(j)
    
    if len(divisor) == 8:
        ans += 1

print(ans)

Solution (Python):
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    return divisors


n = int(input())
count = 0

for i in range(1, n + 1):
    if i % 2 == 1 and len(make_divisors(i)) == 8:
        count += 1

print(count)

Solution (Python):
def resolve():
	n = int(input())
	cnt = 0
	for i in range(1, n+1):
		div_cnt = 0
		for j in range(1, i+1):
			if i % 2 == 0:
				continue
			if i % j == 0:
				div_cnt += 1
		if div_cnt >= 8:
			cnt += 1
	print(cnt)
resolve()

Solution (Python):
def divisor_counter(n):
    cnt = 0
    if n % 2 == 0:
        return 0
    for i in range(1,n+1):
        if n % i == 0:
            cnt += 1
    if cnt == 8:
        return 1
    else:
        return 0
    

n = int(input())
cnt = 0
for i in range(1,n+1):
    cnt += divisor_counter(i)
print(cnt)

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


def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5) + 1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n // i)

    
    return divisors


count = 0

for x in range(N + 1):
    num_len = len(make_divisors(x))
    if x % 2 == 1 and num_len == 8:
        count += 1
print(count)

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

nums = range(1, N+1, 2)

res = 0
for n in nums:
    i = 1
    for x in range(1,n):
        if (n // (x)) * (x) == n:
            i = i + 1
    if i == 8:
        res += 1

print(res)

Solution (Python):
N = int(input())
result = 0
for i in range(1, N + 1, 2):
    counter = 0
    for j in range(1, int(i ** 0.5) + 1):
        if i % j == 0:
            counter += 1
            if j != i // j:
                counter += 1
    if counter == 8:
        result += 1
print(result)

Solution (Python):
n = int(input())
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    divisors.sort()
    return(divisors)
ans = 0
for i in range(1,n+1,2):
  if len(make_divisors(i)) == 8:
    ans += 1
print(ans)

Solution (Python):
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    return divisors

n = int(input())
ans = 0
for i in range(1,n+1):
  if i % 2 == 1 and len(make_divisors(i)) == 8:
    ans += 1
print(ans)

Solution (Python):
N = int(input())
ans = []
cnt = 0

for i1 in range(1,N+1,2):
  for i2 in range(1,i1+1):
    if (i1/i2)-(i1//i2) == 0:
      cnt=cnt+1
  ans.append(cnt)
  cnt = 0
print(ans.count(8))

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



def VI(N, init=0):
  return [init for _ in range(N)]
def VVI(N, M, init=0):
  return [[init for _ in range(M)] for _ in range(N)]

def VD(N, init=0.0):
  return [init for _ in range(N)]
def VVD(N, M, init=0.0):
  return [[init for _ in range(M)] for _ in range(N)]

def Divisor(n):
  ret = []
  for i in range(1, n+1):
    if i*i > n:
      break
    else:
      if n % i == 0:
        ret.append(i)
        if i*i != n:
          ret.append(n//i)
  ret.sort()
  return ret

N = int(input().rstrip())
ans = 0
for i in range(1, N+1):
  divs = Divisor(i)
  if (len(divs) == 8) and (i&1) :
    ans += 1

print(ans)

Solution (Python):
N = int(input())
ans = 0
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    return len(divisors)

for i in range(1, N+1, 2):
    if make_divisors(i) == 8:
        ans += 1
print(ans)

Solution (Python):
n=int(input())
l=[]
b=0
for j in range(1,200):
    for i in range(1,j+1):
        if j%i==0:
            b+=1
    if b==8:
        l.append(j)
    b=0
L=[]
for k in range(len(l)):
    if l[k]%2==1 and l[k]<=n:
        L.append(l[k])
print(len(L))

Solution (Python):
n=int(input())
ans=0
def make_divisors(n):
      divisors=[]
      for i in range(1,int(n**0.5)+1):
          if n%i == 0:
              divisors.append(i)
              if i != n//i:
                  divisors.append(n//i)
      return len(divisors)
for i in range(1,n+1,2):
    if make_divisors(i)== 8:
        ans+=1
print(ans)

Solution (Python):
def check(k):
    cnt = 0
    for i in range(1, k + 1):
        if k % i == 0:
            cnt += 1
    if cnt == 8:return 1
    else:return 0

n = int(input())
pre = [0] * n

for i in range(n):
    if i % 2 == 1:
        pre[i] = pre[i - 1]
    else:
        temp = check(i + 1)
        pre[i] = pre[i - 1] + temp
print(pre[n - 1])

Solution (Python):
def divisor(x):
  ret=[]
  for i in range(1,x+1):
    if x%i==0:
      ret.append(i)
  return len(ret)

ans=0
n=int(input())
for i in range(1,n+1):
  if divisor(i)==8 and i%2==1:
    ans+=1
print(ans)

Solution (Python):
n = int(input())
ans = 0
i = 1
for i in range(1,n+1):
    eight = 0 
    if i % 2 == 1:
        for j in range(1,i+1):
            if i % j == 0:
                eight += 1

    if eight == 8:
        ans += 1

print(ans)

Solution (Python):

n = int(input())
ans = 0
for i in range(1,n+1):
    if i % 2 == 1:
        count = 0
        for j in range(1,i+1):
            if i % j == 0:
                count += 1
        if count == 8: 
            ans += 1 
print(ans)

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

res = 0
for i in range(9, n+1, 2):
    yakusu = 0
    for j in range(1, i+1):
        if i % j == 0:
            yakusu += 1
    if yakusu == 8:
        res += 1

print(res)

Solution (Python):
import itertools
sosuu = [3,5,7,11,13]
n=(int)(input())
count = 0
for i in itertools.combinations(sosuu, 3):
  if i[0] * i[1] * i[2] <= n:
    
    count += 1
add = 2 if n >= 189 else (1 if n >= 135 else 0)
print(count + add)

Solution (Python):
def yakusu(num):
  ret =0 
  for i in range(1,num+1):
    if(num%i==0): ret+=1
      
  return ret
N = int(input())
if(N<105):
  print(0)
  exit()
elif(N==105):
  print(1)
  exit()
else:
  ans=1
  for i in range(106,N+1):
    if(yakusu(i)==8 and i%2==1):
      ans +=1
print(ans)

Solution (Python):
N=int(input())
ans=0
for i in range(1,N+1,2):
  y=0
  for j in range(1,i+1):
    if i%j == 0:
      y+=1
  if y==8:
    ans+=1
print(ans)

Solution (Python):
n = int(input())
ans = 0

for i in range(1,n+1,2):
    c = 0
    for j in range(1,i+1):
        if i%j == 0:
            c+=1
    if c == 8:
        ans += 1
print(ans)

Solution (Python):
n = int(input())
ans=0
for i in range(1,n+1,2):
    cnt = 0
    for j in range(1,n+1,2):
        if j>i:
            break
        if i%j==0:
            cnt+=1
    if cnt==8:
        ans+=1
print(ans)

Solution (Python):
N=int(input())
if N<105:print(0)
else:
    ans=0
    for i in range(105,N+1,2):
        count=0
        for j in range(1,N+1):
            if i%j==0:count+=1
        if count==8:
            ans+=1
    print(ans)

Solution (Python):
n=int(input())
ans=0

for i in range(1,n+1):
    if i%2==0:
        continue
    else:
        cnt=0
        for j in range(1,n+1):
            if i%j==0:
                cnt+=1
        if cnt==8:
            ans+=1
print(ans)

Solution (Python):
import math
import itertools









def count(n):

    if n % 2 == 0 or n < 3:
        return False

    count = 2
    for i in range(2, n):
        if n % i == 0:
            count += 1

    if count == 8:
        return True
    else:
        return False


def main():
    N = int(input())

    ans = 0
    for i in range(1, N + 1):
        if count(i):
            ans += 1

    print(ans)


list(itertools.combinations([1, 2, 3, 4], 2))

if __name__ == '__main__':
    main()

Solution (Python):
N=int(input())
ans=0

for i in range(1,N+1,2):
  count=0
  for j in range(1,i+1):
    if i%j == 0:
      count += 1
  if count == 8:
    ans += 1
print(ans)

Solution (Python):
N=int(input())
ans=0
for i in range(1,N+1,2):
    a=0
    for j in range(1,i+1):
        if i%j==0:
            a+=1
            if a==8:
                ans+=1

print(ans)

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

if N < 105:
    print(0)
else:
    c = 0
    for n in range(105, N+1, 2):
        nf = 0
        for i in range(1, n+1):
            if n%i == 0:
                nf += 1
        if nf == 8:
            c += 1
    print(c)

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

s=0
for i in range(1,N+1,2):
  count=0
  for j in range(1,i+1):
    if i % j == 0:
      count+=1
  if count==8:
    s+=1

print(s)

Solution (Python):
n=int(input())
ans=0
for i in range(1,n+1):
  cnt=0
  for j in range(1,i+1):
    if i%j==0:
      cnt+=1
  if i%2==1 and cnt==8:
    ans+=1
print(ans)

Solution (Python):
n = int(input())
if(n < 105):
    print(0)
elif(105 <= n < 135):
    print(1)
elif(135 <= n < 165):
    print(2)
elif(165 <= n < 189):
    print(3)
elif(189 <= n < 195):
    print(4)
else:
    print(5)

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

def yaku(n):
  ans = []
  x = int(N ** (1/2))
  for i in range(1, x + 1):
    if n % i == 0:
      if i != n // i:
        if i not in ans:
          ans.append(i)
        if n // i not in ans:  
          ans.append(n // i)
  return len(ans)

ans = 0
for i in range(1, N + 1, 2):
  if yaku(i) == 8:
    ans += 1
    
    
print(ans)

Solution (Python):
N = int(input())
ans = 0
for i in range(1,N+1,2):
    cnt = 0
    for j in range(1,i):
        if i%j==0:
            cnt+=1
    if cnt==7:
        ans+=1
print(ans)

Solution (Python):
import math
n = int(input())
def divisor(x):
    div_list = []
    for div in range(1, int(math.sqrt(x)) + 1):
        if x % div == 0:
            if  x // div != div:
                div_list.append(div)
                div_list.append(int(x // div))
            else:
                div_list.append(div)
    return sorted(div_list)

ans = 0
for i in range(1, n + 1):
    if i % 2 == 0:
        continue
    if len(divisor(i))  == 8:
        ans += 1

print(ans)

Solution (Python):
N = int(input())
cnt1 = 0 
cnt2 = 0 
for i in range(1, N+1, 2):
  for j in range(1, i+1, 2):
    if i % j == 0:
      cnt1 += 1
    else:
      pass
  if cnt1 == 8:
    cnt2 += 1
  else:
    pass
  cnt1 = 0
print(cnt2)

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

ans = []
for i in range(1, N + 1, 2):
    count = 0
    for j in range(1, i // 2 + 1):
        if i % j == 0:
            count += 1
    if count == 7:
        ans.append(1)

print(sum(ans))

Solution (Python):
n = int(input())
a = 0
for i in range(1, n+1, 2):
    c = 0
    for j in range(1, n+1):
        if i%j==0:
            c += 1
    if c == 8:
        a += 1
print(a)

Solution (Python):
n = int(input())
ans = 0
for i in range(1, n + 1):
    if i % 2 == 1:
        cnt = 0
        for j in range(1, i + 1):
            if i % j == 0:
                cnt += 1
        if cnt == 8:
            ans += 1
print(ans)

Solution (Python):
def is_odd(n):
    if n % 2 == 1:
        return True
    else:
        return False
    
def p105(n):
    count = 0
    for s in range(n,0,-1):
        if is_odd(s):

            divisors = [s]

            for i in range(1,s):
                if s % i == 0:
                    divisors.append(i)
            if len(divisors) == 8:
                
                count += 1
    return count

if __name__ == "__main__":
    n = int(input())
    print(p105(n))

Solution (Python):
N = int(input())
count = 0
target = 0

for i in range(1, N + 1):
    if i % 2 == 0:
        continue
    for k in range(1, round(i ** (1/2))):
        if i % k == 0:
            count += 1
    if count == 4:
        target += 1
    count = 0

print(target)

Solution (Python):






import sys
input = sys.stdin.readline

import math

import bisect
from collections import defaultdict
from collections import deque
from functools import lru_cache






MOD = 10**9+7
INF = float('inf')






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def Yes(): print("Yes"); return
def No(): print("No"); return


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


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


def make_divisors(n):
  divisors = []
  for i in range(1, int(n**0.5)+1):
    if n % i == 0:
      divisors.append(i)
      if i != n // i: 
        divisors.append(n//i)
  return divisors


def lcm(a, b):
    return a * b // gcd (a, b)


def count_bit(n):
  count = 0
  while n:
    n &= n -1
    count += 1
  return count


def Base_10_to_n(X, n):
  if (int(X/n)):
    return Base_10_to_n(int(X/n), n)+[X%n]
  return [X%n]





N = inputI()

ans = 0
for i in range(3,N+1)[::2]:
  if len(make_divisors(i)) == 8:
    ans+=1
    
print(ans)

Solution (Python):

n = int(input())
def yakusu(x):
    cnt=0
    for i in range(1,x+1):
        if x%i==0:
            cnt+=1

    return cnt

cnt=0
for i in range(1,n+1,2):
    if yakusu(i)==8:
        cnt+=1

print(cnt)

Solution (Python):
N=int(input())
count=0
ans =0
for j in range(N+1):
    count =0
    if j %2 ==0:
        continue
    for i in range(1,N+1):
        if j % i ==0:
            count +=1
        else:
            continue
    if count == 8:
        ans += 1
print(ans)

Solution (Python):
n = int(input())
ans = 0
yaku = 0
for i in range(1,n+1,2):
  yaku = 0
  for j in range(1,i+1,2):

    if i % j == 0:
      yaku += 1

  if yaku == 8:
    ans += 1
print(ans)

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

ok_count = 0
for i in range(1, N + 1, 2):
    
    count = 0
    for j in range(1, i + 1):
        
        if i % j == 0:
            count += 1
    if count == 8:
        ok_count += 1
print(ok_count)

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

ok_count = 0
for i in range(1, N + 1, 2):
    
    count = 0
    for j in range(1, i + 1):
        
        if i % j == 0:
            count += 1
    if count == 8:
        ok_count += 1
print(ok_count)