Being a crewmate in the Among Us game, you will have to solve a task to win against the imposter. 
The task : You are given a certain number of bulbs(Say n) which are initially in OFF position. 
The bulbs are numbered from 1 to n. There will be n current fluctuations in such a way that in the 1st fluctuation all bulbs are toggled, in the 2nd fluctuation every 2nd bulb is toggled, in the 3rd fluctuation every 3rd bulb is toggled and so on.
Your job as a crewmate is to find the number of bulbs which are ON at the end of n fluctuations. But, the imposter has a special power which alerts it when a bulb with a number divisible by 3 is kept ON at the end of n fluctuations. 
So, you will have to switch off the bulbs with numbers divisible by 3 and give the final result to complete the task and win the game.

-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow. 
- Each testcase contains of a single line of input, an integer $n$. 

-----Output:-----
- For each testcase, output a single integer - the number of bulbs that will remain ON after $n$ fluctuations.

-----Constraints :-----
- $1 \leq T \leq 1000$
- $2 \leq n \leq 10^9$

-----Sample Input:-----
2
2
20

-----Sample Output:-----
1

3

Difficulty: interview

Starter code:

Solutions:
import math
def CountSquares(a, b):
    return (math.floor(math.sqrt(b)) - math.ceil(math.sqrt(a)) + 1)
for _ in range(int(input())):
    n=int(input())
    val=CountSquares(1,n)
    ans=val-val//3
    print(ans)

import math
def CountSquares(a, b):
    return (math.floor(math.sqrt(b)) - math.ceil(math.sqrt(a)) + 1)
for _ in range(int(input())):
    n=int(input())
    val=CountSquares(1,n)
    ans=val-val//3
    print(ans)

import math
def CountSquares(a, b):
    return (math.floor(math.sqrt(b)) - math.ceil(math.sqrt(a)) + 1)
for _ in range(int(input())):
    n=int(input())
    val=CountSquares(1,n)
    ans=val-val//3
    print(ans)

l = []
for x in range(1,100000):
    if x%3!=0:
        l.append(x**2)
for _ in range(int(input())):
    n = int(input())
    c = 0
    for x in l:
        if x<=n:
            c+=1
        else:
            break
    print(c)

# cook your dish here
t=int(input())
for i in range(t):
    n=int(input())
    s=0
    for j in range(1,int(n**0.5)+1):
        if (j)%3==0:
            continue
            
        else:
            s+=1
    print(s)        


import math
t=int(input()) 
def CountSquares(b): 
    return (math.floor(math.sqrt(b)))
    
for i in range(t):
    n=int(input())
    l=0
    l=CountSquares(n)
    c=0
    for i in range(2,l+1):
        if(i%3==0):
            c+=1
    print(l-c)
    
            


t = int(input())

for _ in range(t):

	n = int(input())

	'''
	a = [0] * n

	for i in range(n):

		for j in range(i, n, i+1):

			if (j+1) % 3 == 0:
				continue

			a[j] = 0 if a[j] else 1

	print(a)

	'''

	i = 2
	count = 1
	while 1:

		if i*i > n:
			break

		if i % 3 != 0:
			count += 1
			
		i += 1

	print(count)


import sys
# import math
from math import gcd
# import re
# from heapq import *
# from collections import defaultdict as dd
# from collections import OrderedDict as odict
# from collections import Counter as cc
# from collections import deque
# sys.setrecursionlimit(10**5)#thsis is must
# mod = 10**9+7; md = 998244353
# m = 2**32
input = lambda: sys.stdin.readline().strip()
inp = lambda: list(map(int,sys.stdin.readline().strip().split()))
# def C(n,r,mod):
#   if r>n:
#       return 0
#   num = den = 1
#   for i in range(r):
#       num = (num*(n-i))%mod
#       den = (den*(i+1))%mod
#   return (num*pow(den,mod-2,mod))%mod
# M = 1000000+1
# pfc = [i for i in range(M+1)]
# def pfcs(M):
#     for i in range(2,M+1):
#         if pfc[i]==i:
#             for j in range(i+i,M+1,i):
#                 if pfc[j]==j:
#                     pfc[j] = i
#     return
#______________________________________________________
for _ in range(int(input())):
    n = int(input())
    ans = 0 
    for i in range(1,n+1):
        d = i*i
        if d>n:
            break
        if d%3!=0:
            ans+=1
    print(ans)

# cook your dish here
from math import sqrt
t=int(input())
for _ in range(t):
    n=int(input())
    rad=int(sqrt(n))
    div = rad//3
    print(rad-div)

for _ in range(int(input())):
    n=int(input())
    d=int(n**0.5)
    a=d//3
    print(d-a)

x=[]
for i in range(1,31624):
    if (i*i)%3!=0:
        x.append(i*i)

m= len(x)
for i in range(int(input())):
    n= int(input())
    if n<x[0]:
        print(0)
    elif n>x[-1]:
        print(m)
    else:
        for j in range(m):
            if x[j]>n:
                break
        print(j)




from math import sqrt

for _ in range(int(input())):
    N = int(input())
    print(int(sqrt(N)) - int(sqrt(N / 9)))

from sys import stdin
from math import ceil, gcd

# Input data
#stdin = open("input", "r")


def func():

    return

for _ in range(int(stdin.readline())):
    n = int(stdin.readline())
    ans = 0
    i = 1
    while(i * i <= n):
        if (i * i) % 3 != 0:
            ans += 1
        i += 1
    print(ans)