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):
n=int(input())
ans=0
for i in range(1,n+1):
  cnt=0
  if i%2:
    for j in range(1,i+1):
      if i%j==0:
        cnt+=1
    if cnt==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+1):
        if(i%j==0):
            cnt+=1
    if(cnt==8):
        ans+=1
print(ans)

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

def divisor(n):
    div = set()
    i = 1
    while i ** 2 <= n:
        if n % i == 0:
            div.add(i)
            div.add(n // i)
        i += 1
    return len(div)

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

print(ans)

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

def get_divisors(n):
    return [i for i in range(1, n//2+1) if n%i == 0] + [n]

ans = 0
for i in range(1, n+1, 2):
    if len(get_divisors(i)) == 8:
        ans += 1
print(ans)

Solution (Python):
import sys

def divisor(i):
    count = 0
    for j in range(1, i + 1):
        if j ** 2 > i: break
        if i % j == 0:
            if j ** 2 == i: count += 1
            else: count += 2
    return count


def solve():
    N = int(input())
    ans = 0
    for i in range(1, N+1):
        if i % 2 > 0:
            if divisor(i) == 8: ans += 1
    print(ans)
    return 0

if __name__ == "__main__":
    solve()

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

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

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

print(ans)

Solution (Python):

from math import floor, sqrt

def f(x):
    p = set()
    for i in range(1, floor(sqrt(x))+1):
        if x%i == 0:
            p.add(i)
            p.add(x//i)
    return len(p)
def main():
    n = int(input())
    cnt = 0
    for i in range(1, n+1):
        if i%2 != 0:
            if f(i) == 8:
                cnt += 1
    print(cnt)
main()

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

if (N >= 105):
    
    for num in range(105, N + 1, 2):

        divisor = []
        
        for i in range(1, num + 1):
            if (num % i == 0):
                divisor.append(i)
        
        if (len(divisor) == 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

ans=0
for i in range(1,int(input())+1):
    if i%2==1:
        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):
    cnt = 0
    for j in range(1, N + 1):
        if i % j == 0:
            cnt += 1
    if cnt == 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(105,N+1,2):
    ans += 1 if len(make_divisors(i)) == 8 else 0
print(ans)

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


















NUM_YAKUSU = 8
cnt_8_yakusu=0
for n in range(1,N+1,2):

    cnt_yakusu = 0
    for x in range(1,n+1,2):
        if n % x == 0:
            
            cnt_yakusu+=1
    if cnt_yakusu == NUM_YAKUSU:
        cnt_8_yakusu +=1
print(cnt_8_yakusu)

Solution (Python):


import math
def solve():
  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)
solve()

Solution (Python):
def divisor(n):
    i = 1
    table = []
    while i * i <= n:
        if n%i == 0:
            table.append(i)
            table.append(n//i)
        i += 1
    table = list(set(table))
    table.sort()
    return table

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

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

res = 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:
    res += 1

print(res)

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

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

ki=[i for i in range(1,N+1,2)]
yakusuu=[]
ans=[]

for i in ki:
  for j in range(1,i+1):
    if i%j==0:
      yakusuu.append(j)
  else:
    ans.append(str(len(yakusuu)))
    yakusuu=[]

print(ans.count("8"))

Solution (Python):
def count_divisor(n):
    count = 0
    for i in range(1, n+1):
        if n % i == 0:
            count += 1
    return count


def main():
    n = int(input())
    ans = 0
    for i in range(1, n+1, 2):
        if count_divisor(i) == 8:
            ans += 1
    print(ans)


if __name__ == "__main__":
    main()

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

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

Solution (Python):
N = int(input())
if N < 105:
    print(0)
else:
    ans = 1
    for a in range(107, N+1, 2):
        tmp = 2
        for b in range(2, a//2):
            if a % b == 0:
                tmp += 1
        if tmp == 8:
            ans += 1
    print(ans)

Solution (Python):
import math
import copy
from operator import mul
from functools import reduce
from collections import defaultdict
from collections import Counter
from collections import deque

from itertools import product

from itertools import permutations

from itertools import combinations
from bisect import bisect_left, bisect_right


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]

def i_inpl(): return int(input())
def l_inpl(): return list(map(int, input().split()))
INF = float("inf")





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

if __name__ == "__main__":
    main()

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    lista=[105,135,165,189,195]
    n=INT()
    ct=0
    for i in range(1,n+1,2):
        if i in lista:
            ct+=1
    print(ct)
if __name__ == '__main__':
    do()

Solution (Python):


import sys
import math
import time

import collections
from collections import deque
import queue
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)
  
  return divisors





N = int(input())
ans = 0


for i in range(1,N+1):
  if not(i%2==0):
    Arr = make_divisors(i)
    if(len(Arr)==8):
      ans += 1

print(ans)

Solution (Python):


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


N = int(input())
cnt = 0

for i in range(N+1):
    if i%2 == 1 and len(divisor(i)) == 8:
        cnt += 1
print(cnt)

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

def divisors(n):
    m = 1
    divs = []
    while m * m <= n:
        if n % m == 0:
            divs.append(m)
            if n != m * m:
                divs.append(n // m)
        m += 1
    divs.sort()
    return divs
  
N = int(read())

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

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


if __name__ == '__main__':
    main()

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

def divisor(n):
    res = 0
    for i in range(1,int(n**0.5)+1):
        if n % i  == 0:
            res += 1
            if i != n//i:
                res += 1
    return res

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

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

def divisor(n):
    res = 0
    for i in range(1,n+1):
        if n % i  == 0:
            res += 1
    return res

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

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

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

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

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

Solution (Python):


n = int(input())

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

Solution (Python):
def dcount(n):
    c = 0
    for i in range(1, n+1):
        if n % i == 0:
            c += 1
    return c

N = int(input())
c = 0
for i in range(1, N + 1, 2):
    if dcount(i) == 8:
        c += 1
print(c)

Solution (Python):

n = int(input())
divisor_list = []
divisor_length = 0
ans = 0
for i in range(1,n+1):
    divisor_list = []
    divisor_length = 0
    
    if(i % 2 != 0):
        
        for j in range(1,i+1):
            if (i % j == 0):
                divisor_length += 1
    if(divisor_length == 8):
        ans += 1
print(ans)

Solution (Python):

n = int(input())
divisor_list = []
ans = 0
for i in range(1,n+1):
    divisor_list = []
    
    if(i % 2 != 0):
        
        for j in range(1,i+1):
            if (i % j == 0):
                divisor_list.append(j)
            if(len(divisor_list) == 8):
                ans += 1
print(ans)

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

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

mod = 10**9 + 7

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))

n = ni()
ans = 0
for m in range(1, n+1, 2):
    div = set()
    for i in range(1, int(m**0.5)+1):
        if m % i == 0:
            div.add(i)
            div.add(m//i)
    if len(div) == 8:
        ans += 1
print(ans)

Solution (Python):
def is_odd(num):
    return num % 2 == 1


def divisors_count(num):
    return sum(num % i == 0 for i in range(1, num+1))


n = int(input())
print(sum([1 for i in range(1, n+1) if is_odd(i) and divisors_count(i) == 8]))

Solution (Python):
import sys, math
def input():
    return sys.stdin.readline()[:-1]
from itertools import permutations, combinations
from collections import defaultdict, Counter
from math import factorial
from bisect import bisect_left 


sys.setrecursionlimit(10**7)
N = int(input())

if N < 105:
    print(0)
    exit()

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()

def main():
    n = int(input())
    ans = 0
    for i in range(105, 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)

if __name__ == '__main__':
    main()

Solution (Python):
n=int(input())
count=0
ans=0
for j in range(1,n+1,2):
  count=0
  for i in range(1,int(j**0.5)+1):
    if j%i==0:
      if j//i!=i:
        count+=2
      else:
        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
  tmp=0
  for j in range(1,n+1):
    if i%j==0:
      tmp+=1
  if tmp==8:
    ans+=1
print(ans)

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

def yakusu(n):
    L=[]
    for i in range(1,int(n**0.5)+1):
        if n%i==0:
            if i not in L:
                L.append(i)
            if n//i not in L:
                L.append(n//i)
    return len(L)

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

print(c)

Solution (Python):
n = int(input())
ans = 0
for i in range(1, n + 1):
  if i % 2 == 0:
    continue
  else:
    j = 1
    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())

def divisor(n):
    """
    n の約数をリストで返す
    :param int n:
    :rtype: list of int
    """
    ret = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            ret.append(i)
            if n // i != i:
                ret.append(n // i)
    return ret

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

print(ans)

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]





n=ii()

def mdiv(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 i in range(1,n+1):
    a=mdiv(i)
    if i%2==1 and len(a)==8:
        ans+=1
print(ans)

Solution (Python):
def solve():
    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

    return ans

print(solve())

Solution (Python):
def factorize(n):
    fct = []  
    b, e = 2, 0  
    while b * b <= n:
        while n % b == 0:
            n = n // b
            e = e + 1
        if e > 0:
            fct.append((b, e))
        b, e = b + 1, 0
    if n > 1:
        fct.append((n, 1))
    return fct

def solve():
    N = int(input())
    
    c = 0
    for i in range(1, N+1, 2):
        f = factorize(i)
        b = 1
        for j in f:
            b += b * j[1]
        if b == 8:
            c += 1

    return c

print(solve())

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

if N<105:
    print(0)
    exit()

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

Solution (Python):
import sys

N = int(sys.stdin.readline())
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):
    if i % 2 == 0:
        continue
    x = 0
    for j in range(1,i+1):
        if i % j == 0:
            x += 1
    if x == 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())

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

print(answer)

Solution (Python):
N=int(input())
ans=0
for i in range(8,N+1):
    if i%2==0: continue
    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 yaku(n):
    A = []
    for i in range(1,int(n**0.5)+1):
        if n%i==0:
            A.append(i)
            A.append(n//i)
    return len(A)
N = int(input())
cnt = 0
for i in range(1,N+1,2):
    if yaku(i)==8:
        cnt += 1
print(cnt)

Solution (Python):
def ABC106():
    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 = I()
    ans = 0
    for i in range((N+1)//2):
        cur = i*2+1
        if len(make_divisors(cur))==8:
            ans += 1
    print(ans)
    return

def exam2():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,copy,bisect,itertools,heapq,math,random
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

if __name__ == '__main__':
    ABC106()

"""

"""

Solution (Python):
n=int(input())
app=[]
for i in range(1,n+1,2):
    cnt=0
    for j in range(1,i+1):
        if i%j==0:
            cnt+=1
    if cnt==8:
        app.append(i)

print(len(app))

Solution (Python):
N=int(input())
count = 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:
        count += 1
print(count)

Solution (Python):
n = int(input())
cnt = 0
for i in range(105,n+1,2):
    cnt2 = 0
    for j in range(3,i,2):
        if i % j == 0:
            cnt2 += 1
    if cnt2 == 6:
        cnt += 1
print (cnt)

Solution (Python):
n=int(input())
print(sum(i<=n for i in [105,135,165,189,195]))

Solution (Python):

n = int(input())
tmp = 0
ans = 0

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

        if tmp == 8:
            ans += 1

        tmp = 0

print(ans)

Solution (Python):
def 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 != 0 and len(divisors(i)) == 8:
        ans += 1
print(ans)

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

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

print(ans)

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

ret = 0
for x in range(1, n + 1, 2):
    t = 1
    for i in range(2, x + 1):
        k = 0
        while x % i == 0:
            k += 1
            x //= i
        t *= k + 1
        if x == 1:
            break

    if t == 8:
        ret += 1

print(ret)

Solution (Python):
class Sieve:
    """区間[2,n]の値を素因数分解する"""

    def __init__(self, n=1):
        primes = []
        f = [0] * (n + 1)
        f[0] = f[1] = -1
        for i in range(2, n + 1):  
            if f[i]: continue
            primes.append(i)
            f[i] = i  
            for j in range(i * i, n + 1, i):  
                if not f[j]:
                    f[j] = i  
        self.primes = primes
        self.f = f

    def is_prime(self, x) -> bool:  
        return self.f[x] == x

    def factor_list(self, x) -> list:  
        res = []
        while x != 1:
            res.append(self.f[x])
            x //= self.f[x]
        return res

    def factor(self, x) -> list:  
        fl = self.factor_list(x)
        if not fl: return []
        res = [[fl[0], 0]]
        for p in fl:
            if res[-1][0] == p:
                res[-1][1] += 1
            else:
                res.append([p, 1])
        return res


n = int(input())
s = Sieve(n)

ret = 0
for x in range(1, n + 1, 2):
    t = 1
    for prime, cnt in s.factor(x):
        t *= cnt + 1

    if t == 8:
        ret += 1

print(ret)

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

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

ans=0

for i in range(1,N+1):
    howyaku=0
    if i%2==0:
        continue
    for k in range(1,int(i**0.5)+1):
        if i%k==0:
            howyaku+=1
            if k != i//k:
                howyaku+=1
    if howyaku==8:
        ans+=1

print(ans)

Solution (Python):
import math
N=int(input())
ans=0
if N<105:
	print(0)
else:
	for i in range (105,N+1):
		tmp=[]
		if i%2==1:
			for j in range(1,int(math.sqrt(N)+1)):
				if i%j==0:
					tmp.append(j)
					tmp.append(i//j)
			if len(set(tmp))==8:
				ans+=1
	print(ans)

Solution (Python):
N=int(input())
if N<105:
  print(0)
  exit()
cnt=1
for i in range(107,N+1,2):
  tmp=0
  for j in range(1,N+1):
    if i%j==0:
      tmp+=1
  if tmp==8:
    cnt+=1
print(cnt)

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

for i in range(1, n+1):
    count = 0
    if i % 2 == 0: continue
    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())

def divisor(n):
  i = 2
  count = 0
  divs = []
  while n != 1:
    if n % i:
      if count :
        divs.append(count)
        count = 0
      i+= 1
    else:
      n = n //i
      count += 1
      if n == 1:
        divs.append(count)
  ans = 1
  for d in divs:
    ans *= (d + 1)
  return ans

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

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

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


def 約数(n):
	count = 0
	for i in range(1,n+1):
		if n%i == 0:
			count += 1
	if count == 8:
		return True
	else:
		return
if n == 105:
	print(1)
elif n < 105:
	print(0)
else:
	ans = 1
	for i in range(106,n+1):
		if i%2 !=0:
			if 約数(i):
				ans += 1


	print(ans)

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

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

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

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

Solution (Python):

import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [input() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [int(input()) for i in range(n)]


class Math():
    @staticmethod
    def gcd(a, b):
        if b == 0:
            return a
        return Math.gcd(b, a % b)

    @staticmethod
    def lcm(a, b):
        return (a * b) // Math.gcd(a, b)

    @staticmethod
    def roundUp(a, b):
        return -(-a // b)

    @staticmethod
    def toUpperMultiple(a, x):
        return Math.roundUp(a, x) * x

    @staticmethod
    def toLowerMultiple(a, x):
        return (a // x) * x

    @staticmethod
    def nearPow2(n):
        if n <= 0:
            return 0
        if n & (n - 1) == 0:
            return n
        ret = 1
        while(n > 0):
            ret <<= 1
            n >>= 1
        return ret

    @staticmethod
    def sign(n):
        if n == 0:
            return 0
        if n < 0:
            return -1
        return 1

    @staticmethod
    def isPrime(n):
        if n < 2:
            return False
        if n == 2:
            return True
        if n % 2 == 0:
            return False
        d = int(n ** 0.5) + 1
        for i in range(3, d + 1, 2):
            if n % i == 0:
                return False
        return True

    @staticmethod
    def divisor(n):
        i = 1
        table = []
        while i * i <= n:
            if n % i == 0:
                table.append(i)
                table.append(n // i)
            i += 1
        table = list(set(table))
        return table


class PriorityQueue:
    def __init__(self, l=[]):
        self.__q = l
        heapq.heapify(self.__q)
        return

    def push(self, n):
        heapq.heappush(self.__q, n)
        return

    def pop(self):
        return heapq.heappop(self.__q)

    def list(self):
        return self.__q

    def length(self):
        return len(self.__q)


sys.setrecursionlimit(1000000)
MOD = int(1e09) + 7
INF = int(1e30)


def main():
    
    N = Scanner.int()
    ans = 0
    for i in range(1, N + 1, 2):
        if len(Math.divisor(i)) == 8:
            ans += 1
    print(ans)
    return


if __name__ == "__main__":
    main()

Solution (Python):
N= int(input())
if N%2==0:
    cand = list(range(1,N,2))
else:
    cand = list(range(1,N+1,2))

ans = 0
num = 0
for n in range(1,N+1):
    num = 0
    for c in cand:
        if n%c==0:
            num+=1
    if num ==8:
        ans+=1
print(ans)

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

Solution (Python):
n=int(input())
num=[3*5*7,3*3*3*5,3*5*11,3*3*3*7,3*5*13]
ans=0
for i in range(5):
    if n>=num[i]:
        ans+=1
    else:
        break
print(ans)

Solution (Python):
import sys
input = sys.stdin.readline
 
N = int(input())
if N < 105:
  print(0)
elif N < 135:
  print(1)
elif N < 165:
  print(2)
elif N < 189:
  print(3)
elif N < 195:
  print(4)
else:
  print(5)

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

print(nums_count)

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

print(nums_count)

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

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

    ans = 0

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

if __name__ == '__main__':
    main()

Solution (Python):
import sys
from collections import *
import heapq
import math
import bisect
from itertools import permutations,accumulate,combinations,product
from fractions import gcd
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
mod=pow(10,9)+7

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

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

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

Solution (Python):
n = int(input())
ans = []

if n < 105:
    print(0)
    exit(0)

for i in range(105, n + 1, 2):
    divisors = []
    for j in range(1, i + 1):
        if i % j == 0:
            divisors.append(j)

    if len(divisors) == 8:
        ans.append(i)

print(len(ans))