About "The Dead Girl," Wilson finally said to me,

"OK I will watch it. But if it is bad, I will kill you."

I will answer the latest posts in my forum here as my forum will shut down in a day.

<I regard you to be a friend, colleague, and chess historian, and that's the spirit with which I viewed your question.>

It's the same for me, I also regard you as a friend and your contributions to this site are fantastic.

<crawfb5: <Karpova> Besides, it wasn't that well-kept a secret that lotsa was one of Jess' socks.>

I did not consider it to be a secret but there was a post py lotsa offering to share the forum and give password to someone else, so there could have been other people with access to it.

<jess>

That said, I'm not trying to convince you to join the French Foreign Legion.

Your participation in the WCC Edit Project will always be based solely on your own time and inclination.

We are a volunteer army.

Oh wait so is the French Foreign Legion...

Anyways thanks for understanding, I don't like to have any fighting in here as you know.

I did enough fighting the last two days because I can't seem to control my temper.

click for larger view

22 ... ♖a8-d8?

click for larger view

Shocked by MVL's incredible 22 ♗d4xa7!!, Moiseenko playing Black immediately blunders with 22 ... ♖a8-d8?, making this rook <LOOSE> on a square from which its <DEFENDED CAN BE ATTACKED>.

Q. How does White force instant resignation.

Hint: the Black e7-bishop <DEFENDER> of the <LOOSE> Black d8-rook can be <ATTACKED>.

A. By <REMOVING THE GUARD!>.

23 ♗a7-c5! 1-0

click for larger view

Black resigns because he will run into <THE EXCHANGE ON THE PINNING SQUARE> tactic if he tries to <PROTECT> his e7-bishop with 23 ... ♖d8-e8.

(CONTINUATION)
23 ... ♖e8-d8 24 ♖e1x♗e7!

click for larger view

click for larger view

24 ... ♖e8x♖e7 25 ♖d1-e1 <pin against king>

click for larger view

click for larger view

36 ♕b2-c1?? <left behind: a2-sq, self-block: c1-sq>

click for larger view

What an atrocious move for a GM to make! The <BLUNDER> 36 ♕b2-c1?? not only <LEAVES BEHIND> the critcal <LOOSE SQUARE NEAR THE ENEMY KING> a2-sq but by occupying a square <ADJACENT> to the White b1-king, it <SELF-BLOCKS> this crucial <FLIGHT SQUARE> of His Majesty.

The punishment is swift and severe.

36 ... ♖a8-a1+! <decoy for tempo>

click for larger view

(VARIATION)
37 ♔b1x♖a1 ♕c4-a6+ <mating>

click for larger view

click for larger view

38 ♔a1-b1 ♕a6-a2# <self-block: c1-sq>

click for larger view

<JimNorCal: Ouch!
I bet poor GM Ward missed 36. ... Ra1+. If KxR, Qa6+ and it's over.

A good Tuesday puzzle?>

I'll be the judge of who my friends are, Niels being one of the best.

I won't discuss this again, so I'm glad to hear you won't bring it up again in my forum.

I really don't like arguing, especially between mates, and mainly I don't want it in my forum.

As you well know, half the website doesn't like the other half.

That's just a fact of life.

JFQ to DcGentle:

<Good afternoon.
Pardon me for barging in. Long time listener, first time caller.

<DcGentle>, <Annie>

I'm impressed that both of you know what the word "algorithm" means.

<DcGentle> I recently read a few Wikipedia articles based on your recent posts about the <Fibonacci Word>.

I felt sad to be so "maths-impaired" that I could not understand the definition.>

################

DcGentle to JFQ:

<Hi there! I'll address these <questions> on your forum, if you don't mind. :-)>

##################

DcGentle to JFQ:

<WCC Editing Project>: Hello and good afternoon, Ok, as you can see from my bio, I have studied computer science, so I should know what an <algorithm> is. You can roughly translate this as "method to compute something", or "a step-by-step procedure for calculations", as Wikipedia says. ;-)

Computers are stupid, and on the lowest level of hardware, all computation boils down to a movement of electrical charges from one place to the other. So the abacus, this more than 4000 years old computing device ( http://en.wikipedia.org/wiki/Abacus ) still is a relative of the modern computer, something that sounds unbelievable to the layman. ;-)

Anyways, in order to get something done on the modern computer, and be it the most simple calculations, the machine needs instructions, which will be fetched from its memory during program execution.

An algorithm only describes the abstract procedure, any real computer program, that would realize this procedure, must be transferred to machine instructions. A programmer takes an algorithm as a plan to write a computer program using a computer language like C++ or Java, and this will be automatically compiled into machine instructions ready to be executed.

So we have the following:

<algorithm> --> <computer program> --> <machine instructions>.

Only after the algorithm has been transformed into machine instructions, the computer will be able to work.

DcGentle to JFQ:

<<Computation of the Fibonacci word> Part (1/2) If computer scientists or mathematicians talk about a word, they most likely mean a string, that is a sequence of characters.

While the word is a building block of natural language and has a meaning, in mathematics it is a result of a computation.

Characters belong to an alphabet, and the usual set of characters where computer scientists do their computations with is 0, 1. The smallest unit of information is a Bit, it can have the value 0 or 1.

Ok, let's move on to the Fibonacci word, which can be "computed" by concatenation of strings. "Computation" here is not meant in the sense of the usual basic numerical operations like addition, subtraction, multiplication, and division. No, it's simpler, you write down one string and append the next string just by writing it behind the first one.

Now we have a special method, how to do this and this makes up our algorithm! And we are lucky, there are even at least 2 methods describing the production of a Fibonacci word, so we can compare these algorithms and check, which one is easier!

<Algorithm A>:

The initial conditions are:

We have a string called <String_A> with value "0" and a second string <String_B> with value "01".

Procedure:

Write down <String_B> and behind this <String_A>. The result is <String_C>.

(This is the theoretical end of the procedure, if we only want to compute a VERY short Fibonacci word, but it is longer usually. So we have to prepare the next run of this procedure. We have to change the contents of <String_A> and <String_B> in order to be able to repeat the procedure. For the next run of this procedure we don't need the contents of <String_A>, but the contents of the other Strings, B & C.)

So we store the contents of <String_B> on <String_A> and <String_B> gets a new content, namely from <String_C>.

Now we can repeat the procedure as often as desired!

This is <Algorithm A> to compute the Fibonacci word.

No let's check, how it works.

<String_A> = "0"
<String_B> = "01" (according to the initial conditions.)

Procedure 1st run:
"01" "0" yields "010".
<String_A> becomes "01". <String_B> becomes "010".

Procedure 2nd run:
"010" "01" yields "01001"
<String_A> becomes "010". <String_B> becomes "01001".

Procedure 3rd run:
"01001" "010" yields "01001010"
<String_A> becomes "01001". <String_B> becomes "01001010".

Let's stop here and check the results. We have a final result, that is "01001010". But together with the initial conditions we can also write down all intermediate results by just looking at the lines with <yields>:

"0"
"01"
"010"
"01001"
"01001010"

DcGentle to JFQ

<<Computation of the Fibonacci word> Part (2/2) <Algorithm B>:

The initial conditions are:

<String_A> has value "0".

Procedure:

Examine each character of <String_A> and

if this character is equal to "0" then replace it with "01".

if this character is equal to "1" then replace it with "0".

When all replacements are done, <String_A> has the new result.

Repeat the procedure as often as desired.

This algorithm looks easier, doesn't it?

Now let's check, how it works:

<String_A> = "0" (according to the initial conditions.)

Procedure 1st run:

1. char of <String_A> = "0" --> "01"

result: <String_A> = "01"

Procedure 2nd run:

1. char of <String_A> = "0" --> "01"

2. char of <String_A> = "1" --> "0"

result: <String_A> = "010"

Procedure 3rd run:

1. char of <String_A> = "0" --> "01"

2. char of <String_A> = "1" --> "0"

3. char of <String_A> = "0" --> "01"

result: <String_A> = "01001"

Procedure 4th run:

1. char of <String_A> = "0" --> "01"

2. char of <String_A> = "1" --> "0"

3. char of <String_A> = "0" --> "01"

4. char of <String_A> = "0" --> "01"

5. char of <String_A> = "1" --> "0"

result: <String_A> = "01001010"

Let's stop here and compare the results. Looking at the <result> lines we get:

"0"
"01"
"010"
"01001"
"01001010"

And indeed these results are the same. So which algorithm did you like better? :-)

THE MOVE OF THE DAY:

26 ?

click for larger view

Q. Black has just played 25 ... ♗c6-d7, <PINNING> the White e6-knight against the <UNDEFENDED> White g4-bishop and putting the White e6-knight <EN PRISE>. What is White to do?

26 ♘e6-f8!!

click for larger view