blob: 8b0dd569db8941344a92f4931140eac06c5080a9 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
;; -*- mode: lisp; -*-
;;; The following lines added by ql:add-to-init-file:
#-quicklisp
(let ((quicklisp-init (merge-pathnames ".local/share/quicklisp/setup.lisp"
(user-homedir-pathname))))
(when (probe-file quicklisp-init)
(load quicklisp-init)))
(defun primep (number)
(unless (= number 1)
(let ((max (floor (sqrt number))))
(or (= number 2)
(and (not (evenp number))
(= (length (loop for i from 3 upto max by 2
if (integerp (/ number i))
if (< 1 i number)
do (return-from primep nil)
else
collect i))
0))))))
(defun next-prime (number)
(loop for i from (1+ number)
if (primep i)
return i))
(defun previous-prime (number)
(loop for i from (1- number) downto 0
if (primep i)
return i))
(defun primes (number)
(do ((prime 2 (next-prime prime))
(primes (list)))
((> prime number) (reverse primes))
(setf primes (cons prime primes))))
(defun prime-factors (number)
(do ((i 1 (1+ i)))
((> i (/ number 2)) (list number))
(let ((d (/ number i)))
(if (and (integerp d) (primep i))
(return (cons i (prime-factors d)))))))
(defun largest-prime-factor (number)
(apply #'max (prime-factors number)))
;; (defun start-local-server ()
;; (ql:quickload "usocket")
;; (usocket:socket-server
;; "localhost" 4006
;; (lambda (stream)
;; (handler-case
;; (let ((*standard-input* stream)
;; (*standard-output* stream)
;; (type (read stream)))
;; (case type
;; (:eval
;; (princ (eval (read)))
;; (force-output))
;; (:shell
;; (loop
;; (fresh-line)
;; (princ "CL> " stream)
;; (force-output)
;; (print (eval (read)))))))
;; (end-of-file () nil)))
;; () :in-new-thread t :multi-threading t))
(defun reverse-number (num)
(declare (optimize (debug 0)))
(labels ((rev (num acc)
(if (= num 0)
acc
(rev (floor (/ num 10))
(+ (* acc 10) (mod num 10))))))
(rev num 0)))
(defun palindromic-number-p (num)
(= num (reverse-number num)))
(defun largest-palindrome-product (num1 upper)
(do* ((num2 upper (1- num2))
(prod (* num1 num2) (* num1 num2)))
((palindromic-number-p prod) prod)))
(defun largest-palindrome-product-between (bounds)
(do ((num1 (cdr bounds) (1- num1)) (prod 0))
((<= num1 (car bounds)) prod)
(setf prod
(max prod (largest-palindrome-product num1 (cdr bounds))))))
;; (defun prime-factors (num)
;; (declare (optimize (debug 0)))
;; (labels ((fact (num acc)
;; (if (< num 2)
;; (reverse acc)
;; (do ((prime (next-prime 0) (next-prime prime)))
;; ((= (mod num prime) 0)
;; (fact (floor (/ num prime)) (cons prime acc)))))))
;; (fact num nil)))
(defun smallest-multiple-between (bounds)
(apply #'lcm (loop for i from (car bounds) to (cdr bounds) collect i)))
(defun square (num)
(expt num 2))
(defun sum-of-squares (nums)
(apply #'+ (mapcar #'square nums)))
(defun square-of-sums (nums)
(square (apply #'+ nums)))
(defun sum-square-diff (bounds)
(let ((nums (loop for i from (car bounds) upto (cdr bounds)
collect i)))
(- (square-of-sums nums) (sum-of-squares nums))))
(defun nth-prime (num)
(do* ((count 0 (1+ count))
(prime 0 (next-prime prime)))
((>= count num) prime)))
|
