Vampire number: Difference between revisions

{{trans|Nim}}

 

 

F isOdd(n)

print(n‘ is not vampiric.’)

E

 

{{out}}

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

 

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

 

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

 

=={{header|FreeBASIC}}==

'FreeBASIC version 24. Windows

'Vampire.bas

Print "Completed in ";

Print t2-t1;" Seconds"

{{out}}

<pre>First 28 Vampire numbers

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

'''Works with gojq, the Go implementation of jq'''

 

 

# To take advantage of gojq's arbitrary-precision integer arithmetic:

task1(25),

"",

{{out}}

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

end

end

 

{{out}}

 

=={{header|Kotlin}}==

 

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

}

}

 

{{out}}

 

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

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

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

False

]

Testing out the function:

{{out}}

<pre>

 

=={{header|Nim}}==

 

const Pow10 = collect(newSeq, for n in 0..18: 10 ^ n)

echo &"{n} is not vampiric."

else:

 

{{out}}

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

The trailing zeros condition is first triggered when searching for the 26th vampire number.

 

use warnings;

use strict;

}

 

 

A faster version, using the `divisors()` function from the <code>ntheory</code> library.

{{trans|Sidef}}

{{libheader|ntheory}}

 

sub is_vampire {

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

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

{{out}}

<pre>

 

=={{header|Phix}}==

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

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.2"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (for in)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">={}?</span><span style="color: #008000;">"not a vampire number"</span><span style="color: #0000FF;">:</span><span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">))})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

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

(formerly Perl 6)

 

my $digits = $num.comb.sort;

my @fangs;

.say for (16758243290880, 24959017348650, 14593825548650).hyper(:1batch).map: {

"$_: " ~ (is_vampire($_).join(', ') || 'is not a vampire number.')

 

<pre>First 25 Vampire Numbers:

=={{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.*/

a= a '['d"∙"q'] ' /*construct formatted fangs.*/

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

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

<pre>

 

=={{header|Ring}}==

# Project : Vampire number

 

next

return alist

Output:

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

 

=={{header|Rust}}==

 

static TENS: [u64; 20] = [

 

assert_eq!(fangs(14593825548650), vec![]);

 

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

=={{header|Vlang}}==

{{trans|Go}}

fn max(a u64, b u64) u64 {

if a > b {

}

}

{{out}}

<pre> 1: 1260 = 21 × 60

{{trans|Go}}

{{libheader|Wren-fmt}}

 

var ndigits = Fn.new { |x|

Fmt.print("$d is not vampiric", x)

}

 

{{out}}

 

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