Flipping bits game: Difference between revisions

Show an example of a short game here, on this page, for a   '''3×3'''   array of bits.

<br><br>

 

=={{header|8080 Assembly}}==

This program runs under CP/M and takes the board size from the command line.

 

;;; CP/M zero page locations

cmdln: equ 80h

xabcdat: ds 4 ; RNG state

board: equ $

 

{{out}}

 

This program runs under MS-DOS and takes the board size from the command line.

cpu 8086

;;; MS-DOS PSP locations

xabcdat: resb 4 ; Four byte RNG state

board: resb 64 ; 8*8 board

 

{{out}}

You win!

C:\></pre>

 

=={{header|Ada}}==

This solution determines the size of the playground from the command line.

 

 

procedure Flip_Bits is

-- summarize the outcome

Ada.Text_IO.Put_Line("Done after" & Natural'Image(Moves) & " Moves.");

 

{{out}}

{{works with|GNU APL}}

 

 

∇r←b FlipRow ix ⍝ Flip a row

∇

Game

 

{{out}}

{{incomplete|AutoHotkey|Understood comment on why output is missing, but this is to make that fact more prominent.}}

Uploads are currently disabled, so since a GUI is used, I can't show an example.

Gui, Add, Button, , O

Loop, %size%

GuiClose:

ExitApp

 

=={{header|BASIC}}==

20 PRINT "*** FLIP THE BITS ***"

30 INPUT "Board size";S

500 IF R THEN 510 ELSE 520

510 FOR I=1 TO S: B(I,N)=1-B(I,N): NEXT I: RETURN

{{out}}

<pre>*** FLIP THE BITS ***

 

You win! Moves: 3 </pre>

 

=={{header|C}}==

#include <stdio.h>

#include <stdlib.h>

}

}

{{out}}

<pre>

 

=={{header|C++}}==

#include <time.h>

#include <iostream>

int main( int argc, char* argv[] )

{ srand( time( NULL ) ); flip g; g.play( 3, 3 ); return system( "pause" ); }

{{out}}

<pre>

 

=={{header|Clojure}}==

(mapv vec (apply map list board)))

 

(println "Target")

(print-board target-board)

 

{{out}}

=={{header|D}}==

{{trans|Python}}

std.algorithm, std.conv;

 

 

"\nWell done!".writeln;

{{out}}

<pre>T prints the target, and Q exits.

{{works with|Elixir|1.1}}

{{trans|Ruby}}

@az Enum.map(?a..?z, &List.to_string([&1]))

@in2i Enum.concat(Enum.map(1..26, fn i -> {to_string(i), i} end),

end

 

 

{{out}}

=={{header|FOCAL}}==

 

01.20 A "SIZE",N;I (N-2)1.2;I (8-N)1.2

01.30 F I=0,N*N-1;D 3.2;S G(I)=A;S B(I)=A

05.60 I (A-2)5.7;T "C";R

05.70 I (A-1)5.8;T "B";R

 

{{out}}

 

YOU WIN!</pre>

 

=={{header|Fortran}}==

This version uses some routines (like rand(), srand() and date_and_time()) from the GNU Fortran compiler. Formats are used to print data on the screen in an appropriate manner. The number of rows (or columns) is a variable and the current implementation allows for any number between 1 and 10. Incorrect inputs are also verified.

 

!Implemented by Anant Dixit (October 2014)

program flipping_bits

end do

end subroutine

 

Example:

</pre>

 

 

 

import (

}

return o

{{out}}

<pre>

=={{header|Haskell}}==

Maximum game size is 9x9 because the array indices are the characters 1 until 9.

 

import System.Random (randomRIO)

tryAgain = do

putStrLn ": Invalid row or column."

{{Out}}

<pre>Select a board size (1 - 9).

Using J's command line as the game ui:

 

Moves=:0

N=:i.y

Board;End

end.

 

Example:

 

┌─────┬─────┐

│1 1 1│1 0 1│

move '1'

3 moves

 

Note that any size game may be generated but this version only recognizes column flips for the first ten columns.

[[File:Flipping_bits_java.gif|200px|thumb|right]]

{{works with|Java|8}}

import java.awt.event.*;

import java.util.*;

});

}

<pre>The target

[0, 1, 0]

 

=={{header|JavaScript}}==

function numOfCols(board) { return board[0].length; }

function boardToString(board) {

alert('Completed in ' + moves + ' moves.');

}

<pre>Try to match both boards.

Enter `r<num>` or `c<num>` to manipulate a row or col or enter `q` to quit.

 

=={{header|Julia}}==

 

using Printf, Random

 

FlippingBitsGame.play()

<pre>Insert the size of the matrix (nrow [> 1] *space* ncol [> 1]):3 3

 

 

=={{header|Kotlin}}==

 

import java.util.Random

val plural = if (flips == 1) "" else "s"

println("You've succeeded in $flips flip$plural")

 

{{out}}

 

=={{header|Lua}}==

target, board, moves, W, H = {}, {}, 0, 3, 3

 

math.randomseed( os.time() )

play()

{{out}}

<pre>

=={{header|Maple}}==

Click [http://maplecloud.maplesoft.com/application.jsp?appId=5721146878066688 here] to play this game online.

export ModuleApply;

local gameSetup, flip, printGrid, checkInput;

end module:

 

{{out}}

<pre>

You win!! Press enter to play again or type END to quit.

</pre>

 

=={{header|MATLAB}}==

Size can be passed in as an argument or entered after a prompt.

% Play the flipping bits game on an n x n array

end

fprintf('\n')

{{out}}

Normal play and winning:

 

=={{header|MiniScript}}==

// Transform a start grid to an end grid by flipping rows or columns.

 

flipAny(inp)

end while

 

{{out}}

Translation of Kotlin program with some modifications.

 

 

type

 

let plural = if flips == 1: "" else: "s"

 

{{out}}

 

=={{header|OCaml}}==

struct

type t = bool array array

if not !Sys.interactive then

(Random.self_init ();

 

{{out}}

valid rows or columns, and disregards any irrelevant text in between.

 

use warnings qw(FATAL all);

 

my $n = shift(@ARGV) || 4;

{

for(@rows, @cols) {

}

redo if $start eq $goal;

$did_one = 1;

if( /\d/ ) {

} else {

$_ = ord(lc) - ord('a');

}

++$moves_so_far;

}

}

{{out}}

<pre>$ perl FlippingBitsGame.pl 3

 

=={{header|Phix}}==

 

string board, target

end while

end procedure

{{out}}

<pre>

 

=={{header|PL/I}}==

flip: procedure options (main);

declare n fixed binary;

end;

 

{{out}}

<pre>

 

=={{header|Python}}==

Given a %i by %i sqare array of zeroes or ones in an initial

configuration, and a target configuration of zeroes and ones

turns -= 1

else:

 

{{out}}

 

=={{header|QB64}}==

RANDOMIZE TIMER

DIM SHARED cellsPerSide, legalMoves$, startB$, currentB$, targetB$, moveCount

getKey$ = k$

END FUNCTION

'''Output:'''

Flipping Bits Game, now with AI! b+ 2017-12-18

 

 

--------------------------------------------------------------------------------

 

=={{header|Racket}}==

(define (flip-row! pzzl r)

(define N (integer-sqrt (bytes-length pzzl)))

[else (printf "unrecognised character in input: ~s~%" else)

(turn n)])]))

 

{{out}}

Pass in a parameter to set the square size for the puzzle. (Defaults to 4.) Arbitrarily limited to between 1 and 26. Yes, you can choose to solve a 1 element square puzzle, but it won't be very challenging. Accepts upper or lower case letters for columns. Disregards any out-of-range indices. Enter a blank or 0 (zero) to exit.

 

say "{$square}? Seriously?" and exit if $square < 1 or $square > 26;

my %bits = map { $_ => %( map { $_ => 0 }, ('A' .. *)[^ $square] ) },

@keys.push: | keys %hash{'1'};

flip $_, %hash for @keys.pick( @keys/2 );

A sample 3 x 3 game might look like this:

<pre>Goal

Hurray! You solved it in 3 turns.</pre>

=={{header|Red}}==

Red []

random/seed now/time/precise ;; start random generator

flip inp

] ;; 42 lines :- )

{{out}}

<pre>

<br>Programming note: &nbsp; none of the command line parameters &nbsp; ('''N''' &nbsp; and &nbsp; '''u''') &nbsp; are checked for errors (so as to make the

<br>program simpler). &nbsp; A fair amount of coding was added to check for a legal "move".

parse arg N u seed . /*get optional arguments from the C.L. */

if N=='' | N=="," then N=3 /*Size given? Then use default of 3.*/

if tell then call hdr right(r, 2) ' │'_ tx; _= /*show the grid? */

end /*r*/ /*show a grid row.*/

{{out|output|text=&nbsp; when using the default input of: &nbsp; &nbsp; <tt> 3 </tt>}}

 

 

=={{header|Ring}}==

load "guilib.ring"

load "stdlib.ring"

next

next

Output:

 

 

=={{header|Ruby}}==

def initialize(size)

raise ArgumentError.new("Invalid board size: #{size}") if size < 2

rescue => e

puts e.message

 

Sample game:

 

=={{header|Rust}}==

// For random generation

extern crate rand;

} // 'mainloop

}

{{out}}

<pre>

{{libheader|Scala GUI Game}}

{{works with|Scala|2.13}}

import java.awt.event.{MouseAdapter, MouseEvent}

 

}

 

{{output?|Scala}}

 

=={{header|Swift}}==

{{works with|Swift 2.0}}

 

struct Board: Equatable, CustomStringConvertible {

let game = FlippingGame(boardSize: 3)

repeat { } while playGame(game) == "y"

{{Out}}

<pre>

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

 

oo::class create Flip {

Flip create flip 3

flip play

{{out|Example game}}

<pre>

 

You win! (You took 2 moves.)

</pre>