I install this on literally every device I own. Windows machines, linux machines, android machines. It's a great source of small, procedurally generated puzzles. I often just put on some music and zone out playing Pearl for a while.

e: If you're on Ubuntu: sudo apt-get install sgt-puzzles

e2: I misremembered, it's not precisely Unruly--Unruly allows you to repeat rows/columns. But whatever, go install these games!

http://www.chiark.greenend.org.uk/~sgtatham/puzzles/devel/

Want to write an application that does X? Design, build, test, and document a flexible cross-platform framework that can safely and portably run any application in the domain, and then specialize it to do X!

I have to say, though, that it seems to have actually worked out for the best in this case. He added a ton of puzzles at a rapid pace and they've spread to a surprising number of platforms.

- There's no list of rules anywhere. If you forget any rule, you need to go through the tutorial again.

- Is the tutorial missing a rule? (It has the "no two identical rows" rule, but it seems like you also can't have two identical columns).

- The endgame needs work. Right now it's simply highlighting every square that's wrong, rather than just telling which rule was broken. This is absolutely ridiculous, since at that point the player can simply flip every highlighted square and pass (and score the full points?).

There are two alternatives I can think of:

a) Instead of telling which squares are wrong, find an instances of the rules being broken. So for example highlight two rows that are equal, or a column of 3 identical squares, etc.

b) End the game when the board is full, but dock points for incorrect spaces, rather than force the player to go through the busywork of just toggling all squares that were wrong.

I'm wondering if multiple solutions can exist and the game will only accept one.

    1010
    1010
    0101
    0101

edit: oh - "no two rows are the same". fail. disregard this. must have clicked past that in the tutorial.

Another way to find the rules is to use the "eye" on every turn in a 6x6 or 10x10.

Enjoyed the game play and the graphics are very smooth and clean.

The rules don't explicitly say that columns need to be unique (only rows).

Within the stated rules there are (as best I can see) 2 valid solutions to that puzzle. It is the introduction of the unstated unique column rule that resolves it.

     _______
    |     \X|
    |      \|
    |\      |
    |O\_____|
     ```````

Also, the "fixed" tiles of the puzzle need to be presented in a different style from the "dynamic" tiles the user can set.

Is there a GitHub repo for this?

Outstanding work. This is an excellent, simple and original logic game, well done.

Only negative thing I experienced: it can be tough(/not particularly fun) to find similar rows/columns when playing on larger grids. And I don't feel like finding similar complex line patterns is where the game design esthetic shines. Not sure how you could solve this. Perhaps some sort of visualization of similarity of rows for larger grids? Say two rows are identical (minus missing tiles), then the same little icon could appear to the right of each row. Icons could be differentiated by shape, or color. Just an idea. Good work :)

Disclaimer: I'm a game designer

I did similarly in a sudoku game, it is an interesting exercise that then colors your thinking about error messages in future programming.

Great for a young person, but I would like to see a version with more rules and constraints to follow.

The UI and the UI feedback is outstanding though.

1. Look for a chance to play a block that wouldn't cause a chain of 3 colors together.

2. Look so see if the row or column has enough of a certain color in it.

3. Look to see if the row or column is a duplicate of another.

1 and 2 are easier to spot, but 3 is actually quite difficult and takes a lot of time to determine. On the 10x10, option 3 is almost never the determining case, probably because there are so many more possible configurations for a row or column, vs on a 6x6.

Take this one, for instance:

  - O - - - -
  X - - O X -
  - - - - - -
  O - X - O -
  - - - - - O
  X - O - X -

  O O X X O X
  X X O O X O
  X O O X O X
  O X X O O X
  O X X O X O
  X O O X X O

  O O X X O X
  X X O O X O
  O O X O X X
  O X X O O X
  X X O X O O
  X O O X X O

That would actually make it easier, not harder. The more constrains you have the fewer possible options you have, and the easier the puzzle.

For example: I remove undo move, then you certainly have less choices but, the game is harder( even for a computer ), since you have to remember previous states which were previously accessible via undo.

That kinda limits the possible intellectual enjoyment from the game, though. Without the requirement for unique rows and columns, the game would become Simon Tatham's "Unruly" (http://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/unrul...), which is extremely fun because you need to think ahead :-)

There are puzzles of this type that require either backtracking or exceedingly complex heuristics. However, the site only seems to generate simple puzzles that do not require backtracking.

See https://news.ycombinator.com/item?id=8606098

  - - - O - -               O X X O X O
  X - - - - X               X O O X O X
  - - - - - O               X O X O X O                                         
  - - - X O X               O X O X O X
  - - - - - X               O X O O X X
  - - X - - O               X O X X O O

  B C D O 2 1 
  X 3 G N 4 X 
  M N H I 5 O 
  F E F X O X 
  L K J 6 A X 
  9 8 X 7 8 O

  1. finish column
  2. avoid OOO in row
  3. avoid OOO in row
  4. avoid OOO in row
  5. avoid OOO in column
  6. don't duplicate column 6
  7. avoid XXX in column
  8. wrap XX on both sides
  9. finish row
  A. finish column
  B. avoid OOO in column
  C. avoid XXX in column
  D. finish row
  E. don't duplicate column 5
  F. finish row
  G. avoid OOO in column
  H. avoid OOO in column
  I. avoid XXX in row
  J. finish column
  K. avoid OOO in row
  L. finish row
  M. finish column
  N. finish rows

  O X - - X O
  X - - O - -
  - O X X O -
  - - O - - -
  O - X O X -
  X O - - O -

iOS: https://itunes.apple.com/us/app/0h-h1/id936504196?mt=8 Android: https://play.google.com/store/apps/details?id=com.q42.ohhi

I don't understand what's wrong here.

The tutorial must use an example where unique rows/columns is the only way to resolve the choice...

Perhaps rather than pointing out which cells are wrong, highlight the group/row/column that break the rules instead. That might make it slightly harder.

If you are interested in those kind of puzzles there might be more logic puzzles on this page that you like.

Same for 1,2,4: 5 is of the opposite color otherwise 6-8 are of one color.

http://i.imgur.com/BU5L61L.png

Anyone see what the issue is? Been staring for 20 minutes . . .

The game should show the identical rows/columns instead of just highlighting every incorrect square... it can take a while to find out what's actually wrong with a solution.

https://github.com/Q42/0hh1

It's written in clingo (http://en.wikipedia.org/wiki/Answer_set_programming)

https://github.com/fogleman/OhHi/blob/master/main.py

         '00....',
         '110010',
         '......',
         '0.1.0.',
         '.....0',
         '1.0.10',

         '00..0.',

No, my friend and I made that one. It can be solved without guessing, but it takes another heuristic beyond the three or so that people usually use. We also have ones that require guessing (can't be solved with any reasonable heuristics as far as we know.)

I learned clingo to solve puzzles and business scheduling problems. Check out my web site http://www.takingthefun.com for other games and puzzles I've solved with it.

I have found a correct solution, yet the game doesn't accept it:

B r r B

r B B r

B B r B

B r B r

The correct solution was:

B r r B

r B B r

B B r r

r r B B

My guess to this is that there are more than one solutions to the problem and checking if the board is solved is done by finding the first solution and comparing it to yours.

It seems like the solution is always unique, for a given starting point. Is this the case?

You'll also get a first-hand view of how screwed we are in the HTML5 "standards" department,

Just dive in and you'll get used to it soon enough. Html is really easy and JS is similar to other C-like languages, css is pretty hard if you're building complex applications IMO but things like LESS and SASS make it easier to deal with.

Looking at the source it looks like everything is hand rolled except for the jQuery dependency.

http://i.imgur.com/yzD9qFL.png

edit: I see you noticed.

Friendly reminder: launch iOS/Android version before someone else does

EDIT: The history is a little more interesting than that. The janko.at page on Tohu wa Vohu[2] names many pre-existing variants: Eins und Zwei, Binary Puzzles[3], Binoxxo, and others. Binary Puzzles are notable for being paper-and-pencil puzzles, but it's not clear whether these were first paper-and-pencil puzzles or computer puzzles.

[0] http://www.chiark.greenend.org.uk/~sgtatham/puzzles/doc/unru...

[1] https://chris.boyle.name/projects/android-puzzles/

[2] http://www.janko.at/Raetsel/Tohu-Wa-Vohu/index.htm

[3] http://www.puzzle-magazine.com/binary-puzzle-magazine.php