wana have fun?
try to be creative by solving this problem in as many ways as you can:

you are writing a program (in a C-like language, or whatever), and you have a variable k which is either equal to 1 or 2.
find as many ways as possible so that if k is 1 then it becomes 2, and if k is 2 then it becomes 1.

this problem was given to us in a "basic" computer course at the begining of this year...
quite a simple question, but with so many answers...
some relate to math, geometry and programming tricks...
I found it fun, and thought you might too

I'll post all answers I know sometime next week, until then, post what you find...


(I have a feeling that robert will get real creative here...)

I really do find it all.

[pedrodinis]

you could always do
k = 3-k

it's pretty simple and does the job.
and it work for every language too

[bit-101]

as MANY POSSIBLE ways?

not the best, shortest, most elegant way?

how about

if(k==1){
  k=2;
} else {
  k=1;
}

k=(k==1)?2:1;

if(!(k--)) k=2;

[Syzla]

k=(k%=2)+1;

or

k=k%2+1;

[pedrodinis]

k = !(k-1) + 1;

[Basta]

looking good, but there are still some missing
it's a real brain twister once you get into it...

[eighty]

// This is a boring one
switch (k) {
  case 1:
    k = 2;
  case 2:
    k = 1;
}

// This requires another variable bool b
k = ++b + 1;

// Geometry!
k = 1 + sin(asin(k-1) + PI/2);

// Another..
k = pow(2,2-k);

// Some bitshift
(k-1)? (k >>= 1) : (k <<= 1);

[robpenner]

function flip (k) {
	return (Math.log(k)) ? --k : ++k;
};

[bit-101]

let's go bit-wise!

k=(((k&1)<<2)|k)>>1;

might be able to remove some of those parentheses. not sure.

[robpenner]

function flip (k) {
	return (Math.sqrt(--k)) + 2*(!k);
};

[robpenner]

function flip (k) {
	return 1-(k--*--k);
};

[robpenner]

k=1+!(--k/k);

[robpenner]

k=!(++k%--k)+1;

[bit-101]

i like the bitwise ones.

k=(k>>1|k<<1)&3;

[robpenner]

k=2/k;

[robpenner]

k=Math.abs(k*3-5);

[robpenner]

k=Math.ceil(Math.cos(k))+1;

[robpenner]

k=Math.round(2.4-k/2);

[robpenner]

k=2-Math.floor(Math.tan(--k));

[bit-101]

i think rob likes this.

[robpenner]

k=Math.abs((k^2)-1);

[robpenner]

Originally posted by bit-101
i think rob likes this.

I'm just trying to boost my post count.

[Basta]

(I have a feeling that robert will get real creative here...)

I knew this would happen

there are some great solutions here... some I didn't know

but there are still some (one or two) that I know that haven't been posted

I'll post them monday or something (I'm giving more time to robert, so that he can have more fun...)


useless maths are so fun

[Dickee]

// fun with arrays

// init array for options 1,2,3
aNum = [1];

// option 1:
if (aNum.length==1) aNum.push(2);
else aNum.pop();

// option 2:
if (aNum.length==2) aNum.splice(1,1);
else aNum.push(2);

// options 1 and 2 return options:
k = aNum.length;
// or ...
k = aNum[aNum.length-1];

////////////////////////////////

// option 3:
if (aNum.length==1) aNum.push(2), k = aNum[1];

// option 3 return options:
else k = aNum.shift(), aNum = [k];
// or ...
else aNum.pop(), k = aNum[0];

////////////////////////////////////////////////////////

// init array for options 4,5
aNum = [1,2];

// option 4:
aNum.reverse();
k = aNum[0];

// option 5:
if (k==1) aTemp = aNum.slice(1);
else aTemp = aNum.slice(0,-1);
k = aTemp[0];

Richard

[Dickee]

// init array
aNum = [1,2];

// option 6 - uses all 13 methods of the Array object
// caution: some code snippets may include redundancy :D
function dohseedohAllMethods() {
    var a = aNum.splice(0,1).slice(-1); 
    aNum.unshift(a);
    var b = aNum.splice(1).slice(0);
    aNum.push(b);
}
var aTemp = aNum.concat();
aNum.sort(dohseedohAllMethods);
(aTemp[0]==aNum[0]) ? (aNum.reverse(),k=aNum[0]) : 
	              (aNum.toString().join(),k=aNum[1]);
c = aTemp.pop();
d = aTemp.shift();
aSorter = [{e:c,f:d},{e:d,f:c}];
aSorter.sortOn(f);
(!aTemp.length) ? (c=null,delete d,aSorter=undefined) : 
                  (delete c,d=undefined,aSorter=null);

Richard

[Basta]

So here are the ones I knew about:

// the 3 boring ones

if (k==1) {
k=2;
} else {
k=1;
}

//

switch (k) {
case 1:
k=2;
case 2:
k=1;
}

//

k=(k==1) ? 2 : 1;

// two nice and efficient ones

k=3-k;

//

k=2/k;

// array

j=[0,2,1];
k=j[k];

// mod

k=k%2+1;

// pow

k=k-Math.pow(-1,k);

// boolean

k=!(k-1)+1;

so, that's it...

did you kids have fun?

[Basta]

more that I found...

// trigo
k=sin(PI*k/2)+1;
//
k=cos(PI/k)+1;

// complex: this won't work in C, because
// C doesn't get complex numbers, but it
// would work in FORTRAN if it were rewritten
// properly (I"m not sure of the function names...)
// btw, i is equal to the square root of -1
// (yes, that's minus one...)
// oh, and ** simply means pow (or ^)

k=real(i**k+1)+img(i**k+1)

[Basta]

http://www.holger-kohnen.de/ linked to this thread, so I thought I'd revive it (it's a great blog, by the way)

when you think about it, there is an infinite number of ways to solve this problem