First power of 2 that has leading decimal digits of 12: Difference between revisions

::*   display the results here, on this page.

<br><br>

 

=={{header|ALGOL 68}}==

As wih the Go second sample, computes approximate integer values for the powers of 2.

<br>Requires LONG INT to be at least 64 bits (as in Algol 68G).

BEGIN

# returns a string representation of n with commas #

print p( 123, 12345 );

print p( 123, 678910 )

{{out}}

<pre>

p(123, 12345) = 3,510,491

p(123, 678910) = 193,060,223

</pre>

 

{{trans|Pascal}}

{{works with|Factor|0.99 2019-10-06}}

math.functions math.parser sequences tools.time ;

 

123 678910

[ 2dup p "%d %d p = %d\n" printf ] 2 5 mnapply

{{out}}

<pre>

Running time: 44.208249282 seconds

</pre>

 

=={{header|Go}}==

{{trans|Pascal}}

 

import (

}

fmt.Printf("\nTook %s\n", time.Since(start))

 

{{out}}

 

or, translating the alternative Pascal version as well, for good measure:

 

import (

}

fmt.Printf("\nTook %s\n", time.Since(start))

 

{{out}}

Took 1.422321658s

</pre>

 

=={{header|J}}==

Modeled on the python version. Depending on the part of speech defined, the variable names x, y, u, v, m, and n can have special meaning within explicit code. They are defined by the arguments. In the fonts I usually use, lower case "l" is troublesome as well.

p=: adverb define

:

raised

)

 

<pre>

 

=={{header|Java}}==

public class FirstPowerOfTwo {

 

}

{{out}}

<pre>

</pre>

 

=={{header|Julia}}==

@assert(L > 0 && n > 0)

places, logof2, nfound = trunc(log(10, L)), log(10, 2), 0

println("With L = $L and n = $n, p(L, n) = ", p(L, n))

end

<pre>

With L = 12 and n = 1, p(L, n) = 7

===Faster version===

{{trans|Go}}

 

function p(L, n)

testpLn(true)

@btime testpLn(false)

<pre>

With L = 12 and n = 1, p(L, n) = 7

=={{header|Kotlin}}==

{{trans|Java}}

import kotlin.math.pow

 

}

return test

{{out}}

<pre>p(12, 1) = 7

p(123, 12345) = 3,510,491

p(123, 678910) = 193,060,223</pre>

 

=={{header|Pascal}}==

<b>0<= base ** frac(x) < base </b> thats 1 digit before the comma<Br>

Only the first digits are needed.So I think, the accuracy is sufficient, because the results are the same :-)

 

uses

const

 

var

begin

i := Number;

while i >= 10 do

i := i div 10;

end;

// x= i*ld10 -> 2^I = 10^x

// 10^frac(x) -> [0..10[ = exp(ln(10)*frac(i*lD10))

inc(cnt);

BREAK;

end;

until false;

FindExp := i;

end;

 

 

{{out}}

<pre>

Logarithm (Ln(Number/Digits)/ln(10) <= frac(i*lD10) < ln((Number+1)/Digits)/ln(10) => no exp<BR>

 

uses

sysutils,strUtils;

 

FindExp(1,99);

{{out}}

<pre>The 1th occurrence of 2 raised to a power whose product starts with "12" is 7

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

printf "%-15s %9s power of two (2^n) that starts with %5s is at n = %s\n", "p($prefix, $nth):",

comma($nth) . ordinal_digit($nth), "'$prefix'", comma p($prefix, $nth);

{{out}}

<pre>p(12, 1): 1st power of two (2^n) that starts with '12' is at n = 7

 

=={{header|Phix}}==

{{out}}

<pre>

The 678910th power of 2 that starts with 123 is 193060223 [i.e. 58,116,919 digits]

</pre>

 

=={{header|Python}}==

Using logs, as seen first in the Pascal example.

 

 

def p(l, n, pwr=2):

if __name__ == '__main__':

for l, n in [(12, 1), (12, 2), (123, 45), (123, 12345), (123, 678910)]:

 

{{out}}

p(123, 12345) = 3510491

p(123, 678910) = 193060223</pre>

 

=={{header|Raku}}==

Uses logs similar to Go and Pascal entries. Takes advantage of patterns in the powers to cut out a bunch of calculations.

 

 

constant $ln2ln10 = log(2) / log(10);

printf "%-15s %9s power of two (2^n) that starts with %5s is at n = %s\n", "p($prefix, $nth):",

comma($nth) ~ ordinal-digit($nth).substr(*-2), "'$prefix'", comma p($prefix, $nth);

{{out}}

<pre>p(12, 1): 1st power of two (2^n) that starts with '12' is at n = 7

 

=={{header|REXX}}==

parse arg L n b . /*obtain optional arguments from the CL*/

if L=='' | L=="," then L= 12 /*Not specified? Then use the default.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

commas: arg _; do c=length(_)-3 to 1 by -3; _= insert(',', _, c); end; return _

{{out|output|text=&nbsp; when using the inputs of: &nbsp; &nbsp; <tt> 12 &nbsp; 1 </tt>}}

<pre>

The 678910th occurrence of 2 raised to a power whose product starts with "123' is 193,060,223.

</pre>

 

=={{header|Sidef}}==

 

var (a1 = r.int, b1 = 1)

for a,b in (tests) {

say "p(#{a}, #{b}) = #{p(a,b)}"

{{out}}

<pre>

===Slower Version===

 

 

func p(L: Int, n: Int) -> Int {

for (l, n) in cases {

print("p(\(l), \(n)) = \(p(L: l, n: n))")

 

{{out}}

===Faster Version===

 

 

func p2(L: Int, n: Int) -> Int {

for (l, n) in cases {

print("p(\(l), \(n)) = \(p2(L: l, n: n))")

 

{{out}}

 

Same as before.

 

=={{header|zkl}}==

{{trans|Pascal}}

Lots of float are slow so I've restricted the tests.

fcn p(L,nth){ // 2^j = <L><digits>

var [const] ln10=(10.0).log(), ld10=(2.0).log() / ln10;

return(i);

}

{{libheader|GMP}} GNU Multiple Precision Arithmetic Library

GMP is just used to give some context on the size of the numbers we

are dealing with.

tests:=T( T(12,1),T(12,2), T(123,45),T(123,12345), );

foreach L,nth in (tests){

println("2^%-10,d is occurance %,d of 2^n == '%d<abc>' (%,d digits)"

.fmt(n,nth,L,BI(2).pow(n).len()));

{{out}}

<pre>