We shall say that an n-digit number is pandigital if it makes use of all the digits 1 to n exactly once. For example, 2143 is a 4-digit pandigital and is also prime.

What is the largest n-digit pandigital prime that exists?

+-#all_perms
def all_perms(s)
	return [s.to_a] if s.size==1
	ss=s.map do |item|
		sss=s.clone
		sss.delete_at(s.index(item))
		all_perms(sss).map{|col|col.push item}
	end	
	ss.inject{|u,v|u+v}
end

+-#PrimeList
class PrimeList
  @@primes=[2,3,5,7,11,13,17,19]

  def initialize
    @next=-1
  end

  def last
    return 0 if @next==-1
    PrimeList.get(@next)
  end

  def getNext
    PrimeList.get(@next+=1)
  end

  def [](i)
    PrimeList.get(i)
  end

  def PrimeList.isPrime?(n)
    if(@@primes[-1] >= n)
      return true if @@primes.index n
      return false
    end
    p=PrimeList.new
    sq=Math.sqrt(n)
    while(p.last<=sq)
      return false if n % (p.getNext)==0
    end
    true
  end

  def PrimeList.get(i)
    PrimeList.gen while @@primes.length<=i
    @@primes[i]
  end

  def PrimeList.getPrimeNear(n)
    PrimeList.gen until n<@@primes[-1]
    @@primes[PrimeList.primeIndexNear(n)]
  end  

  private

  def PrimeList.primeIndexNear(n)
    return 0 if n<@@primes[0]
    return [-1] if n>@@primes[-1]
    PrimeList.getIndexNear(@@primes,n)
  end

  def PrimeList.getIndexNear(list,n)
    return 0 if list.length==1
    if(list.length==2)
      avg=(list[0]+list[1])/2.0
      return 1 if n>avg
      return 0
    end
    splitAfter=list.size/2
    return PrimeList.getIndexNear(list[0..splitAfter],n) if n<list[splitAfter]
    return splitAfter+1+PrimeList.getIndexNear(list[(splitAfter+1)..-1],n) if n>list[splitAfter+1]
    avg=(list[splitAfter]+list[splitAfter+1])/2
    return splitAfter+1 if n>avg
    splitAfter
  end

  def PrimeList.gen
    add=@@primes[-1]
    cands=Set.new(1..(5*add)){|i|2*i+add}
    theBegin=add+2
    theEnd=11*add
    highest=Math.sqrt(theEnd).to_i
    upTo=PrimeList.primeIndexNear(highest)
    upTo-=1 if @@primes[upTo]>highest
    @@primes[1..upTo].each do |mult|
      ((theBegin-theBegin%mult)..(theEnd-theEnd%mult + mult)).step(mult){|i|cands.delete i}
    end
    @@primes=@@primes+cands.to_a.sort
  end
end

def p41
  digs=7
  while true
    p=all_perms((1..digs).to_a).map{|a|a.join("").to_i}.select{|i|PrimeList.isPrime? i}
    if p.length>0
      p.sort!
      puts p.last
      return 
    end
    digs-=1
  end
end