LISP: Computing Prime Numbers Between 1 and 25 Inclusive | AI Research

LISP: Computing Prime Numbers Between 1 and 25 (Inclusive)

Verified Sources

Nov 4, 2026

To “write a function in LISP that computes prime number between 1 and 25 (inclusive)”, the most reliable approach is to (1) define a predicate prime? and then (2) build a function that enumerates candidates and filters using that predicate. A standard number-theory optimization is to check divisibility only up to $\sqrt{n}$ , because any composite $n$ has a factor $\le \sqrt{n}$ .

A minimal Common Lisp solution typically uses integer loops and modular arithmetic: mod and dolist or loop.

Below is a complete, idiomatic Common Lisp implementation that returns the list of primes in the interval $[1,25]$ (i.e., $2,3,5,7,11,13,17,19,23$ ).

Keyword map: prime?, mod, sqrt, loop.

Common Lisp: Functions, loops, and basics (learning to read the code)

Prime predicate design

A number $n$ is prime if:

$n < 2$ is not prime,
otherwise, test whether any integer $d$ in $2.. \lfloor \sqrt{n}\rfloor$ divides $n$ evenly (i.e., $n \bmod d = 0$ ).

This uses the divisor bound $d \le \lfloor\sqrt{n}\rfloor$ , reducing work while remaining correct.

Warning: if you accidentally start testing from $d=1$ , then every $n$ will appear “divisible” by $1$ and you’ll misclassify primes. Always begin at $2$ .

prime? and divisor are the core logic pieces.

(defun prime? (n)
  "Return T if N is prime, NIL otherwise."
  (cond
    ((< n 2) nil)
    ((= n 2) t)
    ((evenp n) nil)
    (t
     ;; Check odd divisors up to sqrt(n)
     (let ((limit (isqrt n)))
       (loop for d from 3 to limit by 2
             never (zerop (mod n d))))))

(defun primes-between-1-and-25 ()
  "Return the list of prime numbers between 1 and 25 inclusive."
  (loop for n from 1 to 25
        when (prime? n)
        collect n))

;; Example:
;; (primes-between-1-and-25)
;; => (2 3 5 7 11 13 17 19 23)

Build the two functions: prime? then primes-between

1
Step 1
Return NIL for $n<2$ , return T for $n=2$ ; even numbers greater than 2 are not prime using evenp.
2
Step 2
Let $\text{limit} = \lfloor \sqrt{n} \rfloor$ using isqrt so the loop stays integer-only.
3
Step 3
Loop $d$ from 3 to limit by 2 and check mod with (zerop (mod n d)). If any divisor works, return NIL; otherwise return T.
4
Step 4
Use a loop from 1 to 25 and collect n whenever (prime? n) is true.

Pro Tip: prefer list-returning functions

If your goal is “compute primes between 1 and 25”, returning a list is the most useful shape. In Common Lisp, loop with collect makes this natural.

Common bug: wrong loop condition for divisibility

If you accidentally write something like for d below limit (excluding the limit) you can misclassify squares (e.g., $n=9$ or $n=25$ ) because the actual factor can equal $\sqrt{n}$ . Use an inclusive upper bound when checking $d \le \lfloor\sqrt{n}\rfloor$ .

How you should develop this solution

Define prime? predicate

Step 1

Implement edge cases, even check, then divisor test up to $\lfloor\sqrt{n}\rfloor$ ."

Enumerate interval

Step 2

Loop over $n$ from 1 to 25 inclusive and filter using (prime? n)."

Verify with known primes

Step 3

Expected output: (2 3 5 7 11 13 17 19 23)."

Common variants and edge cases

Primes between 1 and 25

Expected result list values

Knowledge Check

Question 1 of 4

Q1Single choice

In a prime-checking function, why do we test divisors only up to $\lfloor\sqrt{n}\rfloor$ ?

Any composite number has a factor at most $\sqrt{n}$

Primes always have a factor exactly $\sqrt{n}$

Divisibility beyond $\sqrt{n}$ is undefined in integer arithmetic

It guarantees $n$ is prime if any divisor is found

Explore Related Topics

Peephole Optimization in Compiler Design: Principles and Worked Examples

Convert the Decimal Number 108.25 to Its Binary Equivalent

Least Upper Bound of $\{3,5\}$ in a Divisibility Poset

Browse all research articles