I’m curious what type of web based coding language you would suggest as the fastest for grabbing data from various locations and passing it back and forth.

Thanks for your time sir,
Mark Essel

So it’s nice that code that’s inefficient is still tolerably fast, as it means your unit tests finish quickly, but what often matters to application performance is the degree to which you can tune the performance critical components of the system.

So to understand whether or not an application in the language can be made to perform well, you need to test code that’s as fast as the language lets you tune it. This can make a big difference – for example, languages with constant vs mutable vs copy-on-write strings which are as fast as each other in benchmarks get big differences in applications.

- memory consumption differs dramatically and can exclude Java from the list of options

- apparently sane code may run so slow that normal performance is irrelevant and the probability to hit a trap is what matters. If you want something that just works, C++/Pascal/C# are safe, Java is less safe possibly because the default VM does not JIT compile some code, and PHP/Ruby/Python may really surprise you.

reduces the time per iteration by 50%

i can optimize it further, but that would be a punch in the face of readability

static int answer(int n, int k, int[] nextAlive) {
Arrays.fill(nextAlive, 1);
int die = 0;
int temp = n – 1;
for (int ctr = 0; ctr < n – 1; ++ctr) {
for (int skipAlive = 0; skipAlive = n) {
die -= n;
}
}
nextAlive[temp] += nextAlive[die];
die += nextAlive[die];
if (die >= n) {
die -= n;
}
}
return die + 1;
}

however, this version executes in 750 microseconds on a dual core 2.6 ghz intel, so presumably it’s a bit faster … a fair comparison to your time would be 750 * 2.6/2.1 = 928 microseconds. ALSO, i’m using jdk 1.5, not 1.6, how big a difference that makes i don’ t know.

i would have thought the difference in speed would be greater, considering i’m using nothing but int’s, no object references. shows how efficient javas heap management and object reference implementation is?

static int answer(int n, int k, int[] nextAlive) {
Arrays.fill(nextAlive, 1);
int die = 0;
int temp = n – 1;
for (int ctr = 0; ctr < n – 1; ++ctr) {
for (int skipAlive = 0; skipAlive = n) {
die -= n;
}
}
nextAlive[temp] += nextAlive[die];
die += nextAlive[die];
if (die >= n) {
die -= n;
}
}
return die + 1;
}
public static void main(String[] args) {
int ITER = 100000;
long start = System.nanoTime();
int n = 40;
int[] nextAlive = new int[n];
for (int i = 0 ; i < ITER ; i++) {
answer(n, 3, nextAlive);
}
long end = System.nanoTime();
System.out.println(“Time per iteration = ” + ((end – start) / (ITER )) + ” nanoseconds.”);
}
}

** MY EXECUTION TIME ?? ** 1751 NANOSECONDS !!!

anonymous does ChurchLady superior dance, ala Dana Carvey =)

(of course C++ would probably be 2 to 4 times faster, I’m betting)

complete code list (27 lines !!! … bit obfuscated, i admit =) )
import java.util.Arrays;
public class Main {
static int answer(int n, int k) {
int[] nextAlive = new int[n];
Arrays.fill(nextAlive, 1);
int die = 0;
int temp = n – 1;
for (int ctr = 0; ctr < n – 1; ++ctr) {
for (int skipAlive = 0; skipAlive < k – 1; ++skipAlive) {
temp = die;
die += nextAlive[die % n];
}
nextAlive[temp % n] += nextAlive[die % n];
die += nextAlive[die % n];
}
return (die % n) + 1;
}
public static void main(String[] args) {
int ITER = 100000;
long start = System.nanoTime();
for (int i = 0 ; i < ITER ; i++) {
answer(40, 3);
}
long end = System.nanoTime();
System.out.println(“Time per iteration = ” + ((end – start) / (ITER )) + ” nanoseconds.”);
}
}

int answer(int n, int k) {
int[] nextAlive = new int[n];
Arrays.fill(nextAlive, 1);
int die = 0;
for(int ctr = 0; ctr < n-1; ++ ctr) {
int temp = 0;
for(int skipAlive = 0; skipAlive < k; ++ skipAlive) {
temp = die;
die += nextAlive[ die % n ];
}
nextAlive[ temp % n ] += nextAlive[ die % n ];
die += nextAlive[ die % n ];
}
return (die % n) + 1;
}

otherwise still looks ok to me

// looks ok to me at the moment … after i hit submit
// i’ll probably see a mistake ! arrgh
int answer(int n, int k) {
boolean[] hesDeadJim = new boolean[n];
Arrays.fill(hesDeadJim, false);
int die = 0;
for(int ctr = 0; ctr < n-1; ++ ctr) {
int skip = 0;
while(skip < k) {
++ die;
if (! hesDeadJim[die % n]) {
++ skip;
}
}
hesDeadJim[die % n] = true;
}
return die % n;
}