Integer roots: Difference between revisions
m
syntax highlighting fixup automation
m (→{{header|F#}}: fix heading, as suggested on the Count examples/Full list/Tier 4 talk page) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 22:
{{trans|D}}
<
I b < 2 {R b}
V n1 = n - 1
Line 39:
print(‘3rd root of 8 = ’iRoot(8, 3))
print(‘3rd root of 9 = ’iRoot(9, 3))
print(‘First 2001 digits of the square root of 2: ’iRoot(BigInt(100) ^ 2000 * 2, 2))</
{{out}}
Line 52:
{{trans|D}}
<
if b<2 -> return b
Line 72:
print ["3rd root of 8:" iroot 8 3]
print ["3rd root of 9:" iroot 9 3]
print ["First 2001 digits of the square root of 2:" iroot (100^2000)*2 2]</
{{out}}
Line 82:
=={{header|BASIC256}}==
{{trans|FreeBASIC}}
<
for nr = floor(sqr(x)) to 1 step -1
if (nr ^ n) <= x then return nr
Line 92:
print root(4, 167)
print root(2, 2e18)
end</
{{out}}
<pre>
Line 101:
=={{header|C}}==
{{trans|C++}}
<
#include <math.h>
Line 137:
return 0;
}</
{{out}}
<pre>3rd root of 8 = 2
Line 145:
=={{header|C sharp|C#}}==
{{trans|Java}}
<
using System.Numerics;
Line 180:
}
}
}</
{{out}}
<pre>3rd integer root of 8 = 2
Line 187:
=={{header|C++}}==
<
#include <math.h>
Line 221:
return 0;
}</
{{out}}
<pre>3rd root of 8 = 2
Line 229:
=={{header|D}}==
{{trans|Kotlin}}
<
import std.stdio;
Line 258:
b = BigInt(100)^^2000*2;
writeln("First 2001 digits of the square root of 2: ", b.iRoot(2));
}</
{{out}}
<pre>3rd root of 8 = 2
Line 266:
=={{header|Elixir}}==
{{trans|Ruby}}
<
def root(_, b) when b<2, do: b
def root(a, b) do
Line 291:
end
Integer_roots.task</
{{out}}
Line 303:
=={{header|F_Sharp|F#}}==
{{trans|C#}}
<
let iroot (base_ : bigint) n =
Line 333:
Console.WriteLine("First 2001 digits of the sqaure root of 2: {0}", (iroot b 2))
0 // return an integer exit code</
{{out}}
<pre>3rd integer root of 8 = 2
Line 341:
=={{header|Factor}}==
{{trans|Sidef}}
<
prettyprint sequences ;
Line 357:
"First 2,001 digits of the square root of two:" print
2 100 2000 ^ 2 * root .</
{{out}}
<pre>
Line 367:
=={{header|FreeBASIC}}==
{{trans|Ring}}
<
Function root(n As Uinteger, x As Uinteger) As Uinteger
Line 380:
Print root(2, 2e18)
Sleep</
{{out}}
<pre>2
Line 390:
=={{header|Go}}==
===int===
<
import "fmt"
Line 421:
r += Δr
}
}</
{{out}}
<pre>
Line 429:
</pre>
===big.Int===
<
import (
Line 466:
r.Add(r, &Δr)
}
}</
{{out}}
<pre>
Line 477:
=={{header|Haskell}}==
{{trans|Python}}
<
root a b = findAns $ iterate (\x -> (a1 * x + b `div` (x ^ a1)) `div` a) 1
where
Line 489:
print $ root 3 8
print $ root 3 9
print $ root 2 (2 * 100 ^ 2000) -- first 2001 digits of the square root of 2</
Or equivalently, in terms of an applicative expression:
<
integerRoot n x =
go $ iterate ((`div` n) . ((+) . (pn *) <*> (x `div`) . (^ pn))) 1
Line 503:
main :: IO ()
main = mapM_ (print . uncurry integerRoot) [(3, 8), (3, 9), (2, 2 * 100 ^ 2000)]</
{{out}}
Line 517:
For example, If you use "3 <.@%: (2*10x^2*200'''0''')" instead of "3 <.@%: (2*10x^2*200'''1''')", you will get an output starting with "271441761659490657151808946...", which are the first digits of the cube root of 20, not 2.
<
2 <.@%: (2*10x^2*2000)
Line 526:
114869835499703500679862694677792758944385088909779750551371111849360320625351305681147311301150847391457571782825280872990018972855371267615994917020637676959403854539263226492033301322122190625130645468320078386350285806907949085127708283982797043969640382563667945344431106523789654147255972578315704103326302050272017414235255993151553782375173884359786924137881735354092890268530342009402133755822717151679559278360263800840317501093689917495888199116488588871447782240220513546797235647742625493141141704109917646404017146978939243424915943739448283626010758721504375406023613552985026793701507511351368254645700768390780390334017990233124030682358360249760098999315658413563173197024899154512108923313999675829872581317721346549115423634135836394159076400636688679216398175376716152621781331348
7 <.@%: (2*10x^2*2002)
1104089513673812337649505387623344721325326600780124165514532464142106322880380980716598289886302005146897159065579931253969214680430855796510648058388081961639198643922155838145512343974763395078906646859029211806139421440562835192195007740110439139292223389537903767320705032063903809884944457070845279252405827307254864679671836816589429995916822424590361601902611505690284386526869351720866524568004847701822070064334667580822044823960984514550922242408608825451442062850448298384317793721518676765230683406727811327252052334859250776811047221310365241746671294399050316</
=={{header|Java}}==
{{trans|Kotlin}}
<
public class IntegerRoots {
Line 568:
System.out.println(iRoot(b, 2));
}
}</
{{out}}
<pre>3rd integer root of 8 = 2
Line 578:
'''Works with gojq, the Go implementation of jq'''
<
def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);
Line 604:
# The task:
"First 2,001 digits of the square root of two:",
iroot(2; 2 * (100 | power(2000)))</
{{out}}
Exactly as for [[#Julia|Julia]].
Line 613:
{{trans|Python}}
<
b < 2 && return b
a1, c = a - 1, 1
Line 625:
end
println("First 2,001 digits of the square root of two:\n", iroot(2, 2 * big(100) ^ 2000))</
{{out}}
Line 633:
=={{header|Kotlin}}==
{{trans|Python}}
<
import java.math.BigInteger
Line 667:
println("First 2001 digits of the square root of 2:")
println(b.iRoot(2))
}</
{{out}}
Line 681:
=={{header|Lua}}==
{{trans|C}}
<
if base < 2 then return base end
if n == 0 then return 1 end
Line 707:
print("3rd root of 8 = " .. root(8, 3))
print("3rd root of 9 = " .. root(9, 3))
print("2nd root of " .. b .. " = " .. root(b, 2))</
{{out}}
<pre>3rd root of 8 = 2
Line 714:
=={{header|Modula-2}}==
<
FROM FormatString IMPORT FormatString;
FROM Terminal IMPORT WriteString,ReadChar;
Line 774:
ReadChar
END IntegerRoot.</
=={{header|Nim}}==
{{trans|Kotlin}}
{{libheader|bignum}}
<
proc root(x: Int; n: int): Int =
Line 802:
echo "First 2001 digits of the square root of 2:"
let s = $x.root(2)
for i in countup(0, s.high, 87): echo s.substr(i, i + 86)</
{{out}}
Line 833:
=={{header|PARI/GP}}==
<
sqrtnint(9,3)
sqrtnint(2*100^2000,2)</
{{out}}
<pre>%1 = 2
Line 843:
=={{header|Perl}}==
{{trans|Ruby}}
<
sub integer_root {
Line 859:
print integer_root( 3, 8), "\n";
print integer_root( 3, 9), "\n";
print integer_root( 2, 2 * 100 ** 2000), "\n";</
{{out}}
<pre>2
Line 867:
===Using a module===
If using bigints, we can do this directly, which will be much faster than the method above:
<
print 8->babs->broot(3),"\n";
print 9->babs->broot(3),"\n";
print +(2*100**2000)->babs->broot(2),"\n";</
The <code>babs</code> calls are only necessary if the input might be non-negative.
Even faster, using a module:
<
use ntheory "rootint";
print rootint(8,3),"\n";
print rootint(9,3),"\n";
print rootint(2*100**2000,2),"\n";</
Both generate the same output as above.
Line 885:
=={{header|Phix}}==
{{libheader|Phix/mpfr}}
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
Line 906:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"First digits of the cube root of 2: %s\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)})</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span>
<!--</
{{out}}
<pre>
Line 918:
=={{header|Python}}==
<
if b < 2:
return b
Line 932:
print("First 2,001 digits of the square root of two:\n{}".format(
root(2, 2 * 100 ** 2000)
))</
{{out}}
Line 940:
=={{header|Quackery}}==
{{trans|Python}}
<
[ stack ] is b ( --> s )
Line 962:
say "3rd root of 9 = " 9 3 root echo cr
say "First 2001 digits of the square root of 2: "
2 100 2000 ** * 2 root echo cr</
{{out}}
Line 978:
(formerly Perl 6)
{{trans|Python}}
<syntaxhighlight lang="raku"
my Int $d = $p - 1;
my $guess = 10**($n.chars div $p);
Line 987:
}
say integer_root( 2, 2 * 100 ** 2000 );</
{{out}}
<pre>141421356237309504880168872420969807856967187537694807317667973799073247846210703885038753432764157273501384623091229702492483605585073721264412149709993583141322266592750559275579995050115278206057147010955997160597027453459686201472851741864088919860955232923048430871432145083976260362799525140798968725339654633180882964062061525835239505474575028775996172983557522033753185701135437460340849884716038689997069900481503054402779031645424782306849293691862158057846311159666871301301561856898723723528850926486124949771542183342042856860601468247207714358548741556570696776537202264854470158588016207584749226572260020855844665214583988939443709265918003113882464681570826301005948587040031864803421948972782906410450726368813137398552561173220402450912277002269411275736272804957381089675040183698683684507257993647290607629969413804756548237289971803268024744206292691248590521810044598421505911202494413417285314781058036033710773091828693147101711116839165817268894197587165821521282295184884720896946338628915628827659526351405422676532396946175112916024087155101351504553812875600526314680171274026539694702403005174953188629256313851881634780015693691768818523786840522878376293892143006558695686859645951555016447245098368960368873231143894155766510408839142923381132060524336294853170499157717562285497414389991880217624309652065642118273167262575395947172559346372386322614827426222086711558395999265211762526989175409881593486400834570851814722318142040704265090565323333984364578657967965192672923998753666172159825788602633636178274959942194037777536814262177387991945513972312740668983299898953867288228563786977496625199665835257761989393228453447356947949629521688914854925389047558288345260965240965428893945386466257449275563819644103169798330618520193793849400571563337205480685405758679996701213722394758214263065851322174088323829472876173936474678374319600015921888073478576172522118674904249773669292073110963697216089337086611567345853348332952546758516447107578486024636008
Line 999:
<br>multiply the guess ['''G'''] by unity, and no need to compute the guess to the 1<sup>st</sup> power, bypassing some trivial arithmetic).
===integer result only===
<
parse arg num root digs . /*obtain the optional arguments from CL*/
if num=='' | num=="," then num= 2 /*Not specified? Then use the default.*/
Line 1,021:
if m==1 then do until old==g; old=g; g=(g + z % g ) % root; end
else do until old==g; old=g; g=(g*m + z % (g**m) ) % root; end
return left(g,p) /*return the Nth root of Z to invoker.*/</
'''output''' when the defaults are being used:
<pre>
Line 1,044:
===true results===
<br>Negative and complex roots are supported. The expressed root may have a decimal point.
<
parse arg num root digs . /*obtain the optional arguments from CL*/
if num=='' | num=="," then num= 2 /*Not specified? Then use the default.*/
Line 1,078:
numeric digits od /*set numeric digits to the original.*/
if oy<0 then return (1/_)i /*Is the root negative? Use reciprocal*/
return (_/1)i /*return the Yth root of X to invoker.*/</
'''output''' when the defaults are being used:
<pre>
Line 1,118:
=={{header|Ring}}==
<
# Project : Integer roots
Line 1,132:
ok
next
</syntaxhighlight>
Output:
<pre>
Line 1,142:
=={{header|Ruby}}==
{{trans|Python, zkl}}
<
return b if b<2
a1, c = a-1, 1
Line 1,154:
puts "First 2,001 digits of the square root of two:"
puts root(2, 2*100**2000)
</syntaxhighlight>
{{out}}<pre>First 2,001 digits of the square root of two:
14142135623730950488016887242096(...)46758516447107578486024636008</pre>
Line 1,160:
=={{header|Rust}}==
The rug crate provides the functionality required for this task.
<
// rug = "1.9"
Line 1,190:
let s = Integer::from(x.root(3)).to_string();
println!("First {} digits of the cube root of 2:\n{}", s.len(), shorten(&s, 70));
}</
{{out}}
Line 1,204:
=={{header|Scala}}==
===Functional solution, tail recursive, no immutables===
<
object IntegerRoots extends App {
Line 1,231:
}
}</
{{Out}}See it running in your browser by [https://scalafiddle.io/sf/bVwlHfa/0 ScalaFiddle (JavaScript, non JVM)] or by [https://scastie.scala-lang.org/0T93IhLVRGiYfuKpW7DTUg Scastie (JVM)].
=={{header|Scheme}}==
{{trans|Python}}
<
(define // quotient)
(define (y a a1 b c d e)
Line 1,251:
(display "First 2,001 digits of the cube root of two:\n")
(display (root 3 (* 2 (expt 1000 2000))))</
{{out}}
Line 1,259:
=={{header|Sidef}}==
{{trans|Ruby}}
<
b < 2 && return(b)
var (a1, c) = (a-1, 1)
Line 1,272:
say "First 2,001 digits of the square root of two:"
say root(2, 2 * 100**2000)</
{{out}}
<pre>
Line 1,283:
On the other hand, everything is very straightforward, no libraries necessary.
<
proc root {this n} {
if {$this < 2} {return $this}
Line 1,303:
puts [root 9 3]
puts [root [expr 2* (100**2000)] 2]
</syntaxhighlight>
{{out}}
<pre>
Line 1,313:
=={{header|Visual Basic .NET}}==
{{libheader|System.Numerics}}
From the method described on [https://en.wikipedia.org/wiki/Nth_root_algorithm the Wikipedia page]. Included is an Integer Square Root function to compare results to the Integer Nth Square root function. One must choose the exponents carefully, otherwise one will obtain the digits of the nth root of 20, 200, 2000, etc..., instead of 2. For example, 4008 was chosen because it works for both ''n = 2'' and ''n = 3'', whereas 4004 was chosen for ''n = 7''<
Imports System.Numerics
Imports Microsoft.VisualBasic.Strings
Line 1,361:
End Module
</syntaxhighlight>
{{out}}
<pre style="height:64ex;overflow:scroll">
Line 1,379:
=={{header|Wren}}==
Wren doesn't have arbitrary precision numerics and so can't do the third example in the task description. We therefore do the third C/C++ example instead.
<
if (!(x is Num && x.isInteger && x >= 0)) {
Fiber.abort("First argument must be a non-negative integer.")
Line 1,394:
var n = e[1]
System.print("%(x) ^ (1/%(n)) = %(intRoot.call(x, n))")
}</
{{out}}
Line 1,406:
=={{header|Yabasic}}==
{{trans|FreeBASIC}}
<
for nr = floor(sqr(x)) to 1 step -1
if (nr ^ n) <= x then return nr : fi
Line 1,415:
print root(3, 9)
print root(4, 167)
end</
Line 1,421:
{{trans|Python}}
Uses GNU GMP library
<
fcn root(n,r){
f:='wrap(z){ (n/z.pow(r-1) + z*(r-1))/r or 1 }; //--> v or 1
Line 1,427:
while(c!=d and c!=e){ c,d,e=d,e,f(e) }
if(d<e) d else e
}</
<
println("Does GMP agree: ",root(a,3)==a.root(3));</
{{out}}
<pre>
|