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

# the decimal representation of 2^j starts with the digits of L #

BEGIN

print p( 123, 12345 );

print p( 123, 678910 )

{{out}}

<pre>

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

</pre>

 

=={{header|C}}==

{{trans|Java}}

#include <stdio.h>

 

 

return 0;

{{out}}

<pre>p(12, 1) = 7

{{trans|Go}}

{{trans|Pascal}}

 

#include <string>

doOne("go integer", gi);

doOne("pascal alternative", pa);

{{out}}Exeution times from Tio.run, language: C++ (clang) or C++ (gcc), compiler flags: -O3 -std=c++17

<pre>java simple version:

Took 0.082407 seconds</pre>

 

{{trans|C++}}

 

using System;

doOne("pascal alternative", pa);

}

{{out}}

Results on the core i7-7700 @ 3.6Ghz.

=={{header|D}}==

{{trans|C}}

import std.stdio;

 

runTest(123, 12345);

runTest(123, 678910);

{{out}}

<pre>p(12, 1) = 7

p(123, 12345) = 3510491

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

 

=={{header|Factor}}==

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

 

=={{header|FreeBASIC}}==

 

function p( L as uinteger, n as uinteger ) as uinteger

print p(123, 45)

print p(123, 12345)

{{out}}

<pre>

3510491

193060223</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}}

=={{header|Haskell}}==

{{trans|Python}}

import Text.Printf (printf)

 

main :: IO ()

main = mapM_ (\(l, n) -> printf "p(%d, %d) = %d\n" l n (p l n))

 

Which, desugaring a little from Control.Monad (guard) and the do syntax, could also be rewritten as:

 

p :: Int -> Int -> Int

p l n = ([-1 ..] >>= f) !! pred n

where

log10pwr = logBase 10 2

where

ds =

floor $

 

main :: IO ()

mapM_

(\(l, n) -> printf "p(%d, %d) = %d\n" l n (p l n))

 

{{out}}

=={{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>

<pre>

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

</pre>

 

=={{header|Scala}}==

{{trans|Java}}

def p(l: Int, n: Int): Int = {

var n2 = n

runTest(123, 678910)

}

{{out}}

<pre>p(12, 1) = 7

 

=={{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}}

 

=={{header|Visual Basic .NET}}==

 

Function Func(ByVal l As Integer, ByVal n As Integer) As Long

End Sub

 

{{out}}

<pre>p( 12, 1) = 60

{{libheader|Wren-fmt}}

{{libheader|Wren-math}}

 

var ld10 = Math.ln2 / Math.ln10

i = 0

while (count < n) {

if ((e * digits).truncate == L) count = count + 1

i = i + 1

}

 

 

{{out}}

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

 

</pre>

 

=={{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>