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:
# -*- coding: utf-8 -*-
"""
Created on Thu May  7 00:03:02 2020

@author: shinba
"""

L = int(input())

L = L/3

print(L**3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    L = int(input())  # 文字列または整数(一変数)

    print((L/3)**3)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(l ** 3)

Submission status: Accepted

Solution code:
L=int(input())
ans=0
for j in range(1,1000*L+1):
    i=j/1000
    ans=max(ans,i*i*(L-2*i))
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# C - Maximum Volume

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#3で割って3乗するだけ
L = int(input())
L /= 3
L **= 3
print(L)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

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:
l = int(input())

print(pow(l/3, 3))

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10 ** 6)
# input = sys.stdin.readline    ####
int1 = lambda x: int(x) - 1
def II(): return int(input())

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

def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

INF = float('inf')

def solve():
    l = II()

    print(1 / 27 * l ** 3)


if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from itertools import permutations, accumulate
from math import sqrt, ceil, floor
from bisect import bisect_left, bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
import sys
def I(): return int(input())  # '123' -> 123
def Is(): return map(int, input().split())  # '123 456' -> 123, 456
def LI(): return list(map(int, input().split()))  # '123 456' -> [123, 456]
def TI(): return tuple(map(int, input().split()))  # '123 456' -> (123, 456)
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()  # 'aa bb' -> 'aa','bb' or ['aa','bb']
def LS(): return list(input())  # 'abc123' -> ['a','b','c','1','2','3']
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(1000000)
MOD = 1000000007
INF = float('inf')

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

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_HALF_UP

l = int(input())

ans = Decimal(str((l/3)**3)).quantize(Decimal('0.0000001'), rounding=ROUND_HALF_UP)

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

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

V = x * y * z

print(V)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# Template 1.0
import sys, re
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

L = INT()

print(L**3/27)

Submission status: Accepted

Solution code:
import math
import queue
from collections import defaultdict
 
def readInt():
	return int(input())
def readInts():
	return list(map(int, input().split()))
def readChar():
	return input()
def readChars():
	return input().split()
def factorization(n):
	res = []
	if n%2==0:
		res.append(2)
	for i in range(3,math.floor(n//2)+1,2):
		if n%i==0:
			c = 0
			for j in res:
				if i%j==0:
					c=1
			if c==0:
				res.append(i)
	return res
def fact2(n):
	p = factorization(n)
	res = []
	for i in p:
		c=0
		z=n
		while 1:
			if z%i==0:
				c+=1
				z/=i
			else:
				break
		res.append([i,c])
	return res
def fact(n):#階乗
	ans = 1
	m=n
	for _i in range(n-1):
		ans*=m
		m-=1
	return ans
def comb(n,r):#コンビネーション
	if n<r:
		return 0
	l = min(r,n-r)
	m=n
	u=1
	for _i in range(l):
		u*=m
		m-=1
	return u//fact(l)
def printQueue(q):
	r=q
	ans=[0]*r.qsize()
	for i in range(r.qsize()-1,-1,-1):
		ans[i] = r.get()
	print(ans)

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from __future__ import print_function

from functools import reduce
from operator import mul
from collections import Counter
from collections import deque
from itertools import accumulate
from queue import Queue
from queue import PriorityQueue as pq
from heapq import heapreplace
from heapq import heapify
from heapq import heappushpop
from heapq import heappop
from heapq import heappush
import heapq
import time
import random
import bisect
import itertools
import collections
from fractions import Fraction
import fractions
import string
import math
import operator
import functools
import copy
import array
import re
import sys
sys.setrecursionlimit(500000)


input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return

# from fractions import gcd
# from math import gcd

# def lcm(n, m):
#     return int(n * m / gcd(n, m))


# def coprimize(p, q):
#     common = gcd(p, q)
#     return (p // common, q // common)


# def find_gcd(list_l):
#     x = reduce(gcd, list_l)
#     return x


def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


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


if __name__ == '__main__':
    main()

Submission status: Accepted

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


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

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

def test():
    import doctest
    doctest.testmod()

if __name__ == '__main__':
    #test()
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

print(round(float((float(l/3))**3),10))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a=int(input())
print('{:.6f}'.format(a*a*a/27))

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:
#########行列読み込み ##############################################
"""
from sys import stdin
n = int(stdin.readline().rstrip())
data = [stdin.readline().rstrip().split() for _ in range(n)]
print(data)
print(*data, sep='\n')
"""
##################################################################
#########入力系####################################################
"""
s =input()
s=list(input())
a=int(input())
x,y = map(int,input().split())	
li = input().split()	
li = list(map(int,input().split()))	
li = input().split('T')	
"""
##################################################################

#########行列読み込み ##############################################
"""
from sys import stdin
n = int(stdin.readline().rstrip())
data = [stdin.readline().rstrip().split() for _ in range(n)]
print(data)
print(*data, sep='\n')
"""
##################################################################
#########入力系####################################################
"""
s =input()
s=list(input())
a=int(input())
x,y = map(int,input().split())	
li = input().split()	
li = list(map(int,input().split()))	
li = input().split('T')	
"""
##################################################################
L = int(input())
leng = L/3
ans = pow(leng,3)
print(ans)

Submission status: Accepted

Solution code:
# https://atcoder.jp/contests/abc159/tasks/abc159_c

import math

L = int(input())

h = L / 3

print(h ** 3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**6) #再帰関数の上限
import math
from copy import copy, deepcopy
from operator import itemgetter

from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque 
#deque(l), pop(), append(x), popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意
#dequeを使うときはpython3を使う、pypyはダメ
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone

def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds

#mod = 10**9+7
#w.sort(key=itemgetter(1),reversed=True)  #二個目の要素で降順並び替え

L = int(input())
#N, K = map(int, input().split())
#L = [int(input()) for i in range(N)]
#A = list(map(int, input().split()))
#S = [list(map(int, input().split())) for i in range(N)]



print((L/3)**3)

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
class abc_159:
    
    def __init__(self):
        pass
    
    def A(self):
        NM=list(map(int,input().split()))
        print(int((NM[0]*(NM[0]-1))/2 + (NM[1]*(NM[1]-1))/2))
    
    def B(self):
        S=input()
        if S==S[::-1] and S[:int((len(S)-1)/2)]==S[:int((len(S)-1)/2):-1] and S[int((len(S)+3)/2)-1:len(S)]==S[int((len(S)+3)/2)-1:len(S)+1][::-1]:print("Yes")
        else:print("No")
        
    def C(self):
        # a+b+c=L abc=M として M=bc(L-b-c) のときのMの極値問題となるb=xとおくとM(x)=-cx^2-c^2x+Lcxの2次関数となる
        #この2次方程式の最大値を求める、まず微分してM'(x)=0を解きx=(L-c)/2を算出、次にM(x)にこれを代入しM((L-c)/2)=c^3-2Lc^2+L^2cの３次関数を作成
        #cをxと置いてM(x)=x^3-2Lx^2+L^2xの3次関数の極大値の内大きい方が答え
        
        L=int(input())
        A,B,C=0,0,0
        
        ans_list=self.f2_ans(3,-4*L,L*L,L)
        
        C = ans_list[0] if self.f3_sum(ans_list[0],L)>=self.f3_sum(ans_list[1],L) else ans_list[1]
        B = (L-C)/2
        A = L-B-C
        print(A*B*C)
            
    #２次関数解の公式       
    def f2_ans(self,a,b,c,L):
        ans_list=[]
        
        discrimination=b*b-4*a*c
        kai1=(-b+math.sqrt(discrimination))/(2*a)
        kai2=(-b-math.sqrt(discrimination))/(2*a)
        
        ans_list.append(kai1)
        ans_list.append(kai2)
        
        return ans_list
    
    def f3_sum(self,x,L):
        return (x*x*x)+(-2*L*x*x)+(L*L*x)
        
        
    def D(self):
        pass
    
    def E(self):
        pass
    
    def F(self):
        pass
    
    
if __name__=='__main__':
    obj=abc_159()
    obj.C()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

v = x**3
print(v)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:


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


def read_ints():
    return list(map(int, input().strip().split(' ')))


def solve():
    L = read_int()
    return (L/3)**3


if __name__ == '__main__':
    print(solve())

Submission status: Accepted

Solution code:
print((float(input()) / 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())

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

Submission status: Accepted

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

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

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


main()

Submission status: Accepted

Solution code:
L=int(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

print(l*l*l/27)

Submission status: Accepted

Solution code:
L = int(input())

hen = float(L/3)
volume = float(hen ** 3)
print(volume)

Submission status: Accepted

Solution code:
import sys

l = int(input())

a = b = c = l/3

v = a*b*c

print(v)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = float(input())

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

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)**3)

Submission status: Accepted

Solution code:
l = int(input())

a = l / 3

print(a**3)

Submission status: Accepted

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

Submission status: Accepted

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

y=l
z=(l-y)/2
x=l-y-z
ans=max(ans,x*y*z)

y=l/3
z=(l-y)/2
x=l-y-z
ans=max(ans,x*y*z)


print(ans)

Submission status: Accepted

Solution code:
l=int(input())

print((l/3)**3)

Submission status: Accepted

Solution code:
N = int(input())

print(N/3*N/3*N/3)

Submission status: Accepted

Solution code:
L = int(input())

"""
Z = 0

n = 100000
step = n*L
V_array = []

for i in range(step):
    Z += (1/n) * i
    V = (L-2*Z)*Z**2
    V_array.append(V)
    
V_max = max(V_array)
"""

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

print(format((L**3/27),'.20f'))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

 
print(x**2 *(L-2*x))

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
l = int(input())

n = l / 3

print(n * n * n)

Submission status: Accepted

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

print(ans)

Submission status: Accepted

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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = float(input())

print(n**3/27)

Submission status: Accepted

Solution code:
l=int(input())

a=float(l/3)

v=a**3

print(v)

Submission status: Accepted

Solution code:
l = int(input())

v = (l/3)**3

print(v)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print((L / 3) ** 3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = float(input())

print((l/3)**3)

Submission status: Accepted

Solution code:
s=int(input())

print((s/3)**3)

Submission status: Accepted

Solution code:
L = int(input())

print((L**3)/27)

Submission status: Accepted

Solution code:
import sys;input=lambda:sys.stdin.readline().rstrip();aint=lambda:int(input());ints=lambda:list(map(int,input().split()))
import math;floor,ceil=math.floor,math.ceil
from collections import deque
Yes=lambda b:print('Yes')if b else print('No');YES=lambda b:print('YES')if b else print('NO')
is_even=lambda x:True if x%2==0 else False

def main():
  l=aint();print(l**3/27)

if __name__ == '__main__':
  main()

Submission status: Accepted

Solution code:
def q3():
    L = int(input())
    l = L / 3
    print('{0:.6f}'.format(l**3))


if __name__ == '__main__':
    q3()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

print((L/3.0)**3)

Submission status: Accepted

Solution code:
L = int(input())

print((L/3) **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:
import sys
import numpy as np
# input処理を高速化する
input = sys.stdin.readline

L=int(input())

#forループではない
# div =0.001
# ranges =np.arange(0.001,L+1,0.01)
# V=0
# for x in ranges:
#     z=L-2*x
#     V=max(V,x*x*z)

# print(V)
#相加相乗平均を用いる
print((L/3)**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

hen = L / 3

print(hen**3)

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

x = (1/3) * L

ans = x**3

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

a = l/3
v = a*a*a

print(v)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

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

Submission status: Accepted

Solution code:
l = int(input())

print(pow(l / 3, 3))

Submission status: Accepted

Solution code:
#coding:utf-8

L = int(input())

ans = (L / 3) ** 3

print("{}".format(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = float(input().rstrip())
v = L / 3.0
print(v * v * v)

Submission status: Accepted

Solution code:
from sys import stdin
import math

L = int(input())

l = L / 3

print(l*l*l)

Submission status: Accepted

Solution code:
l=float(input())

print('{:.09f}'.format((l/3)*(l/3)*(l/3)))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")


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


def main():

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

vol=(l/3)**3

print('{:.9f}'.format(vol))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

print((l**3)/27)

Submission status: Accepted

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


if __name__ == '__main__':
    sol()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    l = int(rl())
    print((l / 3) ** 3)

    
if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
l=int(input())

print((l/3)**3)

Submission status: Accepted

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

L = int(input())

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

Submission status: Accepted

Solution code:
L=int(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

l = int(input())

print(math.pow(l/3, 3))

Submission status: Accepted

Solution code:
l = int(input())


v = 1/27 * l * l * l

print(v)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())

a = n * (1 / 3)


print(a ** 3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())

print((N / 3 )** 3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
'''
n, m = map(int, input().split())
n = int(input())
A = list(map(int, input().split()))
S = input().strip()
for test in range(int(input())):
'''
inf = 100000000000000000  # 1e17

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# solution

data = int(input())
print(data**3/27)

Submission status: Accepted

Solution code:
l = int(input())

print((l/3.0)**3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = int(input())

print(x**3/27)

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

Submission status: Accepted

Solution code:
L =float(input())

print((L/3)**3)

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(math.pow(n/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)**3
print(V)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

t = round(L/3, 9)
y = round(L/3, 9)
n = round(L/3, 9)

print(t * y * n)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a=int(input())

print((a/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/3
print(x*y*z)

Submission status: Accepted

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

print(ans)

Submission status: Accepted

Solution code:
# C - Maximum Volume
# https://atcoder.jp/contests/abc159/tasks/abc159_c

L = int(input())

center = (L/3)
pre = center - 0.1

follow = center + 0.1
# print(pre)
# print(center)
# print(follow)

print(center*center*center)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
l = int(input())
x = y = z = l/3.000000000
ans = x*y*z
print('{:.12f}'.format(ans))

Submission status: Accepted

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

print(l * l* l)

Submission status: Accepted

Solution code:
l = int(input())

ans = (l / 3) ** 3

print(ans)

Submission status: Accepted

Solution code:
from sys import stdin
import math

if __name__ == "__main__":
    _in = [_.rstrip() for _ in stdin.readlines()]
    L = int(_in[0])  # type:int
    # vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
    cnt = (L/3)**3
    # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    print(cnt)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

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

def main():
    print(pow(l / 3, 3))

if __name__ ==  '__main__':
    main()

Submission status: Accepted

Solution code:
L = int(input())

max_abc = L/3

print(max_abc ** 3)

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())
max_vol=L**3/27

print(max_vol)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
i = int(input())
c = i/3 + 0.0
v = c*c*c
print(v)

Submission status: Accepted

Solution code:
# coding: utf-8

L = int(input())

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

Submission status: Accepted

Solution code:
from collections import deque, Counter as cnt
from collections import defaultdict as dd
from operator import itemgetter as ig
from bisect import bisect_right as bsr
from math import factorial, ceil, floor
import sys
sys.setrecursionlimit(1000000)

# お約束
args = None
INF = float("inf")
MOD = int(1e9 + 7)


def input(*ps):
    if type(ps[0]) is list:
        return [input(*ps[0][:-1]) for _ in range(ps[0][-1])]
    elif len(ps) == 1:
        return ps[0](next(args))
    else:
        return [p(next(args)) for p in ps]


def nlist(n, v):
    if not n:
        return [] if type(v) is list else v
    return [nlist(n[1:], v) for _ in range(n[0])]


def yesno(v):
    print(["Yes", "No"][not v])


# エントリーポイント
def main():
    L = input(int)
    print(L / 3 * L / 3 * L / 3)


if __name__ == '__main__':
    args = iter(sys.stdin.read().split())
    main()

Submission status: Accepted

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