Problem:


Score : 300 points

Problem Statement

Given is a positive integer L.
Find the maximum possible volume of a rectangular cuboid whose sum of the dimensions (not necessarily integers) is L.

Constraints

1 ≤ L ≤ 1000

L is an integer.

Input

Input is given from Standard Input in the following format:

L

Output

Print the maximum possible volume of a rectangular cuboid whose sum of the dimensions (not necessarily integers) is L.
Your output is considered correct if its absolute or relative error from our answer is at most 10^{-6}.

Sample Input 1

3

Sample Output 1

1.000000000000

For example, a rectangular cuboid whose dimensions are 0.8, 1, and 1.2 has a volume of 0.96.

On the other hand, if the dimensions are 1, 1, and 1, the volume of the rectangular cuboid is 1, which is greater.

Sample Input 2

999

Sample Output 2

36926037.000000000000



Sample input:
3


Sample output:
1.000000000000

Submission status: Accepted

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

import sys

DEBUG = False

def read(t):
    return t(sys.stdin.readline().rstrip())


def read_list(t, sep = " "):
    return [t(s) for s in sys.stdin.readline().rstrip().split(sep)]


def dprint(*args, **kwargs):
    if DEBUG:
        print(*args, **kwargs)
    return


def main():
    l = read(int)
    print((l/3)**3)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:

L = int(input())

dammy = (L/3)**3

print(dammy)

Submission status: Accepted

Solution code:
def main():
    L = int(input())
    i = L/3
    print(i**3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
l = int(input())

ans = l ** 3 / 27

print(ans)

Submission status: Accepted

Solution code:
L = int(input())
x = L/3
print('{:.10f}'.format(x*x*x))

Submission status: Accepted

Solution code:
l = float(input())
print(pow(l/3,3))

Submission status: Accepted

Solution code:
L=int(input())
print('{:.10f}'.format((L/3)**3))

Submission status: Accepted

Solution code:
L = int(input())

# vol is max when it is a cube, ie each side is L / 3
l = L/3

print(l ** 3)

Submission status: Accepted

Solution code:
l = int(input())
from decimal import *
getcontext().prec = 500

ippen = Decimal(Decimal(l)/3)
print(Decimal(ippen**3))

Submission status: Accepted

Solution code:
def solve():
    tl = int(input())

    ans = tl ** 3 / 27
    print(ans)
    return

if __name__ == "__main__":
    solve()

Submission status: Accepted

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

def main():
    l = int(input())
    print((l / 3) ** 3)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a = int(input())

print((a / 3) ** 3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np

sum_ls = np.asarray(input(), dtype=np.float64)

length = sum_ls / 3

ans = length ** 3

print(ans)

Submission status: Accepted

Solution code:
def main():
    L = int(input())
    a, b, c = L / 3, L / 3, L / 3
    if a + b + c != L:
        a += L - (a + b + c)
    print(a * b * c)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:

a = input()
a=float(a)
print((a/3)**3)

Submission status: Accepted

Solution code:
l = int(input())

s = l/3

print(s**3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())
l = L/3

print(l**3)

Submission status: Accepted

Solution code:
L=int(input())

l = L/3
print(l*l*l)

Submission status: Accepted

Solution code:
L = int(input())

Volume = (L/3) ** 3

print(Volume)

Submission status: Accepted

Solution code:
def main():
    L = int(input())
    Ll = L/3
    print(Ll**3)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
l = int(input())
n = l/3
x = n**3
print("{0:.7f}".format(x))

Submission status: Accepted

Solution code:
l = int(input())

a = l/3
print(a**3)

Submission status: Accepted

Solution code:
L = int(input())

l = L/3

print(l*l*l)

Submission status: Accepted

Solution code:
l = int(input())
print(l / 3 * l / 3 * l / 3)

Submission status: Accepted

Solution code:
L=int(input())
A=(L**3)/27
print(A)

Submission status: Accepted

Solution code:
a = int(input())

print((a/3) * (a/3) * (a/3))

Submission status: Accepted

Solution code:
l = int(input()) / 3
print(l ** 3)

Submission status: Accepted

Solution code:
number=int(input())
number/=3
Maxvalue=number**3
print(Maxvalue)

Submission status: Accepted

Solution code:
L = int(input())

ans = L**3/27

print(float(ans))

Submission status: Accepted

Solution code:
import numpy as np
from decimal import Decimal
L = input()
print((Decimal(L) / 3) ** 3)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**6)
ii = lambda: int(input())
mis = lambda: map(int,input().split())
lmis = lambda: list(mis())
INF = float('inf')

def main():
    L=float(input())
    a=L/3
    b=(L-a)/2
    print(a*b*(L-a-b))


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
l = int(input())
print(l*l*l/27)

Submission status: Accepted

Solution code:
L = int(input())
print('{:.12f}'.format((L / 3) ** 3))

Submission status: Accepted

Solution code:
L = int(input())

a = L / 3

print(a**3)

Submission status: Accepted

Solution code:
L = int(input())

ans = L**3 / 27

print(ans)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
N = int(input().strip())
print((N / 3) ** 3)

Submission status: Accepted

Solution code:
import decimal
l = int(input())
print((l/3)**3)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
L = int(input().strip())

print(L**3 / 27)

Submission status: Accepted

Solution code:
L = int(input())

a = L / 3
print('{:.12f}'.format((L / 3) ** 3))

Submission status: Accepted

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

Submission status: Accepted

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


def solve(L: int):
    r = L / 3
    print(r ** 3)
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    L = int(next(tokens))  # type: int
    solve(L)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10000000)


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n=float(input())
n=n/3
n=(n*n*n)
print('%.12f'%n)

Submission status: Accepted

Solution code:
L=int(input())
T=L**3
k=T/27
print('{:9f}'.format(k))

Submission status: Accepted

Solution code:
L=int(input())
di = L/3
print(str(di * di * di))

Submission status: Accepted

Solution code:
import sys

stdin = sys.stdin

ns = lambda : stdin.readline().rstrip()
ni = lambda : int(ns())
na = lambda : list(map(int, stdin.readline().split()))
sys.setrecursionlimit(10 ** 7)

def main():
    l = ni()
    print((l / 3) ** 3)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!/user/bin/env python3
# -*- conding: utf-8 -*-

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

    v = (L/3) ** 3

    print(v)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import numpy as np
l = int(input())

e = l / 3
print(e * e * e)

Submission status: Accepted

Solution code:
l = int(input())
ans = l**3 / 27

print(ans)

Submission status: Accepted

Solution code:
from decimal import Decimal

L = Decimal(float(input().strip()))

print("{:.6f}".format(L * L * L / Decimal(27.0)))

Submission status: Accepted

Solution code:
L = int(input())

def cal_rec(x, y, z):
    return x * y * z

ans = cal_rec(L, L, L) / 3 ** 3
print(ans)

Submission status: Accepted

Solution code:
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import *				# bisect_left(arr,x,start,end)  => start and end parameters are temporary
from sys import stdin				# bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''
3
'''

def solve(L):
	l = L/3
	w = (L - l)/2
	h = L - w - l
	return l*w*h
	

L = int(stdin.readline())
ans = solve(L)
print("%.10f"%ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#a,b = [int(x) for x in input().split()]
s = int(input())
a = s/3
V = a**3
print(V)

Submission status: Accepted

Solution code:
L = float(input())
a = L/3
print(a**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np
L = np.array(int(input()), dtype='float128')
ans = (L / 3)**3
print(ans)

Submission status: Accepted

Solution code:
l = int(input())

l3 = l/3

ans = l**3/(3**3)

print('%.6f'%ans)

Submission status: Accepted

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


def main():
    l = int(input())
    print((l ** 3) / 27)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

#output
print((L/3)**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    l = int(input())

    print((l / 3) ** 3)

Submission status: Accepted

Solution code:
import bisect,collections,copy,itertools,math,string
def I(): return int(input())
def S(): return input()
def LI(): return list(map(int,input().split()))
def LS(): return list(input().split())
##################################################
N = I()
print((N/3)**3)

Submission status: Accepted

Solution code:
L = int(input())
result = (L / 3) ** 3
print(result)

Submission status: Accepted

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

L = int(input())
print((L/3)**3)

Submission status: Accepted

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

def main():
    l=int(input())
    print((l/3)**3)
            
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def main():

    a = int(input())
    print(float(a/3) ** 3)





if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
i = float(input())
a = i / 3
a = a**3
print('%.12f' % a)

Submission status: Accepted

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

Submission status: Accepted

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

l = int(input())

x = l / 3
y = l / 3
z = l - (x + y)

print(x*y*z)

Submission status: Accepted

Solution code:
L=int(input())

print( (L/3)**3 )

Submission status: Accepted

Solution code:
import math
a=int(input())

K =a**3/27
print(K)

Submission status: Accepted

Solution code:
# Author: cr4zjh0bp
# Created: Sun Mar 22 11:54:41 UTC 2020
import sys
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni      = lambda: int(ns())
nin     = lambda y: [ni() for _ in range(y)]
na      = lambda: list(map(int, stdin.readline().split()))
nan     = lambda y: [na() for _ in range(y)]
nf      = lambda: float(ns())
nfn     = lambda y: [nf() for _ in range(y)]
nfa     = lambda: list(map(float, stdin.readline().split()))
nfan    = lambda y: [nfa() for _ in range(y)]
ns      = lambda: stdin.readline().rstrip()
nsn     = lambda y: [ns() for _ in range(y)]
ncl     = lambda y: [list(ns()) for _ in range(y)]
nas     = lambda: stdin.readline().split()

l = ni()

p = l % 3
ans = (l / 3) * (l / 3) * (l / 3)
print(ans)

Submission status: Accepted

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

L = int(input())
d = L / 3

print(d**3)

Submission status: Accepted

Solution code:
l = int(input())
vol = l**3
print(vol/27.0)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import math

L = int(sys.stdin.readline())

V = (L/3) ** 3
print(V)

Submission status: Accepted

Solution code:
L = int(input())
edge = L/3
print(edge**3)

Submission status: Accepted

Solution code:
from decimal import Decimal as dec
L = int(input())
dL = dec(L)

print((dL/3)**dec(3))

Submission status: Accepted

Solution code:
L = int(input())
l = L/3
print(l * l * l)

Submission status: Accepted

Solution code:

l = int(input())

print((l/3)**3)

Submission status: Accepted

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

L = int(input())

x = L/3
print(x ** 3)

Submission status: Accepted

Solution code:
import decimal
decimal.getcontext().prec = 200

l = int(input())
l = decimal.Decimal(l)
s = l / 3
v = s ** 3
print(v)

Submission status: Accepted

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

    print((l/3)**3)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
l = int(input())
r = l/3
print(r*r*r)

Submission status: Accepted

Solution code:
inp = int(input())

v = (inp/3)**3

print(v)

Submission status: Accepted

Solution code:
# import bisect
# from collections import Counter, deque
# import copy
# from fractions import gcd
# from functools import reduce
# from itertools import accumulate, permutations, combinations, combinations_with_replacement, groupby, product
# import math
# import numpy as np
import sys
sys.setrecursionlimit(10 ** 5 + 10)
# input = sys.stdin.readline

def resolve():
    L=int(input())
    print(L**3/27)

resolve()

Submission status: Accepted

Solution code:
L = float(input())
s = L / 3.0
print(s ** 3)

Submission status: Accepted

Solution code:
L = int(input())

ans = (L**3) / (3**3)

print(ans)

Submission status: Accepted

Solution code:
ll = int(input())

ll_tri = ll / 3

volume = ll_tri * ll_tri * ll_tri

print(volume)

Submission status: Accepted

Solution code:
import decimal
L = decimal.Decimal(input())
L = L/3
print(L*L*L)

Submission status: Accepted

Solution code:
l = float(input())

ans = (l/3)**3
print('{:.12f}'.format(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())
r = L/3
print(r*r*r)

Submission status: Accepted

Solution code:
L = float(input())
print((L / 3) ** 3)

Submission status: Accepted

Solution code:
L=int(input())
m=L/3
V=m**3
#print(m)
print(V)

Submission status: Accepted

Solution code:
from decimal import Decimal
l = int(input())
print(Decimal((Decimal(l)/Decimal(3))**Decimal(3)))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
#sys.setrecursionlimit(150000)


def solve(L: int):
    a=L/3-1e-10
    print(a**3)
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    L = int(next(tokens))  # type: int
    solve(L)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# from math import factorial,sqrt
# from itertools import permutations as permus
# from fractions import gcd
# from collections import deque,Counter
# from decimal import Decimal, getcontext
# # getcontext().prec = 1000
# # eps = Decimal(10) ** (-100)

# import numpy as np
# import scipy as scp

# 入力の受け取り
L = int(input())

# ans = 0
# for i in range(1,L+1):
#     for j in range(1,L-i+1):
#         k = L-i-j
#         ans = max(ans,i*j*k)

ans = (L/3)**3
print(ans)
# print("{:.10f}".format(ans))
# print(*ans)   # unpackして出力。間にスペースが入る
# for row in board:
#     print(*row,sep="")    #unpackして間にスペース入れずに出力する

Submission status: Accepted

Solution code:
L=int(input())
from decimal import *
a=Decimal(L/3)
print(a**3)

Submission status: Accepted

Solution code:
import sys
import math
import string
import fractions
import random
from operator import itemgetter
import itertools
from collections import deque
import copy
import heapq
from bisect import bisect, bisect_left, bisect_right

MOD = 10 ** 9 + 7
INF = float('inf')
input = lambda: sys.stdin.readline().strip()

sys.setrecursionlimit(10 ** 8)

L = int(input())
ans = 0
print((L/3)**3)

Submission status: Accepted

Solution code:
from decimal import *
L = int(input())
print(Decimal(L**3)/Decimal(27))

Submission status: Accepted

Solution code:
def main():
    L = int(input())
    ans = (L**3)/27
    print(ans)
if __name__ == "__main__":
    main()

Submission status: Accepted

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

L = int(input())

l = L / 3
print(L ** 3 / 27)

Submission status: Accepted

Solution code:
l=float(input())
print((((l/3)**3)*1000000)/1000000)

Submission status: Accepted

Solution code:
def main():
  s = float(input())
  print((s/3) *(s/3)*(s/3))
main()

Submission status: Accepted

Solution code:
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


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


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


def input(): return sys.stdin.readline().rstrip()


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


def print_matrix(mat):
    for i in range(len(mat)):
        print(*mat[i])


yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False
# show_flg = True


def main():
    L = I()

    # if L % 3 == 0:
    #     l = L // 3
    #     print(l**3)
    #     return


    l = L / 3
    # print(l)
    print(l**3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
L = int(input())
edge = L / 3
print(edge ** 3)

Submission status: Accepted

Solution code:
n= int(input())

x = n/3.0

print(x**3)

Submission status: Accepted

Solution code:
def inp():
    return input()
def iinp():
    return int(input())
def inps():
    return input().split()
def miinps():
    return map(int,input().split())
def linps():
    return list(input().split())
def lmiinps():
    return list(map(int,input().split()))
def lmiinpsf(n):
    return [list(map(int,input().split()))for _ in range(n)]

l = iinp()
ans = 0

k = (l/3)

ans = k**3

print(ans)

Submission status: Accepted

Solution code:
l = int(input())

n = l/3

print(n**3)

Submission status: Accepted

Solution code:
l=int(input())
print(round((l/3)**3,10))

Submission status: Accepted

Solution code:
N=int(input())

print(N**3/27)

Submission status: Accepted

Solution code:
i = int(input())
temp = i / 3
ans = temp* temp * temp
print(ans)

Submission status: Accepted

Solution code:
L = int(input())
l = L/3
result = pow(l, 3)
print(result)

Submission status: Accepted

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

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

    print((n/3)**3)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
l = input()
l = int(l)

r = (l/3) ** 3

print(r)

Submission status: Accepted

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



#print(divisors(l))
tmp = l/3
#print(l/3)
print(tmp**3)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(4100000)

import math

import logging

logging.basicConfig(level=logging.DEBUG)

logger = logging.getLogger(__name__)


def resolve():
    # S = [x for x in sys.stdin.readline().split()][0]  # 文字列 一つ
    L = [int(x) for x in sys.stdin.readline().split()][0]  # int 一つ
    # N, D = [int(x) for x in sys.stdin.readline().split()]  # 複数int
    # h_list = [int(x) for x in sys.stdin.readline().split()]  # 複数int

    # grid = [list(sys.stdin.readline().split()[0]) for _ in range(N)]  # 文字列grid
    # v_list = [int(sys.stdin.readline().split()[0]) for _ in range(N)]
    # grid = [[int(x) for x in sys.stdin.readline().split()]
    #         for _ in range(N)]  # int grid

    logger.debug('{}'.format([]))

    print((L / 3)**3)


if __name__ == "__main__":
    resolve()

# AtCoder Unit Test で自動生成できる, 最後のunittest.main は消す
# python -m unittest template/template.py で実行できる
# pypy3 -m unittest template/template.py で実行できる

import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """3"""
        output = """1.000000000000"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """999"""
        output = """36926037.000000000000"""
        self.assertIO(input, output)

Submission status: Accepted

Solution code:
from decimal import Decimal
L = Decimal(input())
L3 = L/3
print((L/3)**3)

Submission status: Accepted

Solution code:
def main():
    import sys
    L=int(sys.stdin.readline())
    print((L/3)**3)

main()

Submission status: Accepted

Solution code:
L = int(input())

l = L/3

print(l**3)

Submission status: Accepted

Solution code:
N = int(input())
print((N/3)**3, end='')

Submission status: Accepted

Solution code:
L = int(input())
l = L/3.0

print(pow(l, 3))

Submission status: Accepted

Solution code:
# coding: utf-8

import sys
import math
import collections
import itertools
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]

L = I()
print((L / 3)**3)

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    #s = input().rstrip().split(' ')
    L= int(input())
    print((L/3)*(L/3)*(L/3))

Submission status: Accepted

Solution code:
#!/usr/bin/python3
# -*- coding:utf-8 -*-

def main():
  l = int(input())
  print((l/3)**3)

if __name__=='__main__':
  main()

Submission status: Accepted

Solution code:
# the answer is always a cube. so calculate the volume of that cube.
total_length = float(input())
single_length = total_length/3
volume = single_length**3
print(volume)

Submission status: Accepted

Solution code:
l = float(input())

print(l**3/27)

Submission status: Accepted

Solution code:
l = int(input())
l /= 3
print(l*l*l)

Submission status: Accepted

Solution code:
l = int(input())
ans = l**3
print(ans/27)

Submission status: Accepted

Solution code:
L = int(input())
print("{:.12f}".format((L/3)**3))

Submission status: Accepted

Solution code:
L=int(input())

a=L/3

print(a**3)

Submission status: Accepted

Solution code:
L = int(input())

S = (L/3.0)**3

print(S)

Submission status: Accepted

Solution code:
L = int(input())
d = L / 3
print(d ** 3)

Submission status: Accepted

Solution code:
import sys


def input():
    return sys.stdin.readline()[:-1]

L = int(input())
ans = (L/3)**3
print(ans)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10000000)
INF = 1<<32


def solve(L: int):
    # ans = 0
    # for i in range(1, L, 1):
    #     for j in range(1, L-i, 1):
    #         k = L-i-j
    #         if k > 0:
    #             ans = max(ans, i*j*k)
    # print(ans)
    print((L/3)**3)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    L = int(next(tokens))  # type: int
    solve(L)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
L = int(input().strip())
print( (L/3)**3 )

Submission status: Accepted

Solution code:
if __name__ == "__main__":
    l = int(input())
    print((l/3)*(l/3)*(l/3))

Submission status: Accepted

Solution code:
l = int(input())
ans = (l/3)**3

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
l = int(input())

ans = pow(l / 3, 3)
print(ans)

Submission status: Accepted

Solution code:
num_inp = int(input())
dummy = num_inp / 3
amari = num_inp - dummy * 3
ans = dummy ** 2 * (dummy + amari)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#from scipy.special import comb
#from math import factorial

L = int(input())

print((L/3)**3)

Submission status: Accepted

Solution code:
l = int(input())

ans = (l / 3)**3
print(ans)

Submission status: Accepted

Solution code:
import sys
import numpy as np
input = sys.stdin.readline

def main():
    L = int(input())
    l = L / 3

    print(l*l*l)

main()

Submission status: Accepted

Solution code:
l = int(input())
ans = 0
s = l/3
print(s*s*s)

Submission status: Accepted

Solution code:
n  = [list(map(int, s.split())) for s in open(0)][0][0]
c = n / 3
print(c ** 3)

Submission status: Accepted

Solution code:
l = int(input())

x = l / 3.0
print(x * x * x)

Submission status: Accepted

Solution code:
L = int(input())

K = L / 3

print(K ** 3)

Submission status: Accepted

Solution code:
l = float(input())
print((float((l/3)**3)))

Submission status: Accepted

Solution code:
L = int(input())
ans = (L*L*L)/27
print(ans)

Submission status: Accepted

Solution code:
l = int(input())

d = l/3.0

print(d*d*d)

Submission status: Accepted

Solution code:
l = int(input())
m = l/3

ans = m ** 3
print(ans)

Submission status: Accepted

Solution code:
num = int(input())
print((num / 3) ** 3)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
L = int(input())

print((L / 3) ** 3)

Submission status: Accepted

Solution code:
from decimal import *
L = Decimal(input())
r = Decimal(L) / Decimal(3)
print(r**3)

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    l = int(input())
    print((l/3)**3)

Submission status: Accepted

Solution code:
L = int(input())

result = (L / 3.0) ** 3

print(result)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

L = int(input())

hen = Decimal(L / 3)

print(hen ** 3)

Submission status: Accepted

Solution code:
N = int(raw_input())

l = float(N)/3
print(l**3)

Submission status: Accepted

Solution code:
L = int(input())

n = L / 3.0

print(n**3)

Submission status: Accepted

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

l = int(input())
ans = (l / 3) ** 3
print(ans)

Submission status: Accepted

Solution code:
L=int(input())
print( L/3 * L/3 * L/3 )

Submission status: Accepted

Solution code:
import sys
import math
import 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
from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
from scipy.sparse import csr_matrix
import itertools
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

N = INT()
x = y = z = N / 3
print(x * y * z)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

a = l/3
b = l - 2 * a

print(a*a*b)

Submission status: Accepted

Solution code:
def main():
    L = int(input())
    x = pow((L/3), 3)
    return x
print(main())

Submission status: Accepted

Solution code:
l = int(input())
print((l / 3)**3)

Submission status: Accepted

Solution code:
L=int(input())

print((L/3)**3)

Submission status: Accepted

Solution code:
L = int(input())

ans = L * L * L / 3 / 3 / 3
print(ans)

Submission status: Accepted

Solution code:
import sys
import math
from functools import reduce
from operator import mul
sys.setrecursionlimit(10**6)

def InMap(): return list(map(int, sys.stdin.readline().split(' ')))
def In(): return int(sys.stdin.readline())
def InS(): return sys.stdin.readline()

L = In()
vol = L*L*L
print(vol/27)

Submission status: Accepted

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

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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import collections
import math
import operator as op
from functools import reduce
import numpy as np
import math
import bisect
import heapq


MOD = 1000000007


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a


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


def get_inputs(cast_func=None):
    if cast_func is None:
        return input().split()
    else:
        return list(map(cast_func, input().split()))


def get_input(cast_func=None):
    if cast_func is None:
        return input()
    else:
        return cast_func(input())


def is_prime(n):
    if n == 1:
        return False
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return False
    return True


def main():
    L = get_input(int)

    print(L**3 / 3**3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
L = int(input())

print((L ** 3) / 27)

Submission status: Accepted

Solution code:
l = int(input())
ans = 1
for i in range(3):
  ans = ans *(l/3)
print(ans)

Submission status: Accepted

Solution code:
l = int(input())

a,b,c = l/3,l/3,l/3

print(a*b*c)

Submission status: Accepted

Solution code:
l=int(input())
x=l**3
print('{0:.12f}'.format(x/27))

Submission status: Accepted

Solution code:
l=int(input())

an=l/3

print(an*an*an)