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
import re
import math
import itertools
from copy import deepcopy
import fractions
import random
from heapq import heappop,heappush
import time
import os
import sys
import datetime
from functools import lru_cache
readline=readline = sys.stdin.readline
sys.setrecursionlimit(2000)
#import numpy as np
alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
def yn(b):
    if b:
        print("yes")
    else:
        print("no")
def Yn(b):
    if b:
        print("Yes")
    else:
        print("No")
def YN(b):
    if b:
        print("YES")
    else:
        print("NO")
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def fac_list(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num
def get_primes(n,type="int"):
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    if(type=="bool"):return A
    B=[]
    for a in range(n+1):
        if(A[a]):B.append(a)
    return B
def is_prime(num):
    if(num<=2):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s


#@lru_cache(maxsize=None)  
def f():
    return 1
#main
L=int(input())
R=[]
print((L/3)**3)

Submission status: Accepted

Solution code:
from decimal import *

L = int(input())
a = Decimal(str(L)) / Decimal("3")
print(a * a * a)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys 
input = sys.stdin.readline
MOD = 10**9 +7
INF = 10**9
from bisect import bisect_right

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


if __name__=='__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# encoding:utf-8
import copy
import random
import bisect #bisect_left　これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections

mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

L = int(input())

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

Submission status: Accepted

Solution code:
l=int(input())
s=l/3
x=s
y=s
z=s
print(x*y*z)

Submission status: Accepted

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

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())
res = 0
print((L/3)**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
# from fractions import gcd
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 functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: map(int, INPUT().split())
S_MAP = lambda: map(str, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))
ZIP = lambda: zip(*(MAP() for _ in range(n)))

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


def main():
   L = INT()
   print((L/3) ** 3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def maxvolume( s ): 
  
    # finding length 
    length = s / 3 
      
    s -= length 
      
    # finding breadth 
    breadth = s / 2
      
    # finding height 
    height = s - breadth 
      
    return round(length * breadth * height,12)
      
# Driven Program 
s = int(input())
print( maxvolume(s) )

Submission status: Accepted

Solution code:
L=int(input())
h=L/3
print((h**3-2*L*h**2+h*L**2)/4)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#どっちで出すか注意, rstrip注意
#提出前に見返すこと！
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10000000)
    from collections import Counter, deque
    #from collections import defaultdict
    from itertools import combinations, permutations, accumulate
    #from itertools import product
    from bisect import bisect_left,bisect_right
    import heapq
    from math import floor, ceil
    #from operator import itemgetter

    #inf = 10**17
    #mod = 10**9 + 7

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 
#整数input
def ii(): return int(sys.stdin.readline().rstrip()) #int(input())
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) #list(map(int,input().split()))
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]
#文字列input
def ss(): return sys.stdin.readline().rstrip() #input()
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) #list(input().split())
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]

#本当に貪欲法か？ DP法では？？
#本当に貪欲法か？ DP法では？？
#本当に貪欲法か？ DP法では？？

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

Submission status: Accepted

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

print((L/3)**3)

Submission status: Accepted

Solution code:
import sys
input = lambda: sys.stdin.readline().rstrip()
input_nums = lambda: list(map(int, input().split()))

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from decimal import Decimal

L = Decimal(int(input()))

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

Submission status: Accepted

Solution code:
from sys import stdin
def main():
    readline=stdin.readline
    L=int(readline())
    print((L/3)**3)
if __name__=="__main__":
    main()

Submission status: Accepted

Solution code:
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
    L = ir()
    print((L/3)**3)
resolve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# vim:fenc=utf-8 ff=unix


def solv(L):
    e = L / 3.0
    return e*e*e


if __name__ == "__main__":

    L = int(input())
    ans = solv(L)

    print(ans)

Submission status: Accepted

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

import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

N = INT()

ans = pow(N/3, 3)
print(ans)

Submission status: Accepted

Solution code:


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


submit()

Submission status: Accepted

Solution code:
L = int(input())

print((L**3) / 27)

Submission status: Accepted

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

L = int(input())

print(pow(L/3,3))

Submission status: Accepted

Solution code:
import fractions
L = int(input())
a = fractions.Fraction(L, 3)
ans = float(a ** 3)
print(ans)

Submission status: Accepted

Solution code:
import sys,math,copy,queue,itertools
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
def LI(): return [int(x) for x in input().split()]
INF = 10**18
MOD = 10**9 + 7
DD = ((1,0),(0,1),(-1,0),(0,-1))
L = int(input())
ans = (L/3) ** 3
print (ans)

Submission status: Accepted

Solution code:
import sys
import math
import collections
from collections import deque
l = int(input())
#n, m = map(int, sys.stdin.readline().split())
#s = input()
#x = list(map(int, sys.stdin.readline().split()))

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')

#solve
def solve():
    l = II()
    print((l / 3) ** 3)
    return


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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

ans = (L/3)**3

print(ans)

Submission status: Accepted

Solution code:
def solve():
    L = int(input())
    print(pow(L/3,3))
if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
from decimal import Decimal

l = Decimal(input())

print((l/3) ** 3)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [input() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [int(input()) for i in range(n)]


class Math():
    @staticmethod
    def gcd(a, b):
        if b == 0:
            return a
        return Math.gcd(b, a % b)

    @staticmethod
    def lcm(a, b):
        return (a * b) // Math.gcd(a, b)

    @staticmethod
    def divisor(n):
        res = []
        i = 1
        for i in range(1, int(n ** 0.5) + 1):
            if n % i == 0:
                res.append(i)
                if i != n // i:
                    res.append(n // i)
        return res

    @staticmethod
    def round_up(a, b):
        return -(-a // b)

    @staticmethod
    def is_prime(n):
        if n < 2:
            return False
        if n == 2:
            return True
        if n % 2 == 0:
            return False
        d = int(n ** 0.5) + 1
        for i in range(3, d + 1, 2):
            if n % i == 0:
                return False
        return True


class PriorityQueue:
    def __init__(self, l=[]):
        self.q = l
        heapq.heapify(self.q)
        return

    def push(self, n):
        heapq.heappush(self.q, n)
        return

    def pop(self):
        return heapq.heappop(self.q)


def pop_count(x):
    x = x - ((x >> 1) & 0x5555555555555555)
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
    x = x + (x >> 8)
    x = x + (x >> 16)
    x = x + (x >> 32)
    return x & 0x0000007f


MOD = int(1e09) + 7
INF = int(1e15)


def main():
    # sys.stdin = open("sample.txt")
    L = Scanner.int()
    print((L / 3) ** 3)


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())
ans = (n ** 3)/27
print('{:.12f}'.format(ans))

Submission status: Accepted

Solution code:
def resolve():
    L = int(input())
    a = L/3.0
    print(a*a*a)

if __name__ == "__main__":
    resolve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = int(input())

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

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







print((l/3)**3)

Submission status: Accepted

Solution code:
def solve():
    N = int(input())
    return pow(N/3, 3)

print(solve())

Submission status: Accepted

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

Submission status: Accepted

Solution code:

L = int(input())

print((L/3)**3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
l = int(input())
best = 0
for c in range(l * 1000):
    c /= 1000
    best = max(best, c * ((l - c) / 2) ** 2)
print(best)

Submission status: Accepted

Solution code:
def main():
    #from sys import stdin, setrecursionlimit
    #setrecursionlimit(10**9)
    #r = input()
    #n = int(input())
    #a, b = map(int, input().split())
    #s, y = input().split()
    #a = input().split()
    #a = list(map(int, input().split()))
    #a = [list(input().split()) for i in range(n)]
    #a = [int(input()) for i in range(n)]
    #a = [list(map(int, input().split())) for i in range(n)]
    #a = [int(s) - 1 for s in input().split()]
    #l=[int(input()) for _ in range(int(input()))]
    #res = 0
    l=int(input())
    print((l/3)**3)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from collections import defaultdict
from collections import deque
from string import ascii_uppercase
import sys, bisect, math, heapq

stdin = sys.stdin
read_int = lambda : list(map(int,stdin.readline().split()))
read_str = lambda : stdin.readline().rstrip()

L = read_int()[0]

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import itertools
import sys
import math
import numpy as np
from collections import deque
from itertools import combinations
from functools import reduce
from functools import lru_cache
sys.setrecursionlimit(10**9)

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


if __name__ == "__main__":
  main()

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

e = L / 3

print(e*e*e)

Submission status: Accepted

Solution code:
L =  int(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:
#!python3

iim = lambda: map(int, input().rstrip().split())

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

if __name__ == "__main__":
    resolve()

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l=int(input())

print(pow(l/3, 3))

Submission status: Accepted

Solution code:
n = int(input())

print((n / 3) ** 3)

Submission status: Accepted

Solution code:
import sys

l = int(sys.stdin.readline().strip())
print (l**3 / 27.0)

Submission status: Accepted

Solution code:
L = int(input())
l = L / 3.
print('{:.6f}'.format(pow(l, 3)))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

    print((l/3)**3)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l=int(input())

s=(l/3)**3

print("%.12f"%s)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

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

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

if __name__ == "__main__":
    ans = main()
    print(ans)

Submission status: Accepted

Solution code:
n = int(input())

print ((n / 3.0)**3)

Submission status: Accepted

Solution code:
def c_maximum_volume():
    L = int(input())
    return round((L / 3)**3, 10)

print(c_maximum_volume())

Submission status: Accepted

Solution code:
l = int(input())

# ans = 0
# for i in range(1, 999):
#     for j in range(1, 999):
#         k = l - i - j
#         if 1 <= k <= 1000:
#             ans = max(ans, i*j*k)

# print(ans)

x = l/3
print(x**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
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 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 = float('inf')
mod = 10 ** 9 + 7

L = INT()

# for a in range(L):
#     for b in range():
a = L / 3
bc = L - a
b = bc / 2
c = bc - b
print(a * b * c)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = int(input())

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

Submission status: Accepted

Solution code:
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  l=I()

  a=l/3
  return a**3

# main()
print(main())

Submission status: Accepted

Solution code:
if __name__ == '__main__':

    l = int(input())
    a, b, c = 0, 0, 0

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(1000000000)
import math
from fractions import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    # 10**6
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     # 10**6
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp

#

class UnionFindEx:
    def __init__(self, size):
        #正なら根の番号、負ならグループサイズ
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   #負なら根
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    #サイズ更新
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'

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



main()

Submission status: Accepted

Solution code:
L=int(input())
A=L/3
B=L-(2*A)
ans=A*B*B
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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


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())
s = L / 3
print(s ** 3)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
L = float(input())
print((L/3)**3)

Submission status: Accepted

Solution code:
l = int(input())
ans = 0
s = l/3
q = l/3
r = l - (s + q)
print(s*q*r)

Submission status: Accepted

Solution code:
L = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = float(input())

print((l/3.)**3)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L=int(input())

print((L/3.0)**3)

Submission status: Accepted

Solution code:
n = int(input())
a = (float(n)/3)**3
print('{:.12f}'.format(a))

Submission status: Accepted

Solution code:
#abc159 c

import itertools
from math import factorial
import sys
import heapq
from collections import Counter
from collections import deque
from fractions import gcd
from functools import reduce

sys.setrecursionlimit(4100000)
INF = 1 << 60
MOD = 10 ** 9 + 7

#ここから書き始める
l = float(input())
a1 = a2 = a3 = l / 3
print(a1 * a2 * a3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L = int(input())

print((L / 3.0) ** 3)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import math

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

length = l / 3

print(length ** 3)

Submission status: Accepted

Solution code:
def read():
    L = float(input())
    return L,

def solve(L):
    a = pow(L / 3, 3)
    return '{:.10f}'.format(a)


if __name__ == '__main__':
    inputs = read()
    print("{}".format(solve(*inputs)))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
inxx = input()
inxx = inxx.split()

x = int(inxx[0])

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

Submission status: Accepted

Solution code:
# L: 正の整数
# w, h, l が全部同じであれば良い
L = float(input())

print((L/3.0)**3)

Submission status: Accepted

Solution code:
import sys
import itertools
if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
L=int(input())

print((L/3)**3)

Submission status: Accepted

Solution code:
n = int(input())

if n % 3 == 0:
    print((n//3)**3)
else:
    a = n/3
    b = n/3
    c = n - a - b
    print(a * b * c)

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
s = int(input())
print( maxvolume(s) )

Submission status: Accepted

Solution code:
#n, m = list(map(int,input().split()))

l = int(input())

print(pow(l/3,3))

Submission status: Accepted

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

Submission status: Accepted

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

L = int(input())

print((L/3)**3)

Submission status: Accepted

Solution code:
def ans(s):
    length = s / 3

    s -= length

    breadth = s / 2
    height = s - breadth

    return length * breadth * height

l = int(input())

x = ans(l)

print('%.12f' % x)

Submission status: Accepted

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

out = (l ** 3) / 27.
print(out)

Submission status: Accepted

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

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

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

Submission status: Accepted

Solution code:
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

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

Submission status: Accepted

Solution code:
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left #bisect_left(list, value)
#from fractions import gcd
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input():
    return sys.stdin.readline()[:-1]
def pri(x):
    if type(x) is list:
        print('\n'.join(map(str, x)))
    else:
        print(x)

L = int(input())

res = pow(L, 3)/27

print(res)