Prime

I don't see it.

BTW, what's SPLIT? I didn't see that command defined in this topic. Did you design and write VNA yourself? It looks like quite a bit of programming there.

Here is using only two + and two - Or did you mean 3 +- total? Or 3 of each?

It’s been more than a week and no one could even solve Part I?! It is simply a matter of enumerating all lesser than (3,5,7) positions from which you lose, if it is your move. It is perfectly understandable if no one solves Part II. Here I have a confession to make. I’ve tried to reconstruct the solution I found 20 some years ago, and I couldn’t. So, for now, I have the answer to Part II, but not a proof/derivation. I could publish the answer to Part II, if there is an interest to this problem.

I was not referring to some selected infinite loops, but to an infinite loop in general. That is, you cannot have a computer program capable of detecting all possible infinite loops in other programs. In computability theory, this is known as Halting Problem. Actually, it was Allan Turing, who proved that theorem back in 1930s.

Surely, you mean 6 total wins and losses, for each of the 7 programs. Program does not fight itself, does it? Something similar (detection of infinite loop) has been formally proven to be impossible, even back in the 70s, if I am not mistaken.

About the tournament format. 1).The Olympic system is not the most adequate one for determining the strongest contestant, especially among computer programs. Suppose, program A can beat all other programs except program B. And program B will lose to all programs except program A. What if those two meet in the first round? Olympic system is only used in competitions with a large number of entrants, to save time at the expense of certainty in finding the strongest. 2). Matching two programs until one is ahead by 3 points, may not be feasible. I can write two programs that would chase each other forever without either one winning. With a small number of combatants, round-robin tournament is so much better. For n participants the number of matches is n*(n-1)/2. (In case of 8, it is 28 matches.) No need to battle it out until one program is ahead by 3 points. I don’t know how long each match lasts on average, but it could take forever. Consider one match between 2 participants as following: 1). Place two programs randomly in the queue. 2). Give the first move to the first program in the queue and let them fight. 3). Swap program places (same positions in the queue) and the first move and let them fight again. That would be a fair match, the outcome of which could be: a). One program won, another blew up – 2 points for a winner for the total up to 4 points in a 2-game match. b). Neither program could kill another in a reasonable time. (I presume there is no mechanism to detect such standoff, other than elapsed time.) Then each program gets 1 point. Such match could be repeated some pre-determined number times for each two programs. It does not matter how far one program got ahead of another in their match-up, or if they ended up even. In the end, when each program matched against all others, their score is totaled and the winner thus determined. If there is a tie, a tie-breaker round may be played. Having 7 players, as is the case. If we limit one program per player, the total number of matches in the round-robin tournament would be 21.

While wating for the tournament to start, I have entered 3 programs: Fish1.1-Tuna, Fish2-Flying Fish, and Fish3-Flipper. All completely different fishes. There are still couple of unclear points about the language for me: 1). I assume that VNA resolves all 3 command arguments before starting to execute the command. For example, the following program does not blow itself up on the second turn: BOMB -1;0;0 BLANK 1;0;0 SHIFT -2;-1;a(-1) BLANK Meaning the a(-1) argument in the SHIFT command would be resolved before the copy takes place. If the SHIFT command first copied the -2 node into the -1, then got to resolving its 3rd argument a(-1), the program would blow itself up on the next turn. 2). I assume, the address functions a(x), b(x), and c(x) derive the position relative to the line on which they appear -- not the line from which they were referenced. For example, N1: BLANK 0;2;0 N2: BLANK b(0);1;0 N3: BLANK a(-1);0;0 The a(-1) argument in the node3 would evaluate to "1" -- not "2". In other words, b(0) refers to the second argument on the same line, regardless that it was referenced from the next line.

Swiss format is so much more fair. What happens when there is a draw? Two cyborgs finished 1:1 after two matches with one another. Or better, yet. My program allows for a draw within a single match, when two programs hook up and chase each other endlessly.

Suggestions with respect to the tournament format. 1. The first move gives some advantage. So each pair of cyborgs should battle twice, alternating the first move. 2. The best format to determine the strongest cyborg is round robin tournament. For 8 participants, 2 matches each pair that would translate into 8*7=56 matches. 3. If that's too much, then consider swiss system: 1st round: 1 vs 5; 2 vs 6; 3 vs. 7; 4 vs 8 (two matches each.) After that, group the participants according to their score: 1st group -- those with 2 points; 2nd group those with 1 pont, and 3rd group with 0 points. Then match them again within each group. Make sure each gets a different opponent (not same match as in any of the previous rounds). If that's impossible within the same group, and/or when there are odd number of participants in a group, match cyborg from higher group with top available cyborg from the next lower group. Three rounds (total 24 matches) should be enough here.

A suggestion. If you are coming short of the required number of participants before the scheduled tournament time, you can just enter one or more of those programs that you have published already. (Like the Bomber).

OK. I'll try to submit something as simple as I can manage in the next hour or so.

You don't need actual coins to test that solution. Just imagine you set aside 30 coins. Then choose any number between 0 and 30. Say, you picked number 5. Now assume there are 5 tails among 30 coins set aside. Then there are 25 tails remaining in the other pile. There are also 25 heads in the 30-coin pile that you set aside. When you turn over every coin from the 30 set aside, you get 25 tails and 5 heads. Now recall, there are also 25 tails in the other pile. Repeat this exercise for every number of tails in the 30-coin pile between 0 and 30.

What do we know about Honestant and Swindlecant? Are we to assume one of them speaks only the truth and the other one always lie? If that's the case...

Is that difficult?

I understood, the two piles do not need to have the same number of coins, just the same number of tails.

I am not quite clear on couple points. Do you know where your program is going to be in the queue? Or is all addressing relative? How do you handle situation when program points past the end or before the beginning of the queue? Does opponent's program start in the node immediately past where your program ends? Is battle between 2 programs at a time, or all 8 of them occupy the queue at the same time? What happens when your program runs to the end without hitting a bomb?

Actually, the typo was in another equation. I meant it as x + y + 3z = 100 (That's how I had it on paper, but typed it wrong.) It is just my strange way of constructing the equations. Just because I don't like fractions and prefer whole numbers.

Still, there are many answers

Hello, Ntdo. Wellcome to the Den! Your opponent on his/her move does not have to take coins from the same row as you.

There is a short and simple formula that allows to determine correct move even with many rows and lots of coins in them. Deriving that formula is not easy. Which one of the 3 rows?

That is the correct first move. I'm assuming you are leaving it for other posters because you already know the solution.

Upon further reflection: Let S be a statement. Let P(statement) be a function: Proof of a statement. Lets designate NE(argument) as "Does not exist". Then S = NE(P(S)). Substituting S, we have: S = NE(P(NE(P(S)))). Whereupon we can substitute S again, and again… An infinite regression. I say, the statement is undecidable.

I have a personal history with this game. Long time ago, in a land far, far away...