Problem:


Score : 100 points

Problem Statement

There are N students in a school.

We will divide these students into some groups, and in each group they will discuss some themes.

You think that groups consisting of two or less students cannot have an effective discussion, so you want to have as many groups consisting of three or more students as possible.

Divide the students so that the number of groups consisting of three or more students is maximized.

Constraints

1 \leq N \leq 1000

All input values are integers.

Input

Input is given from Standard Input in the following format:

N

Output

If you can form at most x groups consisting of three or more students, print x.

Sample Input 1

8

Sample Output 1

2

For example, you can form a group of three students and another of five students.

Sample Input 2

2

Sample Output 2

0

Sometimes you cannot form any group consisting of three or more students, regardless of how you divide the students.

Sample Input 3

9

Sample Output 3

3



Sample input:
8


Sample output:
2

Submission status: Accepted

Solution code:
n = int(input())

if n < 3:
    print(0)
else:
    print(n//3)

Submission status: Accepted

Solution code:
N = int(input())
 
print(N // 3)

Submission status: Accepted

Solution code:
#N人の生徒
#一つのグループを3人以上、グループの数を最大化する

#標準入力
N = int(input())
#x個のグループ
x = N // 3
print(x)

Submission status: Accepted

Solution code:
# A - Grouping 2

# N人の生徒を3人以上のグループに分けていったとき、
# 3人以上のグループを最大いくつ作れるか？

student = int(input())

print(student // 3)

Submission status: Accepted

Solution code:
# A - Grouping 2

N = int(input())


if N % 3 == 0:
    answer = N // 3
    print(answer)
else:
    answer = N // 3
    print(answer)

Submission status: Accepted

Solution code:
N = int(input())

print(int(N/3))

Submission status: Accepted

Solution code:
# 089_a
N = int(input())
if 1 <= N & N <= 1000:
    result = int(N/3)
    print(result)

Submission status: Accepted

Solution code:
# 入力
x = int(input())

# 処理
ansewr = x // 3
print(ansewr)

Submission status: Accepted

Solution code:
N = int(input())

x = N // 3

if x >= 1:
    print(x)

else:
    print('0')

Submission status: Accepted

Solution code:
# 入力
N = int(input())

# 処理
answer = N // 3

# 出力
print(answer)

Submission status: Accepted

Solution code:
S = input()
          
q = int(S) // 3
print(q)

Submission status: Accepted

Solution code:
#   AtCoder abc089 a

#   入力
n = int(input())

#   判定
if n < 3:
    print(0)
else:
    print(n // 3)

Submission status: Accepted

Solution code:
# N人の生徒を分けて 3 人以上のグループの数を最大化
# 3人以上のグループを最大で x 個作れるとき x を出力

# 入力値を数値に変換
N = int(input())

# 3で割った時の整数の商をxとして出力
x = N // 3
print(x)

Submission status: Accepted

Solution code:
# Nを定義
N = int(input())

# Nを３で割った時のあまりを出す
Surplus =  int( N ) % 3

# 条件分岐
if Surplus < 3:
    print( N //3 )

Submission status: Accepted

Solution code:
import math as m

N=input()
N=int(N)
n=N//3
n=m.floor(n)
print(n)

Submission status: Accepted

Solution code:
N = int(input())  # 生徒数N人を入力
group_N = (N // 3) # Nを3で割り、余りは切り捨て
print(group_N)

Submission status: Accepted

Solution code:
#生徒の人数を取得
N = int(input())
 
# 生徒人数を3で割った商の小数点を切り捨てた数値(最大のグループ数の出力)を変数に格納
print(N // 3)

Submission status: Accepted

Solution code:
a=int(input())
print(int(a/3))

Submission status: Accepted

Solution code:
# 生徒数を入力
n = int(input())
# 3人グループを作るため３で割った時の商を出力
print(n // 3)

Submission status: Accepted

Solution code:
N = int(input())
x = N // 3

if x >= 1:
    print(x)
else:
    print('0')

Submission status: Accepted

Solution code:
n = int(input())
print(int(n/3))

Submission status: Accepted

Solution code:
# 089a

N = int(input()) # 人数Nを入力

group_N = N // 3    #人数を3人で割って整数で切り捨てる

print(group_N)

Submission status: Accepted

Solution code:
N = int(input())

x = N // 3
print(x)

# //は切り捨て

Submission status: Accepted

Solution code:
N= int(input())

print(N//3)

Submission status: Accepted

Solution code:
#089
#ある学校には、N人の生徒がいる
#2人以下のグループだと❎
#3人以上のグループを最大で x　個作れるとき、x　を出力せよ
# 1 <= N <= 1000
#入力は全て整数のみ
#生徒数　N　の入力
N = int(input(''))

#生徒数　N を3で割って切り捨てる
answer=int(N/3)

#結果
print(answer)

Submission status: Accepted

Solution code:
def resolve():
    n = int(input())
    c = 0
    while n - 3 >= 0:
        n -= 3
        c += 1
    print(c)
resolve()

Submission status: Accepted

Solution code:
N = int(input())
print(N//3)

Submission status: Accepted

Solution code:
n = int(input())

answer = n // 3

print(answer)

Submission status: Accepted

Solution code:
N = input()
answer = int(N) // 3
print(answer)

Submission status: Accepted

Solution code:
N = int(input())
x = N // 3
print(x)

Submission status: Accepted

Solution code:
# 生徒n人を入力する
n=int(input())

# 整数の割り算をする
print(n//3)

Submission status: Accepted

Solution code:
N = int(input())
X = N//3
print(X)

Submission status: Accepted

Solution code:
N = int(input())

x=N//3              #生徒の人数で割ったものがグループ数
                    #//で小数点以下を削除している
print(x)

Submission status: Accepted

Solution code:
# A - Grouping 2
# ある学校に N 人の生徒がいる
# なるべく多く 3人 以上のグループにしたい！
# 3人以上のグループを 最大で x 個 作れるときの x の値を出力する

# 生徒数 N （整数） を入力
N = int(input())
# print(N)

# # N を 3 で割った余りで 計算する
# if 及び % を使わずに再現
answer = int(N / 3)


# 結果の表示
print(answer)

Submission status: Accepted

Solution code:
number = int(input())

print(number // 3)

Submission status: Accepted

Solution code:
# A - Grouping 2
# ある学校に N 人の生徒がいる
# なるべく多く 3人 以上のグループにしたい！
# 3人以上のグループを 最大で x 個 作れるときの x の値を出力する

# 生徒数 N （整数） を入力
N = int(input())
# print(N)

# N を 3 で割った余りで 計算する

if N % 3 == 0:
    # print('amari0')
    answer = int(N / 3)
elif N % 3 == 1:
    # print('amari1')
    answer = int((N - 1) / 3)
else:
    # print('amari2')
    answer = int((N - 2) / 3)

# 結果の表示
print(answer)

Submission status: Accepted

Solution code:
# 089A

N = int(input())

x = N // 3

print(x)

Submission status: Accepted

Solution code:
N = int(input())

answer = int(N / 3)
print(answer)

Submission status: Accepted

Solution code:
total_students = int(input())

if total_students >= 3:
    groups_of_three_student = total_students // 3
    print(groups_of_three_student)
else:
    print(0)

Submission status: Accepted

Solution code:
# 入力
N = int(input(''))

# N を 3 で割って切り捨てる
Group = N // 3

# 出力
print(Group)

Submission status: Accepted

Solution code:
# 入力
a = int(input())

# 処理
answer = a // 3

# 出力
print(answer)

Submission status: Accepted

Solution code:
#N人の生徒
#2人以下NG
#3人以上OK
#1<=N<=1000
#入力はすべて整数
#number=input('整数入力'）
#Print(number)

N=int(input())


# //は小数点以下削除機能
x=N//3
print(x)

Submission status: Accepted

Solution code:
N = int(input())
ans = N // 3
print(ans)

Submission status: Accepted

Solution code:
n=int(input())
if n<3:
  print(0)
else:
  print(int(n//3))

Submission status: Accepted

Solution code:
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    N = I()

    ans = N // 3
    print(ans)

if __name__ == '__main__':
    resolve()

Submission status: Accepted

Solution code:
x = int(input())
print(x//3)

Submission status: Accepted

Solution code:
n = int (input ())
m = n%3
o = n-m
p = round (o/3)
print (p)

Submission status: Accepted

Solution code:
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#s, t = map(str, input().split())
#l = list(map(int, input().split()))
#l = [list(map(int,input().split())) for i in range(n)]
#a = [list(input()) for _ in range(n)]
#a = [int(input()) for _ in range(n)]

n = int(input())
print(n//3)

Submission status: Accepted

Solution code:

def main():
    n = int(input())
    print(n//3)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
N =int(input())
if N<=2:
    print(0)
    exit()

count = 0
while N >=6:
    N-=3
    count+=1
count+=1
print(count)

Submission status: Accepted

Solution code:
import sys

read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    N = int(readline())
    print(N // 3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys

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


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

    print(N // 3)

    return


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
N = int(input())

print(N//3)

Submission status: Accepted

Solution code:
def main():
    n = int(input())
    print(n // 3)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n=int(input())
print(n//3)

Submission status: Accepted

Solution code:
print((int(input()))//3)

Submission status: Accepted

Solution code:
print int(raw_input())/3

Submission status: Accepted

Solution code:
# # Make IO faster
# import sys
# input = sys.stdin.readline

# # get single (or) multiple str
# X = input()

# # get single int
# N = int(input())
# # get multiple int (e.g., 2)
# X, Y = map(int, input().split())
# # get multiple int (e.g., 2) for N lines
# XY = [list(map(int, input().split())) for _ in range(N)]

# from IPython import embed; embed(); exit();

# 全部入り
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
import numpy as np
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

print(INT() // 3)

Submission status: Accepted

Solution code:
n = int(input())
my_result = (n - (n % 3)) / 3
print(int(my_result))

Submission status: Accepted

Solution code:
print(str(int(input())//3))

Submission status: Accepted

Solution code:
print(int(input())//3)

Submission status: Accepted

Solution code:
n= int(input())
print(n//3)

Submission status: Accepted

Solution code:
def solve():
    N = int(input())
    print(N//3)


if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
n = int(input())
a = n//3
print(a)

Submission status: Accepted

Solution code:
N = int(input())
ans = N//3
print(ans)

Submission status: Accepted

Solution code:
# input()
# int(input())
# map(int, input().split())
# list(map(int, input().split()))
# list(map(int, list(input()))) # スペースがない数字リストを読み込み
import math
import fractions
import sys
import bisect
import heapq  # 優先度付きキュー(最小値取り出し)
import collections
from collections import Counter
from collections import deque
import pprint
import itertools

sr = lambda: input()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

"""nを素因数分解"""
"""2以上の整数n => [[素因数, 指数], ...]の2次元リスト"""


def factorization(n):
    arr = []
    temp = n
    if n == 1:
        return arr

    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


# a^n
def power(a, n, mod):
    x = 1
    while n:
        if n & 1:
            x *= a % mod
        n >>= 1
        a *= a % mod
    return x % mod


# n*(n-1)*...*(l+1)*l
def kaijo(n, l, mod):
    if n == 0:
        return 1
    a = n
    tmp = n - 1
    while (tmp >= l):
        a = a * tmp % mod
        tmp -= 1
    return a

# Union Find
class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

# 約数生成
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


inf = 10 ** 18
mod = 10 ** 9 + 7

n = ir()
print(n//3)

Submission status: Accepted

Solution code:
n = int(input())
c = n // 3
if c == 0:
    print(0)
else:
    print(c)

Submission status: Accepted

Solution code:
N = int(input())
ans = N // 3
print(ans)

Submission status: Accepted

Solution code:
n = int(input())
print(n//3)

Submission status: Accepted

Solution code:
N = int(input())
res = int(N / 3)
if N <=2:
  res = 0
print(res)

Submission status: Accepted

Solution code:
N=int(input())
print(int(N/3))

Submission status: Accepted

Solution code:
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def s(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

n = k()
print(n//3)

Submission status: Accepted

Solution code:
import sys
from math import ceil
def input(): return sys.stdin.readline().strip()


def main():
    n = int(input())
    print(ceil(n // 3))

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def INT():
    return int(input())

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

def LI():
    return list(map(int, input().split()))

print(INT() // 3)

Submission status: Accepted

Solution code:
N=int(input())
n=N//3
print(n)

Submission status: Accepted

Solution code:
N = int(input())
print(N // 3)

Submission status: Accepted

Solution code:
N=int(input())

print(N//3)

Submission status: Accepted

Solution code:
n=int(input())
#a,b=map(int,input().split())
#l=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]

print(n//3)

Submission status: Accepted

Solution code:
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

print(ri()//3)

Submission status: Accepted

Solution code:
N=int(input())
 
print(N//3)

Submission status: Accepted

Solution code:
a = int(input())

print(int(a/3))

Submission status: Accepted

Solution code:
import sys
import math
N = int(input())
if not (1 <= N <= 1000):
    sys.exit()

print(math.floor(N/3))

Submission status: Accepted

Solution code:
s = input()
N = int(s)
print(int(N/3))

Submission status: Accepted

Solution code:
# input
N = int(input())

# check
if N < 3:
    print(0)
else:
    print(N // 3)

Submission status: Accepted

Solution code:
N = int(input())
if N % 3 != 0:
  print(N // 3)
else:
  print(N // 3)

Submission status: Accepted

Solution code:
N = int(input())

count = int(0)
g = N

while g >= 3:
    g = g - 3
    count = count + 1

print(count)

Submission status: Accepted

Solution code:
N=int(input())


print(N//3)

Submission status: Accepted

Solution code:
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
INF = 10**9
mod = 10**9+7

N = i()
print(N//3)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

n = int(input())

print(n // 3)

Submission status: Accepted

Solution code:
n =int(input())
print(n // 3)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

N = int(input())
print(N // 3)

Submission status: Accepted

Solution code:
def main():
    N = int(input())
    print(N // 3)
main()

Submission status: Accepted

Solution code:
N = int(input())

a = N // 3
print(a)

Submission status: Accepted

Solution code:
N = int(input())

ans = N // 3

print(ans)

Submission status: Accepted

Solution code:
def main():
    from builtins import int, map, list, print
    import sys
    sys.setrecursionlimit(10 ** 6)

    input = (lambda: (sys.stdin.readline()).rstrip())
    input_list = (lambda: input().split())
    input_number = (lambda: int(input()))
    input_number_list = (lambda: list(map(int, input_list())))

    N = input_number()
    print(N // 3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a = int(input())
if a<=2:
  print(0)
else:
  print(a//3)

Submission status: Accepted

Solution code:
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

N = int(input())
print(N//3)

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.readline

N = int(readline())
print(N // 3)

Submission status: Accepted

Solution code:
# H, W = map(int,input().split())
N = int(input())
# al = list(map(int,input().split()))
print(N // 3)

Submission status: Accepted

Solution code:
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**6)

n=int(input().rstrip())
print(n//3)

Submission status: Accepted

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

    print(N // 3)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n = int(input())

print(int(n//3))

Submission status: Accepted

Solution code:
N=int(input())
if N > 2:
  print(N//3)
else:
  print(0)

Submission status: Accepted

Solution code:
def actual(n):
    return int(n // 3)

n = int(input())
print(actual(n))

Submission status: Accepted

Solution code:
n = int(input())
ans = n // 3
print(ans)

Submission status: Accepted

Solution code:
N=int(input())
print(N//3)

Submission status: Accepted

Solution code:
n = int(input())
c = n//3

print(c)

Submission status: Accepted

Solution code:
n = int(input())

print((n - n%3)//3)

Submission status: Accepted

Solution code:
def main():
    n = int(input())
    res = n // 3
    print(res)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
N=int(input())

print(int(N/3))

Submission status: Accepted

Solution code:
n = int(input())
if n < 3:
    print(0)
else:
    print(n // 3)

Submission status: Accepted

Solution code:
a = int(input())
print(a // 3)

Submission status: Accepted

Solution code:
N_str = input()
N = int(N_str)

Gr_num = 3 #○人ずつのグループを作りたい

N_div = N // Gr_num

if N >= 3:
    print(N_div)
elif N < 3:
    print(0)

Submission status: Accepted

Solution code:
import math
N=(int)(input())
print(math.floor(N/3))

Submission status: Accepted

Solution code:
n=int(input())
num=0
while n>=3:
    n-=3
    num+=1
print(num)

Submission status: Accepted

Solution code:

n=int(input())

print(n//3)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs            # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random                                # random, uniform, randint, randrange, shuffle, sample
# import string                                # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime          # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime       # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta               # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy              # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat   # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby                # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap                # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations  # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate             # accumulate(iter[, f])
# from operator import itemgetter              # itemgetter(1), itemgetter('key')
# from fractions import gcd                    # for Python 3.4 (previous contest @AtCoder)



def main():
    mod = 1000000007                # 10^9+7
    inf = float('inf')              # sys.float_info.max = 1.79...e+308
    # inf = 2 ** 64 - 1             # (for fast JIT compile in PyPy) 1.84...e+19
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    n = ii()
    print(n // 3)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
a=int(input())
print(a//3)

Submission status: Accepted

Solution code:
from math import floor
print(floor(int(input()) / 3))

Submission status: Accepted

Solution code:
import collections

#文字列を一文字ずつ取得したいとき
def inputStrOnebyOne():
    s = list(input())
    return s

#整数を一つずつリストに入れる
def inputOnebyOne_Int():
    a = list(int(x) for x in input().split())
    return a

def main():
    a = int(input())
    print(int(a/3))

if __name__=='__main__':
    main()

Submission status: Accepted

Solution code:
# -*- coding: <encoding name> -*-

N = int(input())
print(N // 3)

Submission status: Accepted

Solution code:
import sys

input = sys.stdin.readline


def main():
    N = int(input())
    ans = N // 3
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Fri May 15 13:51:13 2020

@author: shinba
"""

print(int(input())//3)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
N = int(input())
print(N // 3)

Submission status: Accepted

Solution code:
def main():
    n = int(input())
    print(n//3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math
N = int(input())
print(math.floor(N / 3))

Submission status: Accepted

Solution code:
n = int(input())
print( n // 3)

Submission status: Accepted

Solution code:
import sys
import math
import bisect

def main():
    n = int(input())
    print(n // 3)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:

def resolve():
	n = int(input())
	print(n//3)
resolve()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

def main():
    print(int(input())//3)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:

n = int(input())
print(n//3)

Submission status: Accepted

Solution code:
n=int(input())
print(int(n/3))

Submission status: Accepted

Solution code:
n = int(input())

ans = n // 3
print(ans)

Submission status: Accepted

Solution code:
print(int(input()) // 3)

Submission status: Accepted

Solution code:
n = int(input())

if n >= 3:
    group = n//3
else:
    group = 0
print(group)

Submission status: Accepted

Solution code:
def ABC_89_A():
    N = int(input())
    if N>=3:
        print(int(N/3))
    else:
        print(0)

if __name__ == '__main__':

    ABC_89_A()

Submission status: Accepted

Solution code:
N=int(input())
print (N//3)

Submission status: Accepted

Solution code:
def main():
    print(int(input())//3)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def main():
    n = int(input())
    if n < 3: print(0)
    elif n == 3: print(1)
    else: print(n//3)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# region header
import sys
import math
from bisect import bisect_left, bisect_right, insort_left, insort_right
from collections import defaultdict, deque, Counter
from copy import deepcopy
from fractions import gcd
from functools import lru_cache, reduce
from heapq import heappop, heappush
from itertools import accumulate, groupby, product, permutations, combinations, combinations_with_replacement
from math import ceil, floor, factorial, log, sqrt, sin, cos
from operator import itemgetter
from string import ascii_lowercase, ascii_uppercase, digits
sys.setrecursionlimit(10**7)
rs = lambda: sys.stdin.readline().rstrip()
ri = lambda: int(rs())
rf = lambda: float(rs())
rs_ = lambda: [_ for _ in rs().split()]
ri_ = lambda: [int(_) for _ in rs().split()]
rf_ = lambda: [float(_) for _ in rs().split()]
INF = float('inf')
MOD = 10 ** 9 + 7
PI = math.pi
# endregion
N = ri()
print(N // 3)

Submission status: Accepted

Solution code:
N = int(input())
if N%3 < 3:
  print(N//3)
elif N<3:
  print('0')
else:
  print(N//3)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

N = int(input())

print(N//3)

Submission status: Accepted

Solution code:
print( int(input()) // 3)

Submission status: Accepted

Solution code:
print(int(int(input())/3))

Submission status: Accepted

Solution code:
n=int(input())
ans=n//3
print(ans)

Submission status: Accepted

Solution code:
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop

import collections

N = int(input())
print(N//3)

Submission status: Accepted

Solution code:
# ABC089A(n):

n = int(input())
print(n // 3)

Submission status: Accepted

Solution code:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

N = INT()
print(N//3)

Submission status: Accepted

Solution code:
N=int(input())
ans=N//3
print(ans)

Submission status: Accepted

Solution code:
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [LI()for i in range(n)]
inf = 10**17
mod = 10**9 + 7

n=I()
print(n//3)

Submission status: Accepted

Solution code:
a = int(input())
print(int(a//3))

Submission status: Accepted

Solution code:
def main():
    n = int(input())
    print(n // 3)


if __name__ == '__main__':
    main()

# import sys
# input = sys.stdin.readline
# 
# sys.setrecursionlimit(10 ** 7)
# 
# (int(x)-1 for x in input().split())
# rstrip()

Submission status: Accepted

Solution code:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

N = INT()
num = 3
cnt = 0
print(N // 3)