AtCoder Beginner Contest 159 - Maximum Volume

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

-----Sample Output-----
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.

Difficulty: EASY

Starter code:

Solutions:
A = int(input()) / 3
print(A * A * A)


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


print(pow(int(input()) / 3, 3))


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


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


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


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


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


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


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


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


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


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


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


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


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


l = float(input())
print(l * l * l / 27)


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


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


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


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


import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7

def resolve():
	l = int(input())
	res = pow(l / 3, 3)
	print(res)

def __starting_point():
	resolve()
__starting_point()


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


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


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


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


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


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


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


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


import sys
sys.setrecursionlimit(10 ** 8)
ini = lambda : int(sys.stdin.readline())
inl = lambda : [int(x) for x in sys.stdin.readline().split()]
ins = lambda : sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print('\x1b[33m', *a, '\x1b[0m', **dict(file=sys.stderr, **kw))

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


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


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


l = int(input())
print(str(l * l * l / 27))


import os, sys, re, math
L = int(input())
print((L / 3) ** 3)


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


n = int(input())
x = n / 3
y = n / 3
z = n - x - y
print(x * y * z)


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


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


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


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


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


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


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


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


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


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


L = float(input())
print(pow(L / 3, 3))


S = int(input())
A = S / 3
print(A ** 3)


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


k = float(input())
volume = k / 3 * (k / 3) * (k / 3)
print(volume)


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


n = float(input())
print((n / 3.0) ** 3)


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


l = float(input())
print(l ** 3 / 27.0)


N = int(input())
print(N * N * N / 27)


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


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


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


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


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


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


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


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


import sys
L = int(sys.stdin.readline())
print(L ** 3 / 27)


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


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


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


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


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


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


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


no = int(input())
print(pow(no / 3, 3))


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


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


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


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


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


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


L = int(input())
x = L / 3.0
z = L - 2.0 * x
print(x * x * z)


print(pow(int(input()), 3) / 27)


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


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


x = int(input())
print(pow(x / 3, 3))


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


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


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


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


s = float(input())
print(pow(s / 3, 3))


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


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


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


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


s = int(input())
b = s / 3
print(b ** 3)


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


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


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


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


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, bisect
from operator import itemgetter
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
stdin = sys.stdin
ni = lambda : int(ns())
nf = lambda : float(ns())
na = lambda : list(map(int, stdin.readline().split()))
nb = lambda : list(map(float, stdin.readline().split()))
ns = lambda : stdin.readline().rstrip()
L = ni()
print((L / 3) ** 3)


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


a = int(input())
print(a * a * a / 27)


num = int(input())
number = num / 3
print(number * number * number)


L = int(input())
L = L / 3
V = 1
for i in range(3):
	V *= L
print(V)


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


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


a = int(input())
b = a / 3
sub = b ** 3
print(sub)


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


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


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

def __starting_point():
	print(main())
__starting_point()


l = int(input()) / 3
print('{:.9}'.format(l ** 3))


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


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


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


def i_input():
	return int(input())

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

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

def i_row(N):
	return [int(input()) for _ in range(N)]

def i_row_list(N):
	return [list(map(int, input().split())) for _ in range(N)]
l = i_input()
print((l / 3) ** 3)


l = int(input())
print(pow(l / 3, 3))


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


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


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


l = int(input())
a = l / 3
l = l - a
b = l / 2
c = l - b
print(a * b * c)


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


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


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


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


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


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


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


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


n = float(input())
print(n ** 3 / 27)


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


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


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


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


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


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


from math import *
l = int(input())
print((l / 3) ** 3)


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


print(pow(float(input()) / 3, 3))


import math
import sys

class Graph:

	def __init__(self, Nodes, is_directed=False):
		self.nodes = Nodes
		self.adj_list = {}
		self.is_directed = is_directed
		for node in self.nodes:
			self.adj_list[node] = []

	def add_edge(self, u, v):
		self.adj_list[u].append(v)
		if self.is_directed == False:
			self.adj_list[v].append(u)

	def print_graph(self):
		for node in self.nodes:
			print((node, '->', self.adj_list[node]))

	def degree_node(self, node):
		return len(self.adj_list[node])

	def dfsUTIL(self, v, visited, parents=[]):
		visited[v] = True
		for i in self.adj_list[v]:
			if visited[i] == False:
				self.dfsUTIL(i, visited, parents)
				parents.append(i)

	def dfs(self, v):
		visited = [False] * (max(self.adj_list) + 1)
		parents = [v]
		self.dfsUTIL(v, visited, parents)
		return len(parents)

def dict_sort(ans):
	ans = sorted(list(ans.items()), reverse=True, key=lambda kv: kv[1])

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

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def seive_primes(n):
	flag = [0] * (n + 10)
	flag[1] = flag[0] = 1
	i = 2
	while i * i <= n + 1:
		if flag[i] == 0:
			j = i * i
			while j <= n + 1:
				flag[j] = 1
				j += i
		i += 1
	return flag

def factors(n):
	d = {}
	while n % 2 == 0:
		if 2 in d:
			d[2] += 1
		else:
			d[2] = 1
		n /= 2
	for i in range(3, int(n ** 0.5) + 1, 2):
		while n % i == 0:
			if i in d:
				d[i] += 1
			else:
				d[i] = 1
			n /= i
	n = int(n)
	if n > 1:
		d[n] = 1
	return d

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

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

def alphabates():
	return 'abcdefghijklmnopqrstuvwxyz'

def binary_search(ls, n, flag):
	low = 0
	hi = n - 1
	while low <= hi:
		mid = (low + hi) // 2
		if ls[mid] == flag:
			return mid
		elif ls[mid] > flag:
			hi = mid - 1
		else:
			low = mid + 1
	return -1

def qdrt(a, b, c):
	chk = b * b - 4 * a * c
	if chk >= 0:
		ans1 = (-b + chk ** 0.5) / (2 * a)
		ans2 = (-b - chk ** 0.5) / (2 * a)
		return [int(ans1), int(ans2)]
	return -1

def permutation(n, r):
	if n < r:
		return 0
	ans = 1
	for i in range(n - r + 1, n + 1):
		ans *= i
	return ans

def combination(n, r):
	if n < r:
		return 0
	ans = 1
	for i in range(r):
		ans *= n - i
	div = 1
	for i in range(2, r + 1):
		div *= i
	return ans // div

def arinp():
	ls = list(map(int, input().split()))
	return ls

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

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

def __starting_point():
	main()
__starting_point()


def answer(l: int) -> float:
	return pow(l / 3, 3)

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

def __starting_point():
	main()
__starting_point()


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


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


import sys
import math
from collections import defaultdict, deque, Counter
from copy import deepcopy
from bisect import bisect, bisect_right, bisect_left
from heapq import heapify, heappop, heappush
input = sys.stdin.readline

def RD():
	return input().rstrip()

def F():
	return float(input().rstrip())

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

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

def MF():
	return map(float, input().split())

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

def TI():
	return tuple(map(int, input().split()))

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

def Init(H, W, num):
	return [[num for i in range(W)] for j in range(H)]

def main():
	L = I()
	print(pow(L / 3, 3))

def __starting_point():
	main()
__starting_point()


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


l = int(input())
e = l / 3
print('{:.10}'.format(e ** 3))


s = int(input())
print(s * s * s / 27)


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


l = int(input(''))
v = l * l * l
d = int(v / 27)
print(v % 27 / 27 + d)