I was just reading through the posts here:

1.)the comment on unrolling the javascript loop would result in larger code set to transfer to the browser makes perfect sense. Good point.

2.)Performance is not the main focus for good code: I agree. Readability,maintinence, management,security ect ect are certainly more important. However, sometimes those things are set aside for performance, although rarely. For example, in finance when you are analyzing streaming data on a wire feed and building correlation matricies for the portfolio VaR.... accuracy is most important,followed by performance,everything else is irrelevant. But in these rare cases, you wouldn't use a language like C# and especially not javascript (maybe is you had some crazy streaming RIA it would matter). 

3.) Thought I'd give a hint on the algorithm problem: the largest int is not really important, there exists a number which is uses the most number (count) of distinct 2 digit primes. So no need to get caught up in questions like unsigned int? Long long int? int? ect.

Ah, glad to see you've joined the fray, Jake.  I'm on vacation in NC this week but I have an internet connection for one day.  Anyway, I hope we can all actually discuss this topic rather than resorting to a flame war -- but Jonny will be Jonny...

As for the biggest prime consec int question, the way you first posed it (verbally, not on Shiny D) ended with "and write it in your favorite language."  I think that makes the question either too easy or too hard.  Extra checks would have to be made that the current value is not approaching the max val or, conversely, it could be written in "bob++" that has a max int value of 6.  However, if that part of the question is removed and there are no language-induced size boundaries, it seems that the easiest thing to do would be to write something that loops from 99 to 01, taking each value modded by 2, 3, 5 & 7.  If all 4 comparisons fail to give a 0 result, the current number is prime and can either be appended to the front of a string or added to a counter that is constantly increasing by 100^(n) where n is the number of elements already noted as "prime."  For increased optimization, one could easily change the start and end points to the highest and lowest known primes in that range.

uberInt total = 0;

for(int i = 99; i > 0; i--){
   if(i % 2 != 0 || i % 3 != 0 || i % 5 != 0 || i % 7 != 0){
      total = i + (total * 100^n);
      n++;
   }
}

Or perhaps with some unrolling...

uberInt total = 0;

for(int i = 99; i > 0; ){
   if(i % 2 != 0 || i % 3 != 0 || i % 5 != 0 || i % 7 != 0){
      total = i + (total * 100^n);
      n++;
   }
   i--;
   if(i % 2 != 0 || i % 3 != 0 || i % 5 != 0 || i % 7 != 0){
      total = i + (total * 100^n);
      n++;
   }
   i--;
   if(i % 2 != 0 || i % 3 != 0 || i % 5 != 0 || i % 7 != 0){
      total = i + (total * 100^n);
      n++;
   }
   i--;
   if(i % 2 != 0 || i % 3 != 0 || i % 5 != 0 || i % 7 != 0){
      total = i + (total * 100^n);
      n++;
   }
   i--;
}

I believe that solves it...  now back to my vacation...  I'll be back on Monday, so Bull is in charge while I'm gone...

19737131179

Largest forwards only (a -> b):

619737131179

class Integer #let's extend integers a bit so they know if they're prime
  def prime?
    return false if self < 2
    not (2..Math.sqrt(self).floor).find { |i| self % i == 0 }
  end
end

class String #let a string determine if it's composed of pairs of primes
  def each_pair_unique_prime?
    used = []
    1.upto(length - 1) do |i|
      pair = self[i-1].chr + (self[i].chr)
      if (pair.prime? && (not used.include? pair)) then
        used << pair
      else
        return false
      end
    end
    true
  end
  
  def prime?
    self.to_i.prime?
  end
end

max = 619737131179 #theoretical maximum result

101.step(max, 2) do |x|
  xs = x.to_s
  p 'currently at: ' + xs if x % 1000000 == 1 
  p 'FOUND: ' + xs if xs.each_pair_unique_prime?
end

The largest integer such that each pair of consecutive digits is a different prime is 619,737,131,179. There are 21 two-digit primes. However, eleven of these start with an even digit or a five and can, therefore, be only at the beginning of the number. This leaves ten primes (11, 13, 17, 19, 31, 37, 71, 73, 79, 97) that can occur elsewhere in the number. Obviously, the best we can do is to use all ten of these primes to form an eleven-digit number. A little trial and error quickly shows that 19,737,131,179 is the largest number that can be formed using all ten primes. The largest of the remaining two-digit primes that ends in 1 is 61, which, when appended to the front of this number, leads to the answer above.

Ryan, here's the answer that Jake e-mailed to me.  Most of it is RJ45 to me, and I'm still not clear what forwards and backwards means, since 91 isn't prime.  I'm assuming "backwards" is a mathematical term meaning something else...?

After thinking about it (more), I realized the question has nothing to do
with the largest integer (Unsigned ect), but rather has only to do with the
consecutive pairs of prime. To begin, build a vector of 2 digit primes:

 * pn:{[n]&0,2=+/0={x!/:x}1+!n};P: pn 100;a:#P;P:$P(4+!(a-4)) *

* P *

*("11"*

* "13" *

* "17" *

* "19" *

* "23" *

* "29" *

* "31" *

* "37" *

* "41" *

* "43" *

* "47" *

* "53" *

* "59" *

* "61" *

* "67" *

* "71" *

* "73" *

* "79" *

* "83" *

* "89" *

* "97") *

* *

*Then matrix transpose the vector. Find all distinct values of the second
digit of the primes. This is 1 3 7 9. Return to a new vector all numbers
where the first digit is 1 3 7 or 9. This leaves the sucessors for each
node. *

* *

p:+P;a:?p[1];b:p[0];i:0;H:()

while[i<#a;

H:H,& a[i] ~' p[0]

i+:1]

P[H];R:+P[H]

R

("11"

"13"

"17"

"19"

"31"

"37"

"71"

"73"

"79"

"97")

* *

*Now build a 2 matricies, left and right with connectivity on the number.
See below *
  
 Lmx
 
R
 
Rmx
 
     71
 
31
 
("11"
 
13
 
17
 
19
 
  71
 
31
 
"13"
 
31
 
37
 
   71
 
31
 
"17"
 
71
 
73
 
79
 
  71
 
31
 
"19"
 
97
 
     73
 
13
 
"31"
 
11
 
13
 
17
 
19
 
73
 
13
 
"37"
 
71
 
73
 
79
 
  97
 
17
 
"71"
 
11
 
13
 
17
 
19
 
97
 
17
 
"73"
 
31
 
37
 
   97
 
17
 
"79"
 
97
 
      19
 
"97")
 
71
 
73
 
79
 
 * *

*From here it's pretty obvious, start from the tail which is the R value
where the length of Rmx=1*

* *

*.......................79*

* *

*Then fill in*

* *

*19 97 ................79*

* *

*Using recursive search (eliminate used fields) 2 nd iteration below each
time selecting max Rmx that hasn't be used.*

* *
  
 Lmx
 
R
 
Rmx
 
     71
 
31
 
("11"
 
13
 
17
 
19
 
  71
 
31
 
"13"
 
31
 
37
 
   71
 
31
 
"17"
 
71
 
73
 
79
 
  71
 
31
 
* "19"*
 
*97*
 
     73
 
13
 
"31"
 
11
 
13
 
17
 
19
 
73
 
13
 
"37"
 
71
 
73
 
79
 
  97
 
17
 
"71"
 
11
 
13
 
17
 
19
 
97
 
17
 
* "73"*
 
31
 
37
 
   97
 
17
 
* "79"*
 
*97*
 
     *79*
 
*19*
 
* "97")*
 
71
 
*73*
 
*79*
 
 * *

*Once you're done, you have the numbers *

* *

*19 97 73 37 71 13 31 17 19

*

*Select the and prime indices (2 removed) and you have *

* *

19737131179

 *This is the digit that works forwards and backwards. To just work forwards
add the largest value from the original prime vector where the second digit
is the 1 st digit of this number, or 61*

* *

619737131179

Name

E-mail (optional)

Website (optional)