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:
import math

L = int(input())
a = L/3
print(pow(a, 3))

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

Solution code:
"""abc159_c"""
L = int(input())

l = float(L/3)

print(l**3)

Submission status: Accepted

Solution code:
l = int(input())

print((l / 3)**3)

Submission status: Accepted

Solution code:
import sys

def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())

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

Submission status: Accepted

Solution code:
L = int(input())

print(L**3 / 27)

Submission status: Accepted

Solution code:
L=int(input())

edge=L/3.0

volume=edge**3

print('{:.10f}'.format(volume))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
print(int(input())**3 / 27)

Submission status: Accepted

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

Submission status: Accepted

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

a = L / 3.0
print(pow(a,3))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

l = input()

t = Decimal(l) / Decimal("3")
v = t ** 3

print(v)

Submission status: Accepted

Solution code:
L = int(input())

a = L/3

ans = a**3

print(ans)

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

print((l / 3) ** 3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = float(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:
l = int(input())

print((l / 3)**3)

Submission status: Accepted

Solution code:
import itertools
import functools
import math
from collections import Counter
from itertools import combinations


L = int(input())

ans=(L/3)**3

print(ans)

Submission status: Accepted

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

edge = l/3

ans = edge**3

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

L=int(input())

num=L/3
print('{:.07f}'.format(num**3))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.read
def main():
    l = int(input())
    print((l/3)**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())
print(L*L*L/27)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = float(input())

len = l/3
vol = len*len*len

print(vol)

Submission status: Accepted

Solution code:
# C - Maximum Volume
L = int(input())
print((L/3)**3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

ans = 0
for i in range(l * 10 ** 3):
    s = ((l * 10 ** 3 - i) / 2) ** 2
    ans = max(ans, s * i / (10 ** 9))
print(ans)

Submission status: Accepted

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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#159
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())

x = L/3
y = L/3
z = L - x - y
print(x*y*z)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

print((l/3)** 3)

Submission status: Accepted

Solution code:
def actual(L):
    return (L / 3) ** 3

L = int(input())

print(actual(L))

Submission status: Accepted

Solution code:
l=int(input())
temp1=l/3
temp2=(l-l/3)/2
print(temp1*temp2*(l-temp1-temp2))

Submission status: Accepted

Solution code:
l = int(input())

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

Submission status: Accepted

Solution code:
L = int(input())

print((L**3)/27)

Submission status: Accepted

Solution code:
l = float(input())

print((l/3)**3)

Submission status: Accepted

Solution code:
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():
    n=INT()
    print(n**3/27)
    
if __name__ == '__main__':
    do()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

a = float(L/3)
b = float(L/3)
c = float(L / 3)

print(a * b * c)

Submission status: Accepted

Solution code:
l = int(input())
ll = l/3
lll = l - 2 * ll
print(ll*ll*lll)

Submission status: Accepted

Solution code:
l = int(input())

ans = float(l ** 3 / 27)

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = float(input())

print("{:.12f}".format((a/3)**3))

Submission status: Accepted

Solution code:
from decimal import Decimal

L = int(input())

w = Decimal(L / 3)
d = Decimal(L / 3)
h = Decimal(L / 3)

ans = Decimal(w * d * h)

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

a = L/3
m = a*a*a
print(m)

Submission status: Accepted

Solution code:
L = int(input())

r = L / 3

print(r * r * r)

Submission status: Accepted

Solution code:
L = int(input())

print(float(L*L*L)/27)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np
l = int(input())
print((l/3)**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

print((l**1/3)**3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

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

Submission status: Accepted

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


def solve(L: int):
    v = pow(L/3, 3)
    print(v)


# Generated by 1.1.7.1 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:
#C
l=int(input())
ans=(l**3)/27

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

print((L / 3) ** 3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = lambda: sys.stdin.readline().rstrip()

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    l = int(input())
    print('{:.32f}'.format((l * l * l) / 27))


if __name__ == '__main__':
    main()

Submission status: Accepted

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

if __name__=='__main__':
    main()

Submission status: Accepted

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

import sys
sys.setrecursionlimit(300000)


def solve(L: int):
    ret = (L / 3) ** 3
    print(ret)
    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 = float(input())
print((l/3)**3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import *
getcontext().prec = 28
n = Decimal(input())
print((n/Decimal(3.0))**Decimal(3))

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(4100000)
import math
INF = 10**9

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

    print((l/3)**3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
L = int(input())

L_3 = L / 3

print(L_3**3)

Submission status: Accepted

Solution code:
L=int(input())

print(L**3/27)

Submission status: Accepted

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

print(V)

Submission status: Accepted

Solution code:
L = int(input())
ans = 0
tmp = L / 3

print(tmp**3)

Submission status: Accepted

Solution code:
x=int(input())
a,b,c = x/3,x/3,x/3

print(a*b*c)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

Solution code:


def solve(L):
    print((L / 3) ** 3)


if __name__ == '__main__':
    L = int(input())
    solve(L)

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

l = int(read())
print((l/3)**3)

Submission status: Accepted

Solution code:
import math

l = float(input())/3
print(math.pow(l, 3))

Submission status: Accepted

Solution code:
l = int(input())

x = float(l / 3)

ans = float(x**3)
print(ans)

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())

l = l/3

print(l**3)

Submission status: Accepted

Solution code:
L = int(input())

tmp = L/3

print(tmp*tmp*tmp)

Submission status: Accepted

Solution code:
x = int(input())

print((x / 3) ** 3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

print(L*L*L/27)

Submission status: Accepted

Solution code:
l = int(input())

print((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())
a=L/3
if L%3==0:
    print((L//3)**3)
else:
    print(a**3)

Submission status: Accepted

Solution code:
l=int(input())
if l%3==0:
    k=l/3
    print(k**3)
else:
    n=l/3
    m=l-2*n
    print(n*n*m)

Submission status: Accepted

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

Submission status: Accepted

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

if b == 1:
    print((a+1/3)**3)
elif b==2:
    print((a+2/3)**3)
else:
    print(a**3)

Submission status: Accepted

Solution code:
import numpy as np
import scipy.sparse as sps
import scipy.misc as spm
import collections as col
import functools as func
import itertools as ite
import fractions as frac
import math as ma
import cmath as cma
import copy as cp
import sys
def sinput(): return sys.stdin.readline().strip()
def iinput(): return int(sinput())
def imap(): return map(int, sinput().split())
def fmap(): return map(float, sinput().split())
def iarr(n=0):
    if n: return [0 for _ in range(n)]
    else: return list(imap())
def farr(): return list(fmap())
def sarr(n=0):
    if n: return ["" for _ in range(n)]
    else: return sinput().split()
def barr(n): return [False for _ in range(n)]
sys.setrecursionlimit(10**7)
MOD = 10**9 + 7; EPS = sys.float_info.epsilon
PI = np.pi; EXP = np.e; INF = np.inf

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

Submission status: Accepted

Solution code:
# import sys
# import math
# import itertools
# from collections import deque
# from collections import defaultdict
# import heapq
# import copy
# import bisect
# import numpy as np
# from scipy.special import comb

# def my_input(): return sys.stdin.readline().rstrip()
# sys.setrecursionlimit(100000)
# INF = 1001001001001
# MOD = 1000000007

def main():

    L = int(input())

    print((L/3)**3)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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)**3
print(r)

Submission status: Accepted

Solution code:
# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product#accumulate, combinations, product
#import bisect# lower_bound etc
#import numpy as np
#from copy import deepcopy
#from collections import deque
def run():
    L = int(input())
    print((L/3) ** 3)
if __name__ == "__main__":
    run()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
"""
import random
import functools
import copy
import bisect
import array
import re
import collections
import heapq
import fractions
import itertools
import string
import math
from operator import itemgetter as ig
from bisect import bisect_left, bisect_right, insort_left, insort_right
from itertools import permutations, combinations, product, accumulate, groupby
from heapq import heappush, heappop
from collections import deque, defaultdict, Counter
import sys
sys.setrecursionlimit(10 ** 7)
# import numpy as np

inf = 10 ** 20
INF = float("INF")
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = dd + [(-1, 1), (1, 1), (1, -1), (-1, -1)]
ddn9 = ddn + [(0, 0)]
'''for dx, dy in dd:
        nx = j + dx; ny = i + dy
            if 0 <= nx < w and 0 <= ny < h:'''
"""

from collections import deque
import math
from collections import deque, defaultdict
import sys
sys.setrecursionlimit(10 ** 7)


def wi(): return list(map(int, sys.stdin.readline().split()))
# WideIntPoint


def wip(): return [int(x) - 1 for x in sys.stdin.readline().split()]


def ws(): return sys.stdin.readline().split()


def si(): return int(sys.stdin.readline())  # SingleInt


def ss(): return input()


def hi(n): return [si() for _ in range(n)]


def hs(n): return [ss() for _ in range(n)]  # HeightString


def s_list(): return list(input())


def mi(n): return [wi() for _ in range(n)]  # MatrixInt


def mip(n): return [wip() for _ in range(n)]


def ms(n): return [ws() for _ in range(n)]


def num_grid(n): return [[int(i) for i in sys.stdin.readline().split()[
    0]] for _ in range(n)]  # NumberGrid


def grid(n): return [s_list() for _ in range(n)]


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


def round_up(a, b):
    """ a/b の切り上げ """
    c = (a + b - 1) / b
    return c


def lcm(a, b):
    """a,bの最小公倍数"""
    return a * b // gcd(a, b)


def floor(a, b):
    """floor(a/b) 整数値を返す"""
    c = (a - a % b)/b
    return int(c)


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math as m

def main():
    L = int(input())
    print(m.pow(L/3, 3))

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def main():
    L = int(input())
    ans = '{:.010f}'.format(L*L*L/27)
    print(ans)

main()

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(res)

Submission status: Accepted

Solution code:
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
sys.setrecursionlimit(10**7)

def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())

def main():
    L = I()
    V = (L/3)**float(3.0)
    print("{:.12f}".format(V))

main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
print((float(input(""))/3)**3)

Submission status: Accepted

Solution code:
print(((1/3)*float(input("")))**3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

print(float((l ** 3)/27))

Submission status: Accepted

Solution code:
from sys import stdin, setrecursionlimit


def main():
    input = stdin.buffer.readline
    l = int(input())
    print((l / 3) ** 3)


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    l = int(input())
    x = (l/3)
    print(x**3)
    return

#Solve
if __name__ == "__main__":
    solve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# ABC159C
# 縦，横，高さの合計が len である直方体のうち，体積が最大のものの体積はいくつか
def f(len):
  print((len / 3) ** 3)

f(int(input()))

Submission status: Accepted

Solution code:
L = int(input())

print(L*L*L/27)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

L = ir()
answer = L ** 3 / 27
print(answer)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n=float(input())
v=[0]
print(n/3*n/3*n/3)

Submission status: Accepted

Solution code:
import sys
from io import StringIO
import unittest


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


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)


if __name__ == "__main__":
    # unittest.main()
    resolve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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


def solve(L: int):
    return (L / 3) ** 3


def main():
    L = int(sys.stdin.readline().strip())  # type: int
    print(solve(L))


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())

r = n/3
ans=r**3
print(ans)

Submission status: Accepted

Solution code:
def maxVolume(L):
    return (L/3) ** 3

L = int(input())
print(maxVolume(L))

Submission status: Accepted

Solution code:
L = int(input())

print((L / 3) ** 3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

L /= 3

print(L**3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))

L = ii()

print((L/3)**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#  =========     /\       /|    |====/|
#      |        /  \       |    |   / |
#      |       /____\      |    |  /  |
#      |      /      \     |    | /   |
#  ========= /        \  =====  |/====|  
#  code

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter
# a.sort(key=itemgetter(i)) # i番目要素でsort
from functools import lru_cache
# @lru_cache(maxsize=None)
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp():
    '''
    一つの整数
    '''
    return int(input())
def inpl():
    '''
    一行に複数の整数
    '''
    return list(map(int, input().split()))

l = inp()
print((l/3.0)**3)

Submission status: Accepted

Solution code:
s = int(input())

n = (s/3)

print(n*n*n)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# L = x + y + z
# S = x*y*z
#これをSが最大となるようにyとLの式で表すと
# S_max = 1/2 * (L - y) * y * 1/2 * (L - y) = 1/4 * (y**3 - 2*L*y**2 +L**2 * y)

L = int(input())
S_list = []
for y in range(L*10**3):
    y_cal = y / 10**3
    s  = 1/4 * (y_cal**3 - 2*L*y_cal**2 +L**2 * y_cal)
    S_list.append(s)

S_max = max(S_list)
print(S_max)

Submission status: Accepted

Solution code:
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())

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

Submission status: Accepted

Solution code:
import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def S(): return sys.stdin.readline().rstrip()
def LS(): return sys.stdin.readline().split()
def LS2(N): return [sys.stdin.readline().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)
#'0.01'や'1E1'などで指定、整数に戻すならintをかます
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**5+10)
#input = sys.stdin.readline
from bisect import bisect_left

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

Submission status: Accepted

Solution code:
l=int(input())
print(str(l*l*l/27)+"\n")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines


L = int(read())

print(pow((L/3),3))

Submission status: Accepted

Solution code:
l = int(input())

x = l/3

ans = x**3
print(str(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())
ll = float(l)
a=0
b=0
c=0

if(ll%3 == 0):
	a=ll/3
	b=ll/3
	c=ll/3
else:
	a=ll/3
	b=a
	c=ll-a-b

    
print(a*b*c)

Submission status: Accepted

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

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