Another update from ingydotnet^djgoku

Task/Vampire-number/Common-Lisp/vampire-number.lisp

@@ -0,0 +1,60 @@
+(defun trailing-zerop (number)
+  "Is the lowest digit of `number' a 0"
+  (zerop (rem number 10)))
+
+(defun integer-digits (integer)
+  "Return the number of digits of the `integer'"
+  (assert (integerp integer))
+  (length (write-to-string integer)))
+
+(defun paired-factors (number)
+  "Return a list of pairs that are factors of `number'"
+  (loop
+    :for candidate :from 2 :upto (sqrt number)
+    :when (zerop (mod number candidate))
+      :collect (list candidate (/ number candidate))))
+
+(defun vampirep (candidate &aux
+                             (digits-of-candidate (integer-digits candidate))
+                             (half-the-digits-of-candidate (/ digits-of-candidate
+                                                              2)))
+  "Is the `candidate' a vampire number?"
+  (remove-if #'(lambda (pair)
+                 (> (length (remove-if #'null (mapcar #'trailing-zerop pair)))
+                     1))
+             (remove-if-not #'(lambda (pair)
+                                (string= (sort (copy-seq (write-to-string candidate))
+                                               #'char<)
+                                         (sort (copy-seq (format nil "~A~A" (first pair) (second pair)))
+                                               #'char<)))
+                            (remove-if-not #'(lambda (pair)
+                                               (and (eql (integer-digits (first pair))
+                                                         half-the-digits-of-candidate)
+                                                    (eql (integer-digits (second pair))
+                                                         half-the-digits-of-candidate)))
+                                           (paired-factors candidate)))))
+
+(defun print-vampire (candidate fangs &optional (stream t))
+  (format stream
+          "The number ~A is a vampire number with fangs: ~{ ~{~A~^, ~}~^; ~}~%"
+          candidate
+          fangs))
+
+;; Print the first 25 vampire numbers
+
+(loop
+  :with count := 0
+  :for candidate :from 0
+  :until (eql count 25)
+  :for fangs := (vampirep candidate)
+  :do
+     (when fangs
+       (print-vampire candidate fangs)
+       (incf count)))
+
+;; Check if 16758243290880, 24959017348650, 14593825548650 are vampire numbers
+
+(dolist (candidate '(16758243290880 24959017348650 14593825548650))
+  (let ((fangs (vampirep candidate)))
+    (when fangs
+      (print-vampire candidate fangs))))

Task/Vampire-number/Eiffel/vampire-number.e

@@ -0,0 +1,111 @@
+class
+	APPLICATION
+
+create
+	make
+
+feature
+
+	fang_check (original, fang1, fang2: INTEGER_64): BOOLEAN
+			-- Are 'fang1' and 'fang2' correct fangs of the 'original' number?
+		require
+			original_positive: original > 0
+			fangs_positive: fang1 > 0 and fang2 > 0
+		local
+			original_length: INTEGER
+			fang, ori: STRING
+			sort_ori, sort_fang: SORTED_TWO_WAY_LIST [CHARACTER]
+		do
+			create sort_ori.make
+			create sort_fang.make
+			create ori.make_empty
+			create fang.make_empty
+			original_length := original.out.count // 2
+			if fang1.out.count /= original_length or fang2.out.count /= (original_length) then
+				Result := False
+			elseif fang1.out.ends_with ("0") and fang2.out.ends_with ("0") then
+				Result := False
+			else
+				across
+					1 |..| original.out.count as c
+				loop
+					sort_ori.extend (original.out [c.item])
+				end
+				across
+					sort_ori as o
+				loop
+					ori.extend (o.item)
+				end
+				across
+					1 |..| fang1.out.count as c
+				loop
+					sort_fang.extend (fang1.out [c.item])
+					sort_fang.extend (fang2.out [c.item])
+				end
+				across
+					sort_fang as f
+				loop
+					fang.extend (f.item)
+				end
+				Result := fang.same_string (ori)
+			end
+		ensure
+			fangs_right_length: Result implies original.out.count = fang1.out.count + fang2.out.count
+		end
+
+	make
+                -- Uses fang_check to find vampire nubmers.
+		local
+			i, numbers: INTEGER
+			fang1, fang2: INTEGER_64
+			num: ARRAY [INTEGER_64]
+			math: DOUBLE_MATH
+		do
+			create math
+			from
+				i := 1000
+			until
+				numbers > 25
+			loop
+				if i.out.count \\ 2 = 0 then
+					from
+						fang1 := 10
+					until
+						fang1 >= math.sqrt (i)
+					loop
+						if (i \\ fang1 = 0) then
+							fang2 := i // fang1
+							if i \\ 9 = (fang1 + fang2) \\ 9 then
+								if fang1 * fang2 = i and fang1 <= fang2 and then fang_check (i, fang1, fang2) then
+									numbers := numbers + 1
+									io.put_string (i.out + ": " + fang1.out + " " + fang2.out)
+									io.new_line
+								end
+							end
+						end
+						fang1 := fang1 + 1
+					end
+				end
+				i := i + 1
+			end
+			num := <<16758243290880, 24959017348650, 14593825548650>>
+			across
+				num as n
+			loop
+				from
+					fang1 := 1000000
+				until
+					fang1 >= math.sqrt (n.item) + 1
+				loop
+					if (n.item \\ fang1 = 0) then
+						fang2 := (n.item // fang1)
+						if fang1 * fang2 = n.item and fang1 <= fang2 and then fang_check (n.item, fang1, fang2) then
+							io.put_string (n.item.out + ": " + fang1.out + " " + fang2.out + "%N")
+						end
+					end
+					fang1 := fang1 + 1
+				end
+			end
+		end
+
+end

Task/Vampire-number/Julia/vampire-number-1.julia

@@ -0,0 +1,34 @@
+function divisors{T<:Integer}(n::T)
+    !isprime(n) || return [one(T), n]
+    d = [one(T)]
+    for (k, v) in factor(n)
+        e = T[k^i for i in 1:v]
+        append!(d, vec([i*j for i in d, j in e]))
+    end
+    sort(d)
+end
+
+function vampirefangs{T<:Integer}(n::T)
+    fangs = T[]
+    isvampire = false
+    vdcnt = ndigits(n)
+    fdcnt = vdcnt>>1
+    iseven(vdcnt) || return (isvampire, fangs)
+    !isprime(n) || return (isvampire, fangs)
+    vdigs = sort(digits(n))
+    d = divisors(n)
+    len = length(d)
+    len = iseven(len) ? len>>1 : len>>1 + 1
+    for f in d[1:len]
+        ndigits(f) == fdcnt || continue
+        g = div(n, f)
+        f%10!=0 || g%10!=0 || continue
+        sort([digits(f), digits(g)]) == vdigs || continue
+        isvampire = true
+        append!(fangs, [f, g])
+    end
+    if isvampire
+        fangs = reshape(fangs, (2,length(fangs)>>1))'
+    end
+    return (isvampire, fangs)
+end

Task/Vampire-number/Julia/vampire-number-2.julia

@@ -0,0 +1,36 @@
+function showvampire{T<:Integer}(i::T, n::T, fangs::Array{T,2})
+    s = @sprintf "%6d  %14d %s\n" i n join(fangs[1,:], "\u00d7")
+    for i in 2:size(fangs)[1]
+        s *= " "^23*join(fangs[i,:], "\u00d7")*"\n"
+    end
+    return s
+end
+
+vgoal = 25
+vcnt = 0
+dcnt = 0
+println("Finding the first ", vgoal, " vampire numbers.")
+println("     N         Vampire Fangs")
+while vcnt < vgoal
+    dcnt += 2
+    for i in (10^(dcnt-1)):(10^dcnt-1)
+        (isvampire, fangs) = vampirefangs(i)
+        isvampire || continue
+        vcnt += 1
+        print(showvampire(vcnt, i, fangs))
+        vcnt < vgoal || break
+    end
+end
+
+test = [16758243290880, 24959017348650, 14593825548650]
+println()
+println("Checking a few numbers.")
+println("     N         Vampire Fangs")
+for (i, v) in enumerate(test)
+    (isvampire, fangs) = vampirefangs(v)
+    if isvampire
+        print(showvampire(i, v, fangs))
+    else
+        println(@sprintf "%6d  %14d is not a vampire" i v)
+    end
+end