It’s a well-known result of Sylvester that if $a$ and $b$ are relatively prime positive integers, the largest integer that cannot be written in the form $ma+nb$ for some non-negative integers $m$ and $n$ is $ab-a-b$. (He also showed that exactly half of the $(a-1)(b-1)$ integers $0,1,\dots,ab-a-b$ cannot be so written.) For your problem take $a=25$ and $b=29$ and work in cents.
This PDF gives a lot more information on the Frobenius coin problem, including a pretty accessible development of the first part of Sylvester’s result. (The later parts of the PDF are considerably more advanced.)
Finding palindromic primes is not very hard, but rather proving them and labeling them as Prime instead of PRP (Probable Prime) is the hard job. You can find the list of world's largest palindromic primes here
And the reason why proving most of them is time-consuming lies in odd digits in them. That is if you could express your number as $k*2^n +- 1$ then proving is much easier using several algorithms out there, but since palindromic primes usually have more odd digits than $0$ ones, then their finding procedure becomes too long.
As an example, the best palindromic number is of the following form (the smallest one is $101$):
$100000000000...00000000000000001$
It can be easily expressed as $5^n*2^n + 1$ and therefore easy to do primility test. Occurance of a non-zero digit at any position, cause the power of $2$ in the formula to be decreased.
So the best place for such a digits is near the center of number.
Again as an example where power of $2$ is near $n/2$
$100000000000...007700...00000000000000001$
Updated
And for generating the number you can build a simple formula like the following in Mathematica:
Palindromic[n_, digit_, position_] :=
(10^n - 1)/9 + (digit - 1) (10^position + 10^(n - position - 1))
In[1]:= Palindromic[20, 7, 9]
Out[1]= 11111111177111111111
Best Answer
As it turns out GUILE Scheme does provide hash tables. In order to leave this discussion in an acceptable state for future viewers, I am posting an implementation of the above algorithm using hash tables, which makes for a much simpler and much more readable solution.
This is the code:
(use-modules (ice-9 format)) (define (digits-table mincnt maxcnt maxit minv maxv) (let ((layers (make-vector (+ 1 maxit))) (allsols (make-hash-table)) (initial (make-hash-table))) (for-each (lambda (ex-p) (hash-set! initial (car ex-p) (cdr ex-p))) '((1 . "1") (7 . "7") (17 . "17") (77 . "77") (71 . "71") (777 . "777") (177 . "177") (717 . "717") (771 . "771"))) (vector-set! layers 0 initial) (letrec ((insert (lambda (ht v s) (let ((ent (hash-ref ht v))) (if (or (and ent (> (string-length ent) (string-length s))) (not ent)) (hash-set! ht v s))))) (combine (lambda (res a b) (let* ((ha (vector-ref layers a)) (hb (vector-ref layers b))) (hash-for-each (lambda (v1 s1) (hash-for-each (lambda (v2 s2) (if (not (and (string-contains s1 "1") (string-contains s2 "1"))) (begin (insert res (+ v1 v2) (format #f "(~a)+(~a)" s1 s2)) (insert res (- v1 v2) (format #f "(~a)-(~a)" s1 s2)) (insert res (* v1 v2) (format #f "(~a)*(~a)" s1 s2)) (if (not (zero? v2)) (insert res (/ v1 v2) (format #f "(~a)/(~a)" s1 s2)))))) hb)) ha) res))) (iter (lambda (k) (if (not (= maxit k)) (let ((res (make-hash-table))) (do ((a 0 (1+ a))) ((> a k)) (combine res a (- k a))) (vector-set! layers (1+ k) res) (iter (1+ k))))))) (iter 0) (letrec ((do-disp (lambda (l) (if (not (null? l)) (let ((ex-p (car l))) (begin (display (format #f "~35a ~20a ~8f" (cdr ex-p) (car ex-p) (exact->inexact (car ex-p)))) (newline) (do-disp (cdr l)))))))) (do ((a 0 (1+ a))) ((> a maxit)) (hash-for-each (lambda (v s) (insert allsols v s)) (vector-ref layers a))) (do-disp (filter (lambda (p) (and (<= minv (car p)) (<= (car p) maxv) (<= mincnt (string-count (cdr p) #\7) maxcnt) (= (string-count (cdr p) #\1) 1))) (sort (hash-fold (lambda (v s prior) (cons (cons v s) prior)) '() allsols) (lambda (ex-p1 ex-p2) (< (car ex-p1) (car ex-p2))))))))) '())This will produce output e.g. like this