Vampire number: Difference between revisions

{{task|Mathematics}}

 

 

 

 

;Task:

<big><code> 16758243290880, 24959017348650, 14593825548650 </code></big>

 

 

 

;See also:

* [http://www.numberphile.com/videos/vampire_numbers.html numberphile.com].

<br><br>

 

=={{header|AutoHotkey}}==

The following code should work for older (1.0.*) AHK versions as well:

; (you can make it much faster by removing the informative tooltips)

 

}

Return SubStr(Output,3) ; 3 = 1 + length of "`n`t"

{{out}}

<pre>1260: [21,60]

 

14593825548650:</pre>

=={{header|Bracmat}}==

= N len R fangsList

. !arg:@(?N:? [?len)

& (!count:<25|!bignums:%?i ?bignums)

)

Output:

<pre>1260 (21,60)

 

=={{header|C}}==

#include <stdlib.h>

#include <stdint.h>

 

return 0;

<pre> 1: 1260 = 21 x 60

2: 1395 = 15 x 93

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

{{trans|C}}

 

namespace RosettaVampireNumber

}

}

{{out}}

<pre>

 

=={{header|C++}}==

#include <utility>

#include <algorithm>

#include <string>

#include <cmath>

bool isVampireNumber( long number, std::vector<std::pair<long, long> > & solution ) {

std::ostringstream numberstream ;

int fanglength = numberstring.length( ) / 2 ;

long start = static_cast<long>( std::pow( 10 , fanglength - 1 ) ) ;

if ( number % i == 0 ) {

long quotient = number / i ;

if ( ( i % 10 == 0 ) && ( quotient % 10 == 0 ) )

numberstream.str( "" ) ; //clear the number stream

numberstream << i << quotient ;

return !solution.empty( ) ;

}

void printOut( const std::pair<long, long> & solution ) {

std::cout << "[ " << solution.first << " , " << solution.second << " ]" ;

}

int main( ) {

int vampireNumbersFound = 0 ;

for ( long num = start ; num < end ; num++ ) {

if ( isVampireNumber( num , solutions ) ) {

std::cout << vampireNumbersFound << " :" << num << " is a vampire number! These are the fangs:\n" ;

std::for_each( solutions.begin( ) , solutions.end( ) , printOut ) ;

std::cout << "\n_______________" << std::endl ;

if ( vampireNumbersFound == 25 )

break ;

std::vector<long> testnumbers ;

testnumbers.push_back( 16758243290880 ) ;

testnumbers.push_back( 14593825548650 ) ;

for ( std::vector<long>::const_iterator svl = testnumbers.begin( ) ;

}

return 0 ;

{{out}}

[ 21 , 60 ]

_______________

[ 15 , 93 ]

_______________

_______________

[ 30 , 51 ]

_______________

[ 21 , 87 ]

_______________

[ 27 , 81 ]

_______________

[ 201 , 510 ]

_______________

_______________

[ 210 , 501 ]

_______________

[ 204 , 516 ]

_______________

[ 150 , 705 ]

_______________

[ 135 , 801 ]

_______________

[ 158 , 701 ]

_______________

[ 152 , 761 ]

_______________

[ 161 , 725 ]

_______________

[ 167 , 701 ]

_______________

[ 141 , 840 ]

_______________

[ 231 , 534 ]

_______________

_______________

[ 152 , 824 ]

_______________

[ 231 , 543 ]

_______________

[ 204 , 615 ][ 246 , 510 ]

_______________

[ 251 , 500 ]

_______________

16758243290880 is a vampire number! The fangs:

[ 1982736 , 8452080 ][ 2123856 , 7890480 ][ 2751840 , 6089832 ][ 2817360 , 5948208 ]

14593825548650 is not a vampire number!

</pre>

 

=={{header|Clojure}}==

(for [x (range 2 (Math/sqrt n))

:when (zero? (mod n x))]

 

(doseq [n [16758243290880, 24959017348650, 14593825548650]]

 

=={{header|Common Lisp}}==

 

"Is the lowest digit of `number' a 0"

(zerop (rem number 10)))

(when fangs

(print-vampire candidate fangs))))

 

{{out}}

{{trans|Clojure}}

(Runtime about 1.34 seconds with dmd.)

 

auto fangs(in long n) pure nothrow @safe {

14593825548650].map!fangs))

writefln("%d: (%(%(%s %)) (%))", v[]);

{{out}}

<pre>1260: (21 60)

{{trans|C}}

(Runtime about 0.27 seconds with dmd, about 0.25 seconds with ldc2 compilers.)

 

T[N] pows(T, size_t N)() pure nothrow @safe @nogc {

showFangs(bi, fs);

}

{{out}}

<pre> 2: 1395 = 15 x 93

24959017348650 = 2947050 x 8469153 = 2949705 x 8461530 = 4125870 x 6049395 = 4129587 x 6043950 = 4230765 x 5899410

14593825548650 is not vampiric</pre>

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

{{out}}

<pre>

=={{header|Elixir}}==

{{works with|Elixir|1.1+}}

def factor_pairs(n) do

first = trunc(n / :math.pow(10, div(char_len(n), 2)))

end

 

 

{{out}}

14593825548650 is not a vampire number!

</pre>

=={{header|FreeBASIC}}==

'FreeBASIC version 24. Windows

'Vampire.bas

Print "Completed in ";

Print t2-t1;" Seconds"

{{out}}

<pre>First 28 Vampire numbers

 

Completed in 1.286374813709699 Seconds</pre>

=={{header|Go}}==

{{trans|C}}

 

import (

}

}

{{out}}

<pre>

=={{header|Haskell}}==

 

import Control.Arrow ((&&&))

 

-- VAMPIRE NUMBERS ------------------------------------------------------------

vampires :: [Int]

 

fangs :: Int -> [(Int, Int)]

mapM

(print . ((,) <*>) fangs)

{{Out}}

<pre>

The following works in both languages.

 

write("First 25 vampire numbers and their fangs:")

every fangs := vampire(n := seq())\25 do write(right(n,20),":",fangs)

every (s1 := "", c := !cset(s)) do every find(c, s) do s1 ||:= c

return s1

 

Output:

 

=={{header|J}}==

Filter=: (#~`)(`:6)

odd =: 2&|

fangs f. NB. <laugh>

((10&(#.^:_1)@:[ -:&(/:~) ,&(10&(#.^:_1))/@:])"0 1 # ]) ((% ,. ]) (#~ (0 < [: # :[: 0 -.~ 10&|)"1)@:(((> <.@:%:)~ # ]) (((-: :[:@:(# :[:)@:(10&(#.^:_1))@:[ = # :[:@:(10&(#.^:_1))&>@:]) # ]) ([: ([: /:~ [: */"1 ([: x: [) ^"1 [: > [: , [: { [: <@:i.@>: ])/ __ q: ]))))

 

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.util.HashSet;

 

}

}

Output:

<pre>1260: [21, 60]

 

===Alternative version===

 

public static void main(String args[]) {

return total;

}

 

Output:

16758243290880 : [1982736, 8452080][2123856, 7890480][2751840, 6089832][2817360, 5948208]

24959017348650 : [2947050, 8469153][2949705, 8461530][4125870, 6049395][4129587, 6043950][4230765, 5899410]</pre>

 

=={{header|Julia}}==

'''Functions'''

function divisors{T<:Integer}(n::T)

!isprime(n) || return [one(T), n]

return (isvampire, fangs)

end

 

'''Main'''

function showvampire{T<:Integer}(i::T, n::T, fangs::Array{T,2})

s = @sprintf "%6d %14d %s\n" i n join(fangs[1,:], "\u00d7")

end

end

 

{{out}}

 

=={{header|Kotlin}}==

 

data class Fangs(val fang1: Long = 0L, val fang2: Long = 0L)

}

}

 

{{out}}

</pre>

 

VampireQ[num_Integer] := Module[{poss, divs},

divs = Select[Divisors[num], # <= Sqrt[num] &];

False

]

Testing out the function:

{{out}}

<pre>

True {{{24959017348650,{{2947050,8469153},{2949705,8461530},{4125870,6049395},{4129587,6043950},{4230765,5899410}}}}}

False {}</pre>

 

=={{header|PARI/GP}}==

k=25;forstep(d=4,6,2,for(n=10^(d-1),10^d-1,f=fang(n); for(i=1,#f,print(n" "f[i]" "n/f[i]); if(i==#f && k--==0,return))))

print();v=[16758243290880, 24959017348650, 14593825548650];

Output:

<pre>1260 21 60

=={{header|Perl}}==

 

 

use warnings;

use strict;

}

 

 

 

my @fangs;

 

 

 

 

 

}

}

 

 

<pre>

First 25 Vampire Numbers:

 

Individual tests:

 

</pre>

 

=={{header|PureBasic}}==

DisableDebugger

 

EndIf

Next

{{out}}

<pre>The first 25 Vampire numbers...

=={{header|Python}}==

This routine finds ''all'' the fangs for a number.

 

import math

for n in (16758243290880, 24959017348650, 14593825548650):

fangpairs = vampire(n)

{{out}}

<pre>First 25 vampire numbers

This alternative solution is not fast but it's short:

{{trans|Clojure}}

from itertools import imap, ifilter, islice, count

 

 

for n in [16758243290880, 24959017348650, 14593825548650]:

{{out}}

<pre>(1260, [(21, 60)])

Naive implementation, but notice the sequence-filter/sequence-map composition --

it's a good way to "find the first n numbers meeting predicate p?":

 

;; chock full of fun... including divisors

(displayln (vampire?-and-fangs 16758243290880))

(displayln (vampire?-and-fangs 24959017348650))

Output:

<pre>First 25 vampire numbers:

(24959017348650 (2947050 8469153) (2949705 8461530) (4125870 6049395) (4129587 6043950) (4230765 5899410))

#f</pre>

 

=={{header|REXX}}==

if N>0 then do j=1260 until # >= N /*search until N vampire numbers found.*/

end /*j*/ /* [↑] process a range of numbers. */

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

</pre>

<pre>

</pre>

<pre>

</pre>

<pre>

14593825548650 isn't a vampire number.

 

=={{header|Ring}}==

# Project : Vampire number

 

for p = 10 to 127000

next

return alist

Output:

<pre>

125433: [231,543]

125460: [204,615]

125500: [251,500]

126027: [201,627]

</pre>

 

=={{header|Ruby}}==

first = n / (10 ** (n.to_s.size / 2) - 1)

(first .. n ** 0.5).map { |i| [i, n / i] if n % i == 0 }.compact

puts "#{n}:\t#{vf}"

end

{{out}}

<pre>

14593825548650 is not a vampire number!

</pre>

 

=={{header|Scala}}==

{{works with|Scala|2.9.1}}

import math._

import scala.collection.mutable.ListBuffer

 

println("\n"+"elapsed time: "+et+" seconds")

Output:

<pre style="height: 30ex; overflow: scroll">1: 1260 = 21 x 60

 

elapsed time: 11 seconds</pre>

 

=={{header|Tcl}}==

{{trans|Ruby}}

set result [list 1 $n]

if {$from<=1} {set from 2}

}

return $result

Demonstrating:

proc printVampire {n pairs} {

set out "${n}:"

puts "$n is not a vampire number"

}

{{out}}

<pre>

24959017348650: [2947050, 8469153] [2949705, 8461530] [4125870, 6049395] [4129587, 6043950] [4230765, 5899410]

14593825548650 is not a vampire number

</pre>

 

=={{header|zkl}}==

var [const] tens=[0 .. 18].pump(List,(10.0).pow,"toInt");

 

});

fs and T(N,fs) or T;

if(not fangs) return(n,"Not a Vampire number");

v:=fangs[0]; T(v,fangs[1].apply('wrap(n){T(n,v/n)})) }

 

(0).walker(*).tweak(fangs).filter(26)

{{out}}

<pre>