KenKen

html> KenKen

KenKen

Welcome to KenKen! With the 5x5 puzzle below, the only numbers you are allowed to write are 1, 2, 3, 4, and 5. No numbers may appear more than once an any row or column. Each "cage" contains a target number. You must fill that cage with numbers that produce the target number, using only the specified arithmetic operation on the cage's values in any order. Numbers may be repeated within a cage, if necessary, as long as they do not repeat within a single row or column. Enjoy!

style(square(I,J),border-left,"4px lightsteelblue solid") :-
  distinct(J,1) &
  evaluate(minus(J,1),J1) &
  square(I,J,CageID,_) &
  square(I,J1,CageID,_)

style(square(I,J),border-right,"4px lightsteelblue solid") :-
  board_size(N) &
  distinct(J,N) &
  evaluate(plus(J,1),J1) &
  square(I,J,CageID,_) &
  square(I,J1,CageID,_)

style(square(I,J),border-top,"4px lightsteelblue solid") :-
  distinct(I,1) &
  evaluate(minus(I,1),I1) &
  square(I,J,CageID,_) &
  square(I1,J,CageID,_)

style(square(I,J),border-bottom,"4px lightsteelblue solid") :-
  board_size(N) &
  distinct(I,N) &
  evaluate(plus(I,1),I1) &
  square(I,J,CageID,_) &
  square(I1,J,CageID,_)

op_str(singleton," ")
op_str(plus,"+")
op_str(minus,"-")
op_str(mult,"*")
op_str(div,"/")

innerhtml(label(I,J),Label) :-
  square(I,J,CageID,_) &
  evaluate(minimum(setofall(Idx,square(Idx,_,CageID,_))),I) &
  evaluate(minimum(setofall(Idx,square(I,Idx,CageID,_))),J) &
  cage(CageID,CageVal,Op) &
  op_str(Op,OpStr) &
  evaluate(stringappend(stringify(CageVal),OpStr),Label)

value(text(I,J),"") :-
  square(I,J,_,blank)

value(text(I,J),StrVal) :-
  square(I,J,_,Val) &
  distinct(Val,blank) &
  evaluate(stringify(Val),StrVal)

select(text(I,J),NewValStr) :: 
  square(I,J,CageID,Val) &
  evaluate(readstring(NewValStr),NewVal) &
  index(NewVal) &
  distinct(Val,NewVal) 
  ==> 
  ~square(I,J,CageID,Val) & 
  square(I,J,CageID,NewVal)

select(text(I,J),"") :: 
  square(I,J,CageID,Val) &
  distinct(Val,blank) 
  ==> 
  ~square(I,J,CageID,Val) & 
  square(I,J,CageID,blank)

invalid_row(I) :-
  index(I) &
  evaluate(countofall([I,J],square(I,J,CageID,Val) & distinct(Val,blank)),NumNonBlank) &
  evaluate(countofall(Val,square(I,J,CageID,Val) & distinct(Val,blank)),NumDistinct) &
  distinct(NumNonBlank,NumDistinct)

invalid_column(J) :-
  index(J) &
  evaluate(countofall([I,J],square(I,J,CageID,Val) & distinct(Val,blank)),NumNonBlank) &
  evaluate(countofall(Val,square(I,J,CageID,Val) & distinct(Val,blank)),NumDistinct) &
  distinct(NumNonBlank,NumDistinct)

style(square(I,J),background-color,"red") :- invalid_column(J)
style(square(I,J),background-color,"red") :- invalid_row(I)
style(square(I,J),background-color,"red") :- incorrect_square(I,J)
style(square(I,J),background-color,"green") :- correct_square(I,J)
style(square(I,J),background-color,"") :- 
  ~invalid_row(I) &
  ~invalid_column(J) &
  ~incorrect_square(I,J) &
  ~correct_square(I,J)

operates_to(plus,0,[])
operates_to(plus,CageVal,[_,_,Val]!Vals) :-
  operates_to(plus,IntermediateVal,Vals) &
  evaluate(plus(IntermediateVal,Val),CageVal)

operates_to(minus,CageVal,[[_,_,Val1],[_,_,Val2]]) :- evaluate(abs(minus(Val1,Val2)),CageVal)

operates_to(mult,1,[])
operates_to(mult,CageVal,[_,_,Val]!Vals) :-
  operates_to(mult,IntermediateVal,Vals) &
  evaluate(times(IntermediateVal,Val),CageVal)

operates_to(div,CageVal,[[_,_,Val1],[_,_,Val2]]) :- evaluate(quotient(Val1,Val2),CageVal)
operates_to(div,CageVal,[[_,_,Val1],[_,_,Val2]]) :- evaluate(quotient(Val2,Val1),CageVal)

invalid_cage(CageID) :-
  cage(CageID,CageVal,Op) &
  evaluate(countofall([I,J],square(I,J,CageID,_)),CageSize) &
  evaluate(countofall([I,J],square(I,J,CageID,Val) & distinct(Val,blank)),CageSize) &
  evaluate(setofall([I,J,Val],square(I,J,CageID,Val)),Vals) &
  ~operates_to(Op,CageVal,Vals)

style(label(I,J),color,"magenta") :-
  square(I,J,CageID,_) &
  invalid_cage(CageID)

style(label(I,J),color,"") :-
  square(I,J,CageID,_) &
  ~invalid_cage(CageID)

update_board(Board,I,J) ::
  same(Board,[RowI]) &
  same(RowI,[RightVal]) &
  square(I,J,CageID,CurrVal) &
  distinct(CurrVal,RightVal)
  ==>
  ~square(I,J,CageID,CurrVal) &
  square(I,J,CageID,RightVal)

update_board(Board,I,J) ::
  same(Board,RowI!BoardRest) &
  distinct(BoardRest,nil) &
  same(RowI,[RightVal]) &
  square(I,J,CageID,CurrVal) &
  distinct(CurrVal,RightVal) &
  evaluate(plus(I,1),I1)
  ==>
  ~square(I,J,CageID,CurrVal) &
  square(I,J,CageID,RightVal) &
  update_board(BoardRest,I1,1)

update_board(Board,I,J) ::
  same(Board,RowI!BoardRest) &
  distinct(BoardRest,nil) &
  same(RowI,[RightVal]) &
  square(I,J,CageID,CurrVal) &
  same(CurrVal,RightVal) &
  evaluate(plus(I,1),I1)
  ==>
  update_board(BoardRest,I1,1)

update_board(Board,I,J) ::
  same(Board,RowI!BoardRest) &
  same(RowI,RightVal!RowRest) &
  distinct(RowRest,nil) &
  square(I,J,CageID,CurrVal) &
  distinct(CurrVal,RightVal) &
  evaluate(plus(J,1),J1)
  ==>
  ~square(I,J,CageID,CurrVal) &
  square(I,J,CageID,RightVal) &
  update_board(RowRest!BoardRest,I,J1)

update_board(Board,I,J) ::
  same(Board,RowI!BoardRest) &
  same(RowI,RightVal!RowRest) &
  distinct(RowRest,nil) &
  square(I,J,CageID,CurrVal) &
  same(CurrVal,RightVal) &
  evaluate(plus(J,1),J1)
  ==>
  update_board(RowRest!BoardRest,I,J1)

click(solve) :: 
  solution(B)
  ==>
  update_board(B,1,1)

click(clear) ::
  square(I,J,CageID,Val)
  ==>
  ~square(I,J,CageID,Val) &
  square(I,J,CageID,blank)

click(reveal) ::
  square(I,J,CageVal,blank) &
  evaluate(minimum(setofall(Idx,square(Idx,_,_,blank))),I) &
  evaluate(minimum(setofall(Idx,square(I,Idx,_,blank))),J) &  
  solution(B) &
  get(I,B,RowI) &
  get(J,RowI,RightVal)
  ==>
  ~square(I,J,CageVal,blank) &
  square(I,J,CageVal,RightVal)

mark_correct([[I,J]]) :: correct_square(I,J)
mark_correct([I,J]!L) :: correct_square(I,J) & mark_correct(L)

mark_incorrect([[I,J]]) :: incorrect_square(I,J)
mark_incorrect([I,J]!L) :: incorrect_square(I,J) & mark_incorrect(L)

click(check) ::
  solution(B) &
  evaluate(setofall([I,J],
    square(I,J,CageVal,Val) & 
    distinct(Val,blank) &
    get(I,B,RowI) &
    get(J,RowI,Val)),
  CorrectIndices)
  ==>
  mark_correct(CorrectIndices)

click(check) ::
  solution(B) &
  evaluate(setofall([I,J],
    square(I,J,CageVal,Val) & 
    distinct(Val,blank) &
    get(I,B,RowI) &
    get(J,RowI,RightVal) &
    distinct(Val,RightVal)),
  IncorrectIndices)
  ==>
  mark_incorrect(IncorrectIndices)

click(check) :: uncheck_shown

click(uncheck) :: 
  incorrect_square(I,J)
  ==> 
  ~incorrect_square(I,J)

click(uncheck) :: 
  correct_square(I,J)
  ==> 
  ~correct_square(I,J)

click(uncheck) :: ~uncheck_shown

style(uncheck,display,"none") :- ~uncheck_shown
style(uncheck,display,"inline") :- uncheck_shown
style(check,display,"none") :- uncheck_shown
style(check,display,"inline") :- ~uncheck_shown

insert(X,[],[X])
insert(X,Y!S,X!Y!S) :-
  distinct(X,Y) &
  evaluate(min(X,Y),X)
insert(X,Y!S1,Y!S2) :-
  distinct(X,Y) &
  evaluate(min(X,Y),Y) &
  insert(X,S1,S2)

insert_set([],S,S)
insert_set(X!S1,S2,S3) :-
  insert(X,S2,SX) &
  insert_set(S1,SX,S3)

get(1,X!L,X)
get(I,X1!L,X2) :-
  evaluate(minus(I,1),I1) &
  get(I1,L,X2)

add_to_rows(L,[],[],I)
add_to_rows(L,B!Before,A!After,I) :-
  evaluate(setofall(Val,member([I,_,Val],L)),Vals) &
  evaluate(length(Vals),ValsLen) &
  evaluate(countofall(J,member([I,J,_],L)),ValsLen) &
  insert_set(Vals,B,A) &
  evaluate(plus(I,1),I1) &
  add_to_rows(L,Before,After,I1)

add_to_cols(L,[],[],J)
add_to_cols(L,B!Before,A!After,J) :-
  evaluate(setofall(Val,member([_,J,Val],L)),Vals) &
  evaluate(length(Vals),ValsLen) &
  evaluate(countofall(I,member([I,J,_],L)),ValsLen) &
  insert_set(Vals,B,A) &
  evaluate(plus(J,1),J1) &
  add_to_cols(L,Before,After,J1)

fill_in_board([],Board)
fill_in_board([I,J,Val]!L,Board) :-
  get(I,Board,RowI) &
  get(J,RowI,Val) &
  fill_in_board(L,Board)

init_board(Board,Rows,Cols,3) :-
  same(Board,[[_,_,_],[_,_,_],[_,_,_]]) &
  same(Rows,[nil,nil,nil]) &
  same(Cols,[nil,nil,nil])

init_board(Board,Rows,Cols,4) :-
  same(Board,[[_,_,_,_],[_,_,_,_],[_,_,_,_],[_,_,_,_]]) &
  same(Rows,[nil,nil,nil,nil]) &
  same(Cols,[nil,nil,nil,nil])

init_board(Board,Rows,Cols,5) :-
  same(Board,[[_,_,_,_,_],[_,_,_,_,_],[_,_,_,_,_],[_,_,_,_,_],[_,_,_,_,_]]) &
  same(Rows,[nil,nil,nil,nil,nil]) &
  same(Cols,[nil,nil,nil,nil,nil])

current_board(Board,RowsBefore,RowsAfter,ColsBefore,ColsAfter) :-
  evaluate(setofall([I,J,Val],square(I,J,_,Val) & distinct(Val,blank)),L) &
  add_to_rows(L,RowsBefore,RowsAfter,1) &
  add_to_cols(L,RowsBefore,ColsAfter,1) &
  fill_in_board(L,Board)

assign_values([],[],[])
assign_values([I,J,_]!CageIndices,Val!CageVals,[I,J,Val]!L) :-
  index(Val) &
  assign_values(CageIndices,CageVals,L)

get_cage(CageID,CageVals,L) :-
  evaluate(setofall([I,J,Val],square(I,J,CageID,Val)),CageIndices) &
  assign_values(CageIndices,CageVals,L)

valid_addition([],0)
valid_addition(X!L,CageVal) :-
  valid_addition(L,Y) &
  evaluate(plus(X,Y),CageVal)

valid_subtraction([X,Y],CageVal) :- evaluate(abs(minus(X,Y)),CageVal)

valid_multiplication([],1)
valid_multiplication(X!L,CageVal) :-
  valid_multiplication(L,Y) &
  evaluate(times(X,Y),CageVal)

valid_division([X,Y],CageVal) :- evaluate(quotient(X,Y),CageVal)
valid_division([X,Y],CageVal) :- evaluate(quotient(Y,X),CageVal)

addition_cages([],Board,Rows,Rows,Cols,Cols)
addition_cages([CageID,CageVal]!Cages,Board,RowsBefore,RowsAfter,ColsBefore,ColsAfter) :-
  get_cage(CageID,CageVals,L) &
  valid_addition(CageVals,CageVal) &
  add_to_rows(L,RowsBefore,RowsDuring,1) &
  add_to_cols(L,ColsBefore,ColsDuring,1) &
  fill_in_board(L,Board) &
  addition_cages(Cages,Board,RowsDuring,RowsAfter,ColsDuring,ColsAfter)

subtraction_cages([],Board,Rows,Rows,Cols,Cols)
subtraction_cages([CageID,CageVal]!Cages,Board,RowsBefore,RowsAfter,ColsBefore,ColsAfter) :-
  get_cage(CageID,CageVals,L) &
  valid_subtraction(CageVals,CageVal) &
  add_to_rows(L,RowsBefore,RowsDuring,1) &
  add_to_cols(L,ColsBefore,ColsDuring,1) &
  fill_in_board(L,Board) &
  subtraction_cages(Cages,Board,RowsDuring,RowsAfter,ColsDuring,ColsAfter)

multiplication_cages([],Board,Rows,Rows,Cols,Cols)
multiplication_cages([CageID,CageVal]!Cages,Board,RowsBefore,RowsAfter,ColsBefore,ColsAfter) :-
  get_cage(CageID,CageVals,L) &
  valid_multiplication(CageVals,CageVal) &
  add_to_rows(L,RowsBefore,RowsDuring,1) &
  add_to_cols(L,ColsBefore,ColsDuring,1) &
  fill_in_board(L,Board) &
  multiplication_cages(Cages,Board,RowsDuring,RowsAfter,ColsDuring,ColsAfter)

division_cages([],Board,Rows,Rows,Cols,Cols)
division_cages([CageID,CageVal]!Cages,Board,RowsBefore,RowsAfter,ColsBefore,ColsAfter) :-
  get_cage(CageID,CageVals,L) &
  valid_division(CageVals,CageVal) &
  add_to_rows(L,RowsBefore,RowsDuring,1) &
  add_to_cols(L,ColsBefore,ColsDuring,1) &
  fill_in_board(L,Board) &
  division_cages(Cages,Board,RowsDuring,RowsAfter,ColsDuring,ColsAfter)

additions(Board,RowsBefore,RowsAfter,ColsBefore,ColsAfter) :-
  evaluate(setofall([CageID,CageVal],cage(CageID,CageVal,plus)),Cages) &
  addition_cages(Cages,Board,RowsBefore,RowsAfter,ColsBefore,ColsAfter)

subtractions(Board,RowsBefore,RowsAfter,ColsBefore,ColsAfter) :-
  evaluate(setofall([CageID,CageVal],cage(CageID,CageVal,minus)),Cages) &
  subtraction_cages(Cages,Board,RowsBefore,RowsAfter,ColsBefore,ColsAfter)

multiplications(Board,RowsBefore,RowsAfter,ColsBefore,ColsAfter) :-
  evaluate(setofall([CageID,CageVal],cage(CageID,CageVal,mult)),Cages) &
  multiplication_cages(Cages,Board,RowsBefore,RowsAfter,ColsBefore,ColsAfter)

divisions(Board,RowsBefore,RowsAfter,ColsBefore,ColsAfter) :-
  evaluate(setofall([CageID,CageVal],cage(CageID,CageVal,div)),Cages) &
  division_cages(Cages,Board,RowsBefore,RowsAfter,ColsBefore,ColsAfter)

solution(Board) :- 
  board_size(N) &
  init_board(Board,Rows1,Cols1,N) &
  multiplications(Board,Rows1,Rows2,Cols1,Cols2) &
  subtractions(Board,Rows2,Rows3,Cols2,Cols3) &
  divisions(Board,Rows3,Rows4,Cols3,Cols4) &
  additions(Board,Rows4,Rows5,Cols4,Cols5)