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:
x=int(input())
x=x/3
x=x*x*x
print("%0.9f"%x)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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


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


if __name__ == '__main__':
    solve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
    return list(map(int,input().split()))
def m(): #複数文字
    return map(int,input().split())
def onem(): #Nとかの取得
    return int(input())
def s(x): #圧縮
    a = []
    if len(x) == 0:
        return []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): #listをスペースごとに分ける
    return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
    return max(map(max,x))
def In(x,a): #aがリスト(sorted)
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False
"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""

n = onem()
print((n/3)**3)

Submission status: Accepted

Solution code:
l=int(input())

print(l*l*l/27)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(1000000)

# INF = float('inf')
INF = int(1e10)

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

def main():
    from builtins import int, map
    L = int(input())
    print("{:.10f}".format((L / 3) ** 3))


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(raw_input())

x = L/3.0
y = L/3.0
z = L/3.0

print x*y*z

Submission status: Accepted

Solution code:
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:
l=int(input())
m=l/3




print(m*m*m)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# import sys
# import math
# import decimal
# import queue
# import bisect
# import heapq # priolity-queue
# import time
# import itertools
# import collections # queue
# from operator import itemgetter
# from fractions import Fraction

mod = int(1e9+7)
INF = 1<<29
lINF = 1<<35

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

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 = 0
# for i in range(1,L-1):
#     for j in range(1,L):
#         mm = L-i-j
#         ans = max(i*j*mm,ans)
#         # print(i,j,ans)
# print(ans)


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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
stdin = sys.stdin

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

L = ni()

print((L**3)/27)

Submission status: Accepted

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

Submission status: Accepted

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def input_int():
    return map(int, input().split())

def one_int():
    return int(input())

def one_str():
    return input()

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

import math

L = one_int()

print((L/3)**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# ABC159c


def main():
    import sys
    import math
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)
    # 再帰関数を使わない限りPypyで出すこと

    def dump(*args):
        sys.stderr.write(str(args))
    l = int(input())
    print((l/3)**3)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

L /= 3
print(L**3)

Submission status: Accepted

Solution code:

L = int(input())

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

Submission status: Accepted

Solution code:
import sys
import itertools
input = sys.stdin.readline
sys.setrecursionlimit(100000)
mod = 10 ** 9 + 7

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


class v:
    def __init__(self, f):
        self.f = f
        self.v = None
 
    def __str__(self):
        return str(self.v)
 
    def ud(self, n):
        if self.v is None:
            self.v = n
        else:
            self.v = self.f(self.v, n) 


def f(S):
    for s, t in zip(S, S[::-1]):
        if s != t:
            return False
    return True

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
v = float(input())/3

print("%.9lf" % (v**3))

Submission status: Accepted

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

l1 = l / 3

print(l1 ** 3)

Submission status: Accepted

Solution code:

from sys import stdin
import sys
sys.setrecursionlimit(10**8)

def getInputs():
	inputs=[]
	for line in stdin:
		line=line.split()
		inputs.append(line)
	return inputs


def main(inputs):
	L=int(inputs[0][0])
	print(L**3/27)
# 	print((L/3)**3)
	

if __name__=="__main__":
	inputs=getInputs()
# 	inputs=simInputs()
	main(inputs)

Submission status: Accepted

Solution code:
def main():
    l = int(input())
    a = l / 3

    print(a**3)
if __name__=='__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l=int(input())

ll=l*(1/3)

print(ll**3)

Submission status: Accepted

Solution code:
""" My template """
# x0,y0,ax,ay,bx,by = list(map(int,input().split()))
# xs,ys,t = list(map(int,input().split()))
# V = []
# for i in range(61):
#     V.append([x0,y0])
#     x0=ax*x0+bx;y0=ay*y0+by;
# A=0
# for i in range(61):
#     for j in range(i,61):
#         ans=min(abs(xs-V[i][0])+abs(ys-V[i][1]),abs(xs-V[j][0])+abs(ys-V[j][1]))
#         for k in range(i,j):
#             ans=ans+abs(V[k+1][0]-V[k][0])+abs(V[k+1][1]-V[k][1])
#         if ans<=t:
#             A=max(A,j-i+1);
# print(A)

# def f(s):
#     s = str(s)
#     ans = 0
#     for i in s:
#         ans += int(i)
#     return ans

# s = input()
# x = int(s)
# ans = f(x)
# n = len(s)

# for i in s:
#     t = int(i)

# TC = int(input())
# for _ in range(TC):
#     n, m = list(map(int, input().split()))
#     print(2**(n*m)*(3**(n+m)))

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

Submission status: Accepted

Solution code:
import math
n=int(input())
t=n/3
print(math.pow(t,3))

Submission status: Accepted

Solution code:
l = int(input())

f = (l/3)**3

print(f)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10 ** 7)

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

L = float(input())

a = L / 3.

ans = a * a * a
print(ans)

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

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


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


# 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:
def main():
    L = int(input())
    ans = L**3 / 27
    print(ans)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# import bisect
# from collections import Counter, deque
# import copy
# from heapq import heappush, heappop, heapify
# from fractions import gcd
# import itertools
# from operator import attrgetter, itemgetter
# import math

import sys

# import numpy as np

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    l = float(input())
    ll = l/3

    print(pow(ll,3))


if __name__ == '__main__':
    main()

Submission status: Accepted

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


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

print(pow(L/3,3))

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

Solution code:
# coding: utf-8


def solve(*args: str) -> str:
    l = int(args[0])

    return str((l/3)**3)


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

Submission status: Accepted

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


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def main():

    L = int(input())
    return (L/3) *(L/3) * (L/3)
if __name__ == '__main__':
    print(main())

Submission status: Accepted

Solution code:
# coding: utf-8

L = int(input())

print(pow(L/3, 3))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from math import *
l=int(input())
k=3*(log10(l)-log10(3))
print(pow(10,k))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def inpl():
    return list(map(int, input().split()))


L = int(input())

print(L**3 / 27)

Submission status: Accepted

Solution code:
import sys


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


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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys


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


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

Submission status: Accepted

Solution code:
n = int(input())

ans = n*n*n

print("{:.7f}".format(ans/27))

Submission status: Accepted

Solution code:
l = int(input())

tmp = l / 3

print(tmp ** 3)

Submission status: Accepted

Solution code:
l = int(input())

ans = (l/3)**3


print(ans)

Submission status: Accepted

Solution code:
import sys
l=int(sys.stdin.readline())
s=l/3
ans=s*s*s
print(ans)

Submission status: Accepted

Solution code:
import sys
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

L = int(read())
print(pow(L, 3) / 27)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = float(input())

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

Submission status: Accepted

Solution code:
#coding:utf-8
import sys,os
from collections import defaultdict, deque
from fractions import gcd
from math import ceil, floor
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
    input = lambda: given().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    XLMIIS = lambda x: [LMIIS() for _ in range(x)]
    YN = lambda c : print('Yes') if c else print('No')
    MOD = 10**9+7

    L = II()
    assert((L/3)*3 == L)
    print((L/3)**3)

    

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
"""
NTC here
"""
import sys
inp = sys.stdin.readline


def input(): return inp().strip()


flush = sys.stdout.flush
# import threading
# sys.setrecursionlimit(10**6)
# threading.stack_size(2**25)


def iin(): return int(input())


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

# range = xrange
# input = raw_input


def main():
    l = iin()
    a = l/3
    print(pow(a, 3))
main()
# threading.Thread(target=main).start()

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

def solve():
    input = sys.stdin.readline
    L = int(input())
    print((L / 3) ** 3)

    return 0

if __name__ == "__main__":
    solve()

Submission status: Accepted

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

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

    print(L**3 / 27)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
L = int(input())

if L%3 == 0:
    print((L//3)**3)
else:
    print((L/3)**3)

Submission status: Accepted

Solution code:
from decimal import *

l = Decimal(input())
h = l/Decimal(3)
ans = h**Decimal(3)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(L):
    n = L / 3
    return n ** 3


def main():
    L = read_int()
    print(slv(L))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math
from collections import deque
def main():
    L = int(input())
    L = L/3.0

    print(math.pow(L,3))


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import unittest


class TestC(unittest.TestCase):
    def test_1(self):
        self.assertEqual(think(3), 1.0)

    def test_2(self):
        self.assertEqual(think(999), 36926037.0)


def solve():
    L = read()
    result = think(L)
    write(result)


def read():
    return read_int(1)[0]


def read_int(n):
    return read_type(int, n, sep=' ')


def read_float(n):
    return read_type(float, n, sep=' ')


def read_type(t, n, sep):
    return list(map(lambda x: t(x), read_line().split(sep)))[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(L):
    edge = L / 3
    return edge ** 3


def write(result):
    print(result)


if __name__ == '__main__':
    # unittest.main()
    solve()

Submission status: Accepted

Solution code:
''' بِسْمِ اللَّهِ الرَّحْمَٰنِ الرَّحِيمِ '''
#codeforces
gi = lambda : list(map(int,input().split()))
n, = gi()
print((n / 3) ** 3)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
from operator import itemgetter
sys.setrecursionlimit(10000000)
INF = 10**30

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
    if row <= 0:
        return [[] for _ in range(col)]
    elif col == 1:
        return [I() for _ in range(row)]
    else:
        read_all = [LI() for _ in range(row)]
        return map(list, zip(*read_all))

#################

L = I()

print(L**3/27)

Submission status: Accepted

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


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

main()

Submission status: Accepted

Solution code:
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
from re import split
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce
from copy import deepcopy
import re

sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7


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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
# coding: utf-8
import sys
sys.setrecursionlimit(10000000)

#const
dxdy=((1,0),(0,1))
# my functions here!
def pin(type=int):
    return map(type,input().rstrip().split())

def resolve():
    N,=pin()
    print(pow(N,3)/27)
"""         
#printデバッグ消した？
#前の問題の結果見てないのに次の問題に行くの？
"""
"""
お前カッコ閉じるの忘れてるだろ
"""
if __name__=="__main__":resolve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#300
L = float(input())
l = L / 3
V = l ** 3
print(V)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import math
import bisect

def solve(n):
    return (n/3) ** 3

def main():
    n = int(input())
    ans = solve(n)
    print('%.12f' % ans)

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

print(L**3/27)

Submission status: Accepted

Solution code:
H = int(input())

def func(H):
    h = H/3.0
    ans = h*h*h
    return ans

print(func(H))

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

Solution code:



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

    print((L/3)**3)




if __name__ == "__main__":
    resolve()

Submission status: Accepted

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


if __name__ == '__main__':
    resolve()

Submission status: Accepted

Solution code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    L = I()
    l3 = L / 3
    print(l3 ** 3)
    

main()

Submission status: Accepted

Solution code:
# coding: utf-8

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

print ((L/3) ** 3)

Submission status: Accepted

Solution code:
#gcdは3.4.3だとfractionsにある
from fractions import gcd
import math

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

yes = "Yes"
no = "No"

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


main()

Submission status: Accepted

Solution code:
import sys
from collections import *
import heapq
import math
import bisect
from itertools import permutations,accumulate,combinations,product
from fractions import gcd
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]

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

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


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

    print((L / 3) ** 3)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python
# coding: utf-8

def ri():
    return int(input())

def rl():
    return list(input().split())

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

def main():
    l = ri()
    print((l*l*l)/27)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
L = int(input())

print (L**3 / 27)

Submission status: Accepted

Solution code:
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
from fractions import gcd
from copy import deepcopy
import math
import queue
import numpy as np
#import sympy as syp(素因数分解とか)
Mod = 1000000007
import sys
sys.setrecursionlimit(100000) 
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

def main(): #startline-------------------------------------------
    l = int(input())
    print((l/3)**3)
if __name__ == "__main__":
    main() #endline===============================================

Submission status: Accepted

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

Submission status: Accepted

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


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

Submission status: Accepted

Solution code:
N = float(input())

print ((N/3)**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n=int(input())

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#create date: 2020-03-22 21:08

import sys
stdin = sys.stdin

def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))

def main():
    l = ni()
    print("{:.10f}".format((l/3)**3))

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from math import *

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

Submission status: Accepted

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

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

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

Submission status: Accepted

Solution code:
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = [int(i) for i in input().split()][0]
print(L/3*L/3*L/3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import *

getcontext().prec = 99


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

    ans = Decimal(L / 3) ** 3

    print(ans)


resolve()

Submission status: Accepted

Solution code:
l = int(input())

print((l ** 3) / 27)

Submission status: Accepted

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