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:
# Python3 code to Maximize volume of 
# cuboid with given sum of sides 

# Return the maximum volume. 
def maxvolume( s ): 

	# finding length 
	length = s / 3 
	s -= length 
	# finding breadth 
	breadth = s / 2
	# finding height 
	height = s - breadth 
	
	return length * breadth * height
	
# Driven Program 
s = int(input())
jj=maxvolume(s)
print ('%.15f'%jj) 

# This code is contributed by "Sharad_Bhardwaj".

Submission status: Accepted

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

L1 = L/3
L -= L1
L2 = L/2
L -= L2
print(L1*L2*L)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

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

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

l1 = L / 3
l2 = L / 3
l3 = L - l1 -l2

print(l1 * l2 * l3)

Submission status: Accepted

Solution code:
l = int(input())

def f(x,y):
    z = l-x-y
    if z<0 or z>l:
        print(x,y,z)
        return -1
    return x*y*z

def fp(x,y):
    dx = y*(l-x-y) - x*y
    dy = x*(l-x-y) - x*y
    return dx,dy

x = 1.0
y = 1.0
while True:
    dx,dy = fp(x,y)
    if abs(dx)<10**-6 and abs(dy)<10**-6:
        print(f(x,y))
        exit()

    x += dx * 10**-5
    y += dy * 10**-5

Submission status: Accepted

Solution code:
l = int(input())
# v = 0
# for i in range(1, l+1):
#     for j in range(1, l+1):
#         k = l - i - j
#         v = max(v, i*j*k)
# print(v)

print((l/3)**3)

Submission status: Accepted

Solution code:
l = int(input())

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

Submission status: Accepted

Solution code:
# cook your dish here
from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
from bisect import bisect_left

def L():
    return list(map(int, stdin.readline().split()))

def In():
    return map(int, stdin.readline().split())

def I():
    return int(stdin.readline())

P = 1000000007
l = I()
a = l/3
print('%.12f'%(a*a*a))

Submission status: Accepted

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


def solve(L: int):
    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 = float(input())

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

Submission status: Accepted

Solution code:
L = int(input())


def main(l):
    x = float(l / 3)

    return x ** 3


print(main(L))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np
import fractions
import decimal
from collections import deque

n=float(input())
a=n/3
b=n/3
c=n/3
# print(a,b,c)
print(a*b*c)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A=int(input())

print((A/3)**3)

Submission status: Accepted

Solution code:
def main():

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

a = L/3
b = L/3
c = L -a-b

print(a*b*c)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    l = int(input())
    mx = 0
    hen = l / 3
    print(hen**3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from sys import stdin

def main():

    input = stdin.readline

    L = int(input())

    ans = (L / 3) ** 3

    print(ans)

    
if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

ans = 0
i = 0
while i < l:
    if (l - i) % 2 == 0:
        a = (l - i) / 2
        b = (l - i) / 2
    else:
        a = ((l - i) / 2)
        b = (l - i) / 2
    ans = max(ans, a * b * i)
    i += 0.001

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
inputs = list(map(int, (input().split())))

n = inputs[0]

print((n/3)**3)

Submission status: Accepted

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

Submission status: Accepted

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

	ans = (L/3)**3

	print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

a = float(l/3)

print(a**3)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
from math import ceil

def main():
    s = int(input())
    length = s / 3; 
  
    s -= length; 
  
    breadth = s / 2; 
    height = s - breadth; 
    print(length*breadth*height)





# region fastio

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

Solution code:
import sys,math
sys.setrecursionlimit(10**9)
from collections import defaultdict
 
IA = lambda: map(int,input().split())
IAS= lambda: map(str,input().split())

n=int(input())
print("{:.12f}".format(pow(n,3)/27.0))

Submission status: Accepted

Solution code:
L=int(input())
#D = L//3
#Amari = L%3
#if Amari == 0:
#    print(D**3)
#elif Amari == 1:
#    print(D*D*(D+1))
#else:
#    print(D*(D+1)*(D+1))
print(L**3/27)

Submission status: Accepted

Solution code:
L=int(input())

x=L/3
y=x
z=L-x-y

print(x*y*z)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())
N_1 = round(N/3, 6)
N_2 = round(N/3, 6)
N_3 = round(N/3, 6)

if N_1+N_2+N_3!=N:
  N_3 += N-(N_1+N_2+N_3)
print(N_1*N_2*N_3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from fractions import Fraction
l = int(input())
a = (l/3)
print(a**3)

Submission status: Accepted

Solution code:
def solve(L):
    x = L/3.0
    print(x*x*x)

L = int(input())
solve(L)

Submission status: Accepted

Solution code:
L = int(input())
r = L/3
print(r**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**3)/27)

Submission status: Accepted

Solution code:
from decimal import *
getcontext().prec = 16

L = int(input())

dec_var = Decimal(L / 3)
print(Decimal(dec_var ** 3))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = float(input())

a = L/3

print("%.10f" % a**3)

Submission status: Accepted

Solution code:
from decimal import *
import math
getcontext().prec = 30
n = int(input())
nd = Decimal(n**1/3)
print(float(Decimal(nd**3)))

Submission status: Accepted

Solution code:
L = int(input())

print(L**3/27)

Submission status: Accepted

Solution code:
L = int(input())

a = float(L/3)

print(a**3)

Submission status: Accepted

Solution code:
L = int(input().strip())
#N, M = list(map(int, input().strip().split()))
v = L / 3
print(v**3)

Submission status: Accepted

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

import sys

sys.setrecursionlimit(10 ** 6)


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

main()

Submission status: Accepted

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

l = int(input())

print((l/3)**3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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


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


main()

Submission status: Accepted

Solution code:
import re
from decimal import Decimal, ROUND_DOWN

print((Decimal(input()) / 3) ** 3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
num = int(input())

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

Submission status: Accepted

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

    print((L/3)**3)

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import collections
import sys
import numpy as np
sys.setrecursionlimit(1000000000)
l = int(input())
ans1 = l/3
print(ans1**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = float(input())#整数L
print((l/3)**3.0)

Submission status: Accepted

Solution code:
def c():
    L = int(input())
    a, b = (L/3, L/3)
    c = L - (a + b)

    print(a * b * c)


##########
if __name__ == "__main__":
    c()

Submission status: Accepted

Solution code:
L = int(input())
l = L//3
'''
ans = (L//3)**3
if L % 3 == 0:
    print(ans)
    exit()j
elif L % 3 == 1:
    for i in range(1000001):
        for j in range(1000000-i):
            ans=max(ans,ans+l*l*(0.000001*()))
'''
print((L/3)*(L/3)*(L/3))

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

Solution code:
#


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
L = int(input())

L /= 3

print(L*L*L)

Submission status: Accepted

Solution code:


l = [0]

def format_input(filename = None):
	global l
	if filename == None:
		l = int(input())

	elif filename == '__random__':
		from random import randint as rng
		l = rng(1, 10**3)

def get_answer():
	answer = (l/3)**3
	return answer

if __name__ == '__main__':
	format_input()

	ans = get_answer()
	print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(raw_input())

print ((L/3.0)**3)

Submission status: Accepted

Solution code:
N = int(input())

n = N/3

print(n**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding:utf-8

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys
from math import ceil, floor, pow
from collections import deque, Counter, defaultdict
from fractions import gcd
input = lambda: sys.stdin.readline().rstrip()

def eprint(s):
    sys.stderr.write('DEBUG: {}'.format(s))
    return

def main():
    l = int(input())
    print(pow(l/3, 3))
    return

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# print('input >>')
L = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

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

s = l/3
result = s*s*s

print(result)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
import string


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor


# coordinates
dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]


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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# AtCoder Beginner Contest 159: C (2020/03/22)
L = int(input())
print(pow((L/3),3))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = float(input())

t = L / 3

print(pow(t, 3))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

ans = l**3 / 27

print('%6f'%ans)

Submission status: Accepted

Solution code:
import itertools,sys,collections,math,random,fractions,bisect;sys.setrecursionlimit(10**7)
sr = sys.stdin.readline; P = print; P2 = lambda x: print(*x, sep="\n")
def I(i=0): t = [int(x)-i for x in sr().split()];return t
def S(): t = sr().split(); return t if len(t) > 1 else t[0]
L1,L2,L3,L4, = [],[],[],[]

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

Submission status: Accepted

Solution code:
#!python3.4
# -*- coding: utf-8 -*-
# abc159/abc159_c
import sys

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    L = i2n()
    print(L * L * L / 27)
    return

main()

Submission status: Accepted

Solution code:
l = int(input())

a = l / 3

print(a ** 3)

Submission status: Accepted

Solution code:
import math

L = int(input())

x = math.floor(L/3*1e7)/1e7
print(x**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

L=Decimal(int(input()))
h=L/Decimal(3)
w=L/Decimal(3)
t=L/Decimal(3)

print(h*w*t)

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

#n = int(input())
#l = list(map(int, input().split()))

'''
A=[]
B=[]
for i in range():
    a, b = map(int, input().split())
    A.append(a)
    B.append(b)'''
#import copy

#import numpy as np

l=int(input())
if l%3==0:
    print((l//3)**3)
elif l%3==1:
    print((l/3)**3)
else:
    print((l/3)**3)

Submission status: Accepted

Solution code:
S = int(input())

print((S/3)**3)

Submission status: Accepted

Solution code:
l = int(input())

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

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
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 LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

def main():
	L = II()
	x = L/3
	y = L/3
	print(y*x*(L-x-y))




if __name__ == '__main__':
	main()

Submission status: Accepted

Solution code:
def calculate(N):
    print(N**3 / 27)

calculate(int(input()))

Submission status: Accepted

Solution code:
import numpy as np
L = int(input())
print(float(np.longdouble((L/3))**3))

Submission status: Accepted

Solution code:
L = int(input())

"""
max = 0
for a in range(L - 2 , 0, -1):
    for b in range(L - a, 0, -1):
        c = L - a - b
        if a * b * c > max:
            max = a * b * c
print(max)
"""

print((L/3) ** 3)

Submission status: Accepted

Solution code:
x = int(input())

y = x / 3

print(y**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

Submission status: Accepted

Solution code:
'''
.append(要素) リストに要素を追加
.extend(リスト) リストを連結する
.insert(場所,要素) 指定した場所に要素追加
del 配列名[場所]
-1で末尾で末尾から一つ前

sort()
sorted(reverse=true)

配列の初期化
配列名=[a]*n+[b]*m

Decimal()
'''

from sys import stdin
from itertools import accumulate, dropwhile, takewhile, groupby
import bisect
import copy
import math
from functools import reduce
from operator import mul
from collections import Counter


def ispalindrome(str): return 1 if str == str[::-1] else 0


n = float(stdin.readline().rstrip())


print((n/3)**3)

Submission status: Accepted

Solution code:
#-------------------------------------------------------------------
import sys
def p(*_a):
  _s=" ".join(map(str,_a))
  #print(_s)
  sys.stderr.write(_s+"\n")
#-------------------------------------------------------------------

L = int(input())		# 文字列の入力  abcdefg...

l = L/3

print(l**3)

Submission status: Accepted

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

import sys


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

# ----------------------------------------------------------------


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


main()

Submission status: Accepted

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

Submission status: Accepted

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

print(a**3)

Submission status: Accepted

Solution code:
l = int(input())

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

Submission status: Accepted

Solution code:
x = int(input())

res = (x/3)**3

print(res)

Submission status: Accepted

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

Submission status: Accepted

Solution code:


L = int(input())
x = L**3
# print(x)
print(x/27)
# print(x//27)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

# L = h + w + d

# answer = h * w * d

print((L/3)**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8

import sys
import math
import collections
import itertools
from inspect import currentframe
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 MI() : return map(int, input().split())
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)]
def chkprint(*args) : names = {id(v):k for k,v in currentframe().f_back.f_locals.items()}; print(', '.join(names.get(id(arg),'???')+' = '+repr(arg) for arg in args))


L = I()

ll = L/3

print(ll ** 3)

Submission status: Accepted

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

Submission status: Accepted

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

print(a*a*a)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

x = L/3
y = L/3
z = L/3

ans = x*y*z

print(ans)

Submission status: Accepted

Solution code:
L = int(input())

hen = L/3

print("{:.6f}".format(hen**3))

Submission status: Accepted

Solution code:
L = int(input())

print(pow(L / 3, 3))

Submission status: Accepted

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

L = int(input())

print('{:.9f}'.format((L/3)**3))

Submission status: Accepted

Solution code:
import sys

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

print((l**3)/27)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())
epsilon = 10*(10*-7)
if L%3==0:
    length = L/3
    vol = length**3
    print(vol)
else:
    length = L/3
    vol = length**3
    print(vol)

Submission status: Accepted

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

print(taiseki)

Submission status: Accepted

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

d = Decimal(L)
temp = d / Decimal(3)

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

l_3 = L / 3

# print(l_3)

print(l_3 ** 3)

Submission status: Accepted

Solution code:
l = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

from decimal import Decimal

L = float(input())

# taiseki = (L/3)**3
taiseki = Decimal(L/3)**3
print(taiseki)

Submission status: Accepted

Solution code:
from decimal import *
l = int(input())
a = Decimal(l/3)
volume = a**3
print("{:.12f}".format(volume))

Submission status: Accepted

Solution code:
def volume(l):
    return (l / 3) ** 3

if __name__ == "__main__":
    l = int(input())
    print(volume(l))

Submission status: Accepted

Solution code:
N = int(input())

M = N/3
print(M**3)

Submission status: Accepted

Solution code:
L=int(input())

x=L/3

print(x**3)

Submission status: Accepted

Solution code:
import math
import copy
from copy import deepcopy
import sys
import fractions
# import numpy as np
from functools import reduce
# import statistics
import decimal
import heapq
import collections
import itertools

sys.setrecursionlimit(100001)


# input = sys.stdin.readline
# sys.setrecursionlimit(10**6)

# ===FUNCTION===

def getInputInt():
    inputNum = int(input())
    return inputNum


def getInputListInt():
    outputData = []
    inputData = input().split()
    outputData = [int(n) for n in inputData]

    return outputData


def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)

    return outputDataList


def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)

    return outputDataList


# ===CODE===

s = float(input())

tmp = decimal.Decimal(s/3)
ans = decimal.Decimal(tmp) * decimal.Decimal(tmp) *decimal.Decimal(tmp)

print("{:.10f}".format(ans))

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

v = a * b * c
print(v)

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

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

print(l*l*l)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import *

L = Decimal(input())
side = (L / 3)

print(side**3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import *

L = int(input())

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

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

Submission status: Accepted

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

Submission status: Accepted

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys

L = int(input())

v=L*L*L/27.0

print(v)

Submission status: Accepted

Solution code:
n=input()
print n*n*n/(27.0)

Submission status: Accepted

Solution code:
l=float(input())
a=float(l/3.000000)
s=0.000000
s=a*a*a
print(s)

Submission status: Accepted

Solution code:
l = float(input())

hen = l/3

print(pow(hen, 3))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = float(input())

a = L / 3

print(a ** 3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n=int(input())
if 1:
    v=n-(n//3)*3
    a=(n//3)+v
    print(((n//3)+v/3)**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())

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

Submission status: Accepted

Solution code:
sm = input()
l = float(sm)/3
b = (sm - l) / 2
h =  sm - l - b
print l*b*h

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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