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>

}

return 0 ;

{{out}}

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

 

=={{header|Factor}}==

math.combinatorics math.functions math.primes.factors math.statistics

math.text.utils prettyprint sequences sets ;

: main ( -- ) part1 part2 ;

 

{{out}}

<pre>

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

</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 ((&&&))

 

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

{{Lines too long|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;

}

 

 

{{trans|Sidef}}

 

sub is_vampire {

print("$n: ", (@fangs ? join(' ', map { "[@$_]" } @fangs)

: "is not a vampire number"), "\n");

{{out}}

<pre>

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

14593825548650: is not a vampire number

</pre>

 

=={{header|Phix}}==

{{out}}

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

Note: &nbsp; if the argument is negative, its absolute value is used to test if <u>that</u> single number is vampiric.

parse arg N . /*obtain optional argument from the CL.*/

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

!.0= 1260; !.1= 11453481; !.2= 115672; !.3= 124483; !.4= 105264 /*lowest #, dig*/

!.5= 1395; !.6= 126846; !.7= 1827; !.8= 110758; !.9= 156289 /* " " " */

numeric digits max(9, length(aN) ) /*be able to handle ginormus numbers. */

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

if length(j) // 2 then do; j= j*10 - 1; iterate /*bump J to even length*/

if f=='' then iterate /*Are fangs null? Yes, not vampire. */

#= # + 1 /*bump the vampire count, Vlad. */

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

else do; f= vampire(aN) /* [↓] process a number; obtain fangs.*/

end

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

vampire: procedure; parse arg x,, $. a bot; L= length(x) /*get arg; compute len of X*/

if L//2 then return '' /*is L odd? Then ¬vampire.*/

w= L % 2 /*%: is REXX's integer ÷ */

top= left( reverse(bot), w)

bot= left(bot, w) /*determine limits of search*/

inc= x // 2 + 1 /*X is odd? INC=2. No? INC=1*/

/* [↑] odd BEG if odd INC*/

if x // d \==0 then iterate /*X not ÷ by D? Then skip,*/

if q*d//9 \== (q+d)//9 then iterate /*modulo 9 congruence test. */

parse var q '' -1 _ /*get last decimal dig. of Q*/

end /*i*/

end /*d*/ /* [↑] ∙ is a round bullet*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

16758243290880 is a vampire number, fangs= [1982736∙8452080] [2123856∙7890480] [2751840∙6089832] [2817360∙5948208]

</pre>

<pre>

24959017348650 is a vampire number, fangs= [2947050∙8469153] [2949705∙8461530] [4125870∙6049395] [4129587∙6043950] [4230765∙5899410]

</pre>

<pre>

14593825548650 isn't a vampire number.

 

=={{header|Ring}}==

# Project : Vampire number

 

next

return alist

Output:

<pre>

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

 

=={{header|Sidef}}==

return [] if n.ilog10.is_even

 

var fangs = is_vampire(n)

say "#{n}: #{fangs ? fangs.join(', ') : 'is not a vampire number'}"

{{out}}

<pre>

=={{header|Swift}}==

 

 

func vampire<T>(n: T) -> [(T, T)] where T: BinaryInteger, T.Stride: SignedInteger {

print("\(vamp) is a vampire number with fangs: \(fangs)")

}

 

{{out}}

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