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

{{trans|Python}}

 

l = Int(abs(l))

V digitcount = floor(log(l, 10))

 

L(l, n) [(12, 1), (12, 2), (123, 45), (123, 12345), (123, 678910)]

 

{{out}}

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>

 

=={{header|BASIC256}}==

FAC = 0.30102999566398119521373889472449302677

 

end while

return j

{{out}}

<pre>Same as FreeBASIC entry.</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:

=={{header|C sharp|C#}}==

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

 

=={{header|F_Sharp|F#}}==

// First power of 2 that has specified leading decimal digits. Nigel Galloway: March 14th., 2021

let fG n g=let fN l=let l=10.0**(l-floor l) in l>=n && l<g in let f=log10 2.0 in seq{1..0x0FFFFFFF}|>Seq.filter(float>>(*)f>>fN)

printfn "p(123,12345)->%d" (int(Seq.item 12344 (fG 1.23 1.24)))

printfn "p(123,678910)->%d" (int(Seq.item 678909 (fG 1.23 1.24)))

{{out}}

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

 

=={{header|FreeBASIC}}==

 

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

print p(123, 45)

print p(123, 12345)

{{out}}

<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

(123, 12345),

(123, 678910)

 

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

 

(Starting with (8+28) and tapering off to 8 is insufficient.)

def n:

if length == 1 and .[0] < $base then .[0]

[[12, 1], [12, 2], [123, 45], [123, 12345], [123, 678910]][]

| "With L = \(.[0]) and n = \(.[1]), p(L, n) = \( p(.[0]; .[1]))"

{{out}}

As for Julia.

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

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Without compilation arbitrary precision will be used, and the algorithm will be slow, compiled is much faster:

Module[{l, digitcount, log10power, raised, found, firstdigits, pwr = 2},

l = Abs[ll];

f[123, 45]

f[123, 12345]

{{out}}

<pre>7

{{trans|Pascal}}

This is a translation to Nim of the very efficient Pascal alternative algorithm, with minor adjustments.

 

const

findExp(123, 45)

findExp(123, 12345)

 

{{out}}

<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

FindExp(12345, 123);

FindExp(678910, 123);

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

{{libheader|Phix/mpfr}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">L</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</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>

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

===Untyped Racket===

 

(define (fract-part f)

(- f (truncate f)))

(report-p 123 45)

(report-p 123 12345)

 

{{out}}

===Typed Racket===

 

 

(: fract-part (-> Float Float))

(report-p 123 12345)

(report-p 123 678910))

 

{{out}}

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>

=={{header|Ruby}}==

{{trans|C}}

test = 0

logv = Math.log(2.0) / Math.log(10.0)

runTest(123, 45)

runTest(123, 12345)

{{out}}

<pre>P(12, 1) = 7

 

=={{header|Rust}}==

let mut test: isize = 0;

let log: f64 = 2.0_f64.ln() / 10.0_f64.ln();

run_test(123, 678910);

}

{{out}}

<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-math}}

Just the first version which has turned out to be much quicker than the Go entry (around 28 seconds on the same machine). Frankly, I've no idea why.

import "/math" for Math

 

}

 

 

{{out}}

 

=={{header|Yabasic}}==

 

print p(12, 1)

end while

return j

 

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