Go: package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"strconv"
	"strings"
)

var sc = bufio.NewScanner(os.Stdin)

//Sliceconvtof ...
func Sliceconvtof() []float64 {
	strs := strings.Split(sc.Text(), " ")

	var flts []float64
	var x int

	for _, s := range strs {
		x, _ = strconv.Atoi(s)
		xf := float64(x)
		flts = append(flts, xf)
	}

	return flts
}

//ThirdRoot .
func ThirdRoot(f float64) float64 {
	xn := f / 2
	var dmt float64

	for {
		dmt = math.Pow(xn, 3) - f
		if math.Abs(dmt) < 0.00001*f {
			break
		}

		xn = xn - (dmt / (3 * math.Pow(xn, 2)))
	}

	return xn
}

func main() {

	for sc.Scan() {
		i := Sliceconvtof()
		if i[0] == -1.0 {
			break
		}
		fmt.Printf("%6f\n", ThirdRoot(i[0]))
	}

}

Python: while True:
    q=int(input())
    if q==-1:
        break
    x=q/2
    a=0.00001*q
    while abs(x**3-q)>=a:
        s=x*x
        t=s*x-q
        x-=t/(3*s)
    print(f"{x:.6f}")

Python: for e in iter(input,'-1'):
 q=float(e)
 x=q/2
 while abs(x**3-q)>=q*1e-5:x-=(x**3-q)/(3*x*x)
 print(x)

Python: def solve(q):
    x = q / 2.0
    while abs(x**3 - q)/q >= 1e-5:
        x1 = x - (x**3 - q)/3/x**2
        x = x1
    return(x)

while True:
    q = int(input().strip())
    if q==-1:
        break
    print("%.6f" % solve(q))

Python: while True:
  q = int(input())
  if q == -1:
    break
  d = 0.00001* q
  x = q / 2
  while(abs(q - x ** 3) >= d):
    x = x - (x ** 3 - q) / (3 * (x ** 2))
  print(x)

Python: import sys
f = sys.stdin

while True:
    q = int(f.readline())
    if q == -1:
        break
    x = q / 2
    while abs(x ** 3 - q) >= 0.00001 * q:
        x = x - (x ** 3 - q) / (3 * x ** 2)
    print('{:.6f}'.format(x))

Python: while True:
  q = int(input())
  if q == -1:
    break
  x = q / 2
  end = q * 10 ** -5
  while abs(x ** 3 - q) >= end:
    x = (2 * x ** 3 + q) / (3 * x ** 2)
  print(f'{x:.6f}')

Python: while 1:
    q=float(input())
    if q<0:break
    print(q**(1/3))


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

Python: while True:
    q=int(input())
    if q==-1:
        break
    x=q/2
    while abs(x**3-q)>=0.00001*q:
        x=x-(x**3-q)/(3*x**2)
    print(f'{x:.6f}')

Python: while True:
    q=int(input())
    if q==-1:
        break
    x=q/2
    while abs(x**3-q)>=0.00001*q:
        x=x-((x**3-q)/(3*(x**2)))
    print("{:.6f}".format(x))

Python: while True:
    q=int(input())
    
    if q==-1:
        break
    
    x=q/2
    while True:
        x=x-(x**3-q)/(3*x**2)
        
        if abs(x**3-q)<0.00001*q:
            break
    
    print(x)

Python: def cubeRoot(q):
    x = q / 2
    while abs(x ** 3 - q) >= (0.00001 * q):
        x = (2 * x ** 3 + q) / (3 * x ** 2)
    return x
    
while True:
  q = int(input())
  if q == -1:
    break
  print(cubeRoot(q))

Python: def calc_third_root(q):
    x = q / 2
    while not (abs(x ** 3 - q) < 0.00001 * q):
        x = x - (x ** 3 - q) / (3.0 * x ** 2)
    return x

while 1:
    q = int(input())
    if q == -1:
        break
    result = calc_third_root(q)
    print("{:.6f}".format(result))

Python: #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
                        unicode_literals)
from sys import stdin

for line in stdin:
    q = int(line)
    if q == -1:
        break

    x = q / 2.0
    diff = q * 0.00001
    while True:
        x = x - (x**3 - q) / (3 * x * x)
        if abs(x**3 - q) < diff:
            break
    print('{:.6f}'.format(x))

Python: # Aizu Problem 0080: Third Root
#
import sys, math, os

# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
    sys.stdin = open("sample-input.txt", "rt")


def third_root(q):
    x = q / 2
    while abs(x**3 - q) > 1e-5:
        x = x - (x**3 - q) / (3 * x**2)
    return x


for line in sys.stdin:
    n = int(line)
    if n == -1:
        break
    print("%.6f" % third_root(n))

Python: for e in iter(input,'-1'):
 q=float(input())
 x=q/2
 while abs(x**3-q)-q*1e-5:x-=(x**3-q)/(3*x*x)
 print(x)

Python: # coding: utf-8
# Your code here!

while True:
    q = int(input())
    if q < 1:
        break
    
    x = q / 2
    y = 0.00001 * q
    while True:
        x2 = x * x
        r = x2 * x - q
        if -y < r < y:
            break
        x = x - r / (3 * x2)
    print(x)

Python: while True:
  q = int(input())
  if q == -1:
    break
  x = q / 2
  end = q * 10 ** -5
  while abs(x ** 3 - q) >= end:
    x = (2 * x ** 3 + q) / (3 * x ** 2)
  print(f'{x:.6f}')

Python: def rec(x1,q):
    return x1-((x1**3-q)/(3*(x1**2)))

q = []
while True:
    try:
        tmp = int(input())
        if tmp == -1:
            break
        q.append(tmp)
    except EOFError:
        break
for i in range(len(q)):
    x1 = float(q[i]/2)
    for j in range(50000):
        x1 = rec(x1,q[i])
    print(x1)

Python: # coding: utf-8
# 84

while True:
    q = int(input())
    if q==-1:
        break
    x = q/2
    while abs(x**3-q)>=0.00001*q:
        x = x-(x**3-q)/(3*x**2)
    print(f'{x:6f}')

Python: for e in iter(input,'-1'):
 q=float(e)
 x=q/2
 while abs(x**3-q)-q*1e-5:x-=(x**3-q)/(3*x*x)
 print(x)

Python: while True:
    q = int(input())
    if q == -1:
        break
    x = q / 2
    ep = 0.00001 * q
    
    while True:
        x2 = x * x
        t = x2 * x - q
        if -ep < t < ep:
            break
        x = x - t / (3 * x2)
    print("%.06f" %x)

Python: import math

while 1:
    q = int(input())
    if q == -1:
        break
    
    x = q/2
    while 1:
        if abs(x*x*x - q) < (0.00001*q):
            break
        x -= (x*x*x - q) / (3*x*x)
  
    print( '{:.6f}'.format(x))

Python: def thirdRoot(xn, q):
    ans = xn - (x**3 - q)/(3 * (xn**2))
    return ans


while True:
    q = int(input())
    if q == -1:
        break

    x = q/2
    while abs(x**3 - q) >=0.00001*q:
        x = thirdRoot(x, q)

    print(x)

Python: import sys

for q in map(int, sys.stdin):
    if q == -1:
        break

    ok, ng = 1, q
    while ng-ok > 0.000001:
        mid = (ok+ng)/2
        if mid**3 > q:
            ng = mid
        else:
            ok = mid
    print(ok)

Python: while True:
  n=int(input())
  if n==-1:
    break
  print(n**(1/3))

Python: while True:
  q = int(input())
  if q == -1:
    break
  x = q/2
  while abs(x**3-q) >= 0.00001*q:
    x = x - (x**3-q)/(3*x**2)
  print(x)

Python: 
while True:
	q = int(input())
	if q < 1: break
	
	x = q / 2
	err = 0.00001*q
	while True:
		x2 = x * x
		t = x2 * x - q
		if -err < t < err: break
		x = x - t / (3 * x2)
	print(x)

Python: # Aizu Problem 0080: Third Root
#
import sys, math, os

# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
    sys.stdin = open("sample-input.txt", "rt")


for line in sys.stdin:
    n = int(line)
    if n == -1:
        break
    print("%.6f" % (pow(n, 1. / 3)))

Python: while True:
    q = int(input())
    if q < 0:
        break
    ep = q / 1e5
    x = q/2
    while True:
        x = x - (x**3-q)/(3*(x**2))
        
        if abs(x**3 -q) < ep:
            break
    
    print("{:.6f}".format(x))