15 puzzle game: Difference between revisions

{{trans|Python: Original, with output}}

 

position = 0

[Int = String] items

This is an entire Sega Genesis game, tested in the Fusion emulator. Thanks to Keith S. of Chibiakumas for the cartridge header, font routines, and printing logic. I programmed the actual game logic. This code can be copied and pasted into a text file and assembled as-is using vasmm68k_mot_win32.exe, no includes or incbins necessary (even the bitmap font is here too.)

 

;Ram Variables

Cursor_X equ $00FF0000 ;Ram for Cursor Xpos

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program puzzle15_64.s */

 

=={{header|Action!}}==

DEFINE X0="13"

DEFINE Y0="6"

We fist define a generic package Generic_Puzzle. Upon instantiation, it can take any number of rows, any number of columns for a rows*columns-1 game. Instead of plain numbers, the tiles on the board can have arbitrary names (but they should all be of the same length). The package user can request the name for the tile at a certain (row,column)-point, and the set of possible moves. The user can move the empty space up, down, left and right (if possible). If the user makes the attempt to perform an impossible move, a Constraint_Error is raised.

 

Rows, Cols: Positive;

with function Name(N: Natural) return String; -- with Pre => (N < Rows*Cols);

The package implementation is as follows.

 

Field: array(Row_Type, Col_Type) of Natural;

The main program reads the level from the command line. A larger level implies a more difficult instance. The default level is 10, which is fairly simple. After randomizing the board, the user can move the tiles.

 

Ada.Numerics.Discrete_Random, Ada.Command_Line;

 

4 moves!</pre>

 

 

=={{header|APL}}==

{{works with|Dyalog APL|16.0}}

⍺←4 4

(s∨.<0)∨2≠⍴s←⍺:'invalid shape:'s

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

 

=={{header|Astro}}==

 

fun mainframe(puz):

 

=={{header|AutoHotkey}}==

Grid := [], Deltas := ["-1,0","1,0","0,-1","0,1"], Width := Size * 2.5

Gui, font, S%Size%

 

==={{header|Commodore BASIC}}===

20 REM COMMODORE BASIC 2.0

30 REM ********************************

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}{{works with|ARM BBC BASIC}}{{works with|Brandy BASIC|Matrix Brandy}}

 

SIZE=4 : DIFFICULTY=3

=={{header|BQN}}==

{{trans|APL}}

FPG←{

𝕊𝕩: 4‿4𝕊𝕩;

@

}</syntaxhighlight>

FPG 10

┌─

===C89, 22 lines version===

The task, as you can see, can be resolved in 22 lines of no more than 80 characters. Of course, the source code in C is not very readable. The second example works exactly the same way, but it was written in much more human readable way. The program also works correctly for non-standard number of rows and/or columns.

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

 

===C89, short version, TTY mode===

* RosettaCode: Fifteen puzle game, C89, plain vanillia TTY, MVC

*/

 

===C89, long version, TTY/Winapi/ncurses modes===

* RosettaCode: Fifteen puzle game, C89, MS Windows Console API, MVC

*

{{libheader|System.Drawing}}

{{works with|C sharp|6}}

using System.Drawing;

using System.Linq;

 

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

#include <time.h>

#include <stdlib.h>

Tested with GnuCOBOL

 

*> This code is dedicated to the public domain

*> This is GNUCOBOL 2.0

Credit to this post for help with the inversions-counting function: [http://www.lispforum.com/viewtopic.php?f=2&t=3422]

 

 

(:use :common-lisp))

(in-package :15)

[https://easylang.online/apps/15-puzzle.html Run it]

 

textsize 13

len f[] 16

 

=={{header|F_Sharp|F#}}==

// 15 Puzzle Game. Nigel Galloway: August 9th., 2020

let Nr,Nc,RA,rnd=[|3;0;0;0;0;1;1;1;1;2;2;2;2;3;3;3|],[|3;0;1;2;3;0;1;2;3;0;1;2;3;0;1;2|],[|for n in [1..16]->n%16|],System.Random()

</pre>

=={{header|Factor}}==

combinators.short-circuit grouping io kernel literals math

math.matrices math.order math.parser math.vectors prettyprint qw

See [[15_puzzle_solver#Forth]] for a solver based on the same code.

 

 

cell 8 <> [if] s" 64-bit system required" exception throw [then]

The game plan is to start with an ordered array so that each cell definitely has a unique code, then jumble them via "random" swaps. Possible arrangements turn out to have either odd or even parity based on the number of out-of-sequence squares, and as the allowed transformations do not change the parity and the solution state has even parity, odd parity starting states should not be presented except by those following Franz Kafka. The calculation is simplified by always having the blank square in the last position, thus in the last row. Once an even-parity starting state is floundered upon, the blank square is re-positioned using allowable moves so that the parity is not altered thereby. Then the game begins: single-square moves only are considered, though in practice groups of squares could be moved horizontally or vertically rather than one-step-at-a-time - a possible extension.

 

INTEGER I,J,T !So, we're stuck with supplying the obvious.

T = I !And, only for one type at a go.

 

=={{header|FreeBASIC}}==

dim as string outstr = ""

for i as ubyte = 0 to 15

 

=={{header|Gambas}}==

'Inspiration came from: -

''http://rosettacode.org/wiki/15_Puzzle_Game

 

=={{header|Go}}==

 

import (

 

=={{header|Harbour}}==

 

#include "inkey.ch"

 

=={{header|Haskell}}==

import System.Random

 

Implementation:

 

 

genboard=:3 :0

A full game would be too big to be worth showing here, so for the purpose of giving a glimpse of what this looks like in action we replace the random number generator with a constant:

 

15 puzzle

h for help, q to quit

=={{header|Java}}==

{{works with|Java|8}}

 

import java.awt.*;

=={{header|Javascript}}==

Play it [http://paulo-jorente.de/webgames/15p/ here]

var board, zx, zy, clicks, possibles, clickCounter, oldzx = -1, oldzy = -1;

function getPossibles() {

 

=={{header|Julia}}==

using Random

 

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.awt.BorderLayout

{{trans|Commodore BASIC}}

{{works with|Just BASIC}}

' 15-PUZZLE GAME

' ********************************

 

=={{header|LiveCode}}==

#Please note that all this code can be performed in livecode with just few mouse clicks

#This is just a pure script exampe

 

=={{header|Lua}}==

math.randomseed( os.time() )

local puz = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0 }

Also the code is not the best, because we can move from 4 position to 5 (we can't do that with real puzzle)

 

Module Puzzle15 {

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

Move[x_] := (empty = Select[grid, #[[1]]==16 &][[1,2]];

The ideal in Mercury is to have a declarative module that encodes the game logic, and then separate modules to implement a human player with text commands (here), or keyed commands, or some kind of AI player, and so on. fifteen.print/3 is a arguably a smudge on fifteen's interface:

:- interface.

:- use_module random, io.

As used:

 

:- interface.

:- import_module io.

 

=={{header|Nim}}==

 

type

 

=={{header|OCaml}}==

struct

type t = int array

=={{header|Pascal}}==

This is Free Pascal(version >= 3.0.4) text mode implementation. To make a move, the user needs to enter the number of the selected tile.

program fifteen;

{$mode objfpc}

On verbosity shows how the solvability is calculated. The program has some extra feature like font size and color scheme but also the possibility to set the intial board disposition.

This program was originally posted by me at [http://www.perlmonks.org/?node_id=1192660 perlmonks]

 

use strict;

===console version===

This short console program just poses solvable puzzles: it achieves this shuffling a solved board n times, where n defaults to 1000 but can be passed as first argument of the program in the command line. It was originally posted by me at [http://www.perlmonks.org/?node_id=1192865 perlmonks] but here a little modification was inserted to prevent wrong numbers to make the board messy.

use strict;

use warnings;

=== console only ===

Kept simple. Obviously, increase the 5 random moves for more of a challenge.

<span style="color: #008080;">constant</span> <span style="color: #000000;">ESC<span style="color: #0000FF;">=<span style="color: #000000;">27<span style="color: #0000FF;">,</span> <span style="color: #000000;">UP<span style="color: #0000FF;">=<span style="color: #000000;">328<span style="color: #0000FF;">,</span> <span style="color: #000000;">LEFT<span style="color: #0000FF;">=<span style="color: #000000;">331<span style="color: #0000FF;">,</span> <span style="color: #000000;">RIGHT<span style="color: #0000FF;">=<span style="color: #000000;">333<span style="color: #0000FF;">,</span> <span style="color: #000000;">DOWN<span style="color: #0000FF;">=<span style="color: #000000;">336</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">board</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">tagset<span style="color: #0000FF;">(<span style="color: #000000;">15<span style="color: #0000FF;">)<span style="color: #0000FF;">&<span style="color: #000000;">0<span style="color: #0000FF;">,</span> <span style="color: #000000;">solve</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">board</span>

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/15game.htm here].

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\15_puzzle_game.exw

=={{header|PHP}}==

OOP and MVC design pattern has been used to facilitate any improvements, e.g. tiles with graphics instead of just numbers.

// Puzzle 15 Game - Rosseta Code - PHP 7 as the server-side script language.

 

 

=={{header|Picat}}==

import util.

 

Board is always scrambled from a solved board so it's always solvable.

Written in ISE with ISESteroids. I'm sure the code could be improved on.

#15 Puzzle Game

$Script:Neighbours = @{

 

=={{header|Processing}}==

int number_of_grid_cells = 16; // Set the number of cells of the board here 9, 16, 25 etc

color piece_color = color(255, 175, 0);

==={{header|Processing Python mode}}===

{{trans|Processing}}

num_grid_cells = 16

piece_color = color(255, 175, 0)

Numbers are displayed in Hexadecimal (ie 1 to F)

Default controls are u,d,l,r

#difficulty=10 ;higher is harder

#up="u"

{{works with|Python|3.X}}

'''unoptimized'''

''' Structural Game for 15 - Puzzle with different difficulty levels'''

from random import randint

 

===Python: using tkinter===

''' Python 3.6.5 code using Tkinter graphical user interface.'''

 

 

=={{header|QB64}}==

_TITLE "GUI Sliding Blocks Game "

RANDOMIZE TIMER

=={{header|Quackery}}==

The inputs are w,s,a,d and they refer to the direction in which the empty place "moves". After every prompt you can input a string of characters and submit them by pressing enter. Any characters other than w,s,a,d will be ignored, and moves will be performed according to the correct commands. Commands that would "move" the empty space off the edge of the puzzle are also ignored. For example, on a solved puzzle "asgw" would move 15 to the right, ignore 's' and 'g' and move 11 down.

( moves: 0 - up, 1 - down, 2 - left, 3 - right )

 

=={{header|R}}==

The inputs are w,a,s,d and they refer to the direction in which the adjacent piece moves into the empty space. For example, on a solved puzzle, "d" would move the 15 to the right.

puz15<-function(scramble.length=100){

m=matrix(c(1:15,0),byrow=T,ncol=4)

It uses the <code>2htdp/universe</code> package.

 

(require 2htdp/universe 2htdp/image racket/list racket/match)

 

{{works with|Rakudo|2018.06}}

Most of this is interface code. Reused substantial portions from the [[2048#Raku|2048]] task. Use the arrow keys to slide tiles, press 'q' to quit or 'n' for a new puzzle. Requires a POSIX termios aware terminal. Ensures that the puzzle is solvable by shuffling the board with an even number of swaps, then checking for even taxicab parity for the empty space.

 

constant $saved = Term::termios.new(fd => 1).getattr;

 

=={{header|Rebol}}==

if not find [0x108 108x0 0x-108 -108x0] face/offset - e/offset [exit]

x: face/offset face/offset: e/offset e/offset: x] across

 

=={{header|Red}}==

Red [Needs: 'view]

system/view/screens/1/pane/-1/visible?: false ;; suppress console window

 

Over half of the REXX program has to do with input validation and presentation of the puzzle (grid).

parse arg N seed . /*obtain optional arguments from the CL*/

if N=='' | N=="," then N=4 /*Not specified? Then use the default.*/

=={{header|Ring}}==

 

# Project : CalmoSoft Fifteen Puzzle Game

# Date : 2018/12/01

 

=={{header|Ruby}}==

 

class Board

{{libheader|JRubyArt}}

Gui Version:-

SOLUTION = %w[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0].freeze

 

 

=={{header|Run BASIC}}==

' ---- fill 15 squares with 1 to 15

dim sq(16)

=={{header|Rust}}==

{{libheader|rand}}

use std::collections::HashMap;

 

=={{header|Scala}}==

 

import jline.console._

=={{header|Scheme}}==

 

(import (scheme base)

(scheme read)

=={{header|Scilab}}==

 

solution=[tiles(1:4);...

tiles(5:8);...

 

=={{header|Simula}}==

BEGIN

CLASS FIFTEENPUZZLE(NUMTILES, SIDE, WIDTH, SEED);

{{works with|SML/NJ}}

{{works with|Moscow ML}}

(* Load required Modules for Moscow ML *)

load "Int";

The window-title is used to show messages.

 

# http://wiki.tcl.tk/14403

 

This plays the game in an ANSI-compliant terminal using vi/nethack movement keys to slide the tiles.

 

main() {

local puzzle=({1..15} " ") blank moves_kv i key count total last

The last move is displayed on the input box, or an error message if an invalid move is attempted. When the puzzle is solved, the move count is displayed.

 

Public iSide As Integer

Public iSize As Integer

 

=={{header|Visual Basic .NET}}==

Inherits System.Windows.Forms.Form

 

[https://youtu.be/rWy3AX5HjXM 15 Puzzle in Visual Prolog - video]

 

/* ------------------------------------------------------------------------------------------------------

 

 

=={{header|VBScript}}==

'----------------15 game-------------------------------------

'WARNING: this script uses ANSI escape codes to position items on console so

{{libheader|Wren-ioutil}}

{{libheader|Wren-fmt}}

import "/dynamic" for Enum

import "/ioutil" for Input

 

=={{header|x86-64 Assembly}}==

; How to play ?.. Just press one of the arrow keys then [enter] to valid

; ( press [Ctrl+C] to escape )

{{trans|Liberty BASIC}}

{{works with|Windows XBasic}}

PROGRAM "fifteenpuzzlegame"

VERSION "0.0001"

 

=={{header|XPL0}}==

[Box:= [^ ,^F,^E,^D, \starting configuration

^C,^B,^A,^9, \slide digits into ascending order

 

=={{header|Yabasic}}==

dim grid(dx, dy)

 

 

Adaptation from Phix solution

solve$ = board$

pos = 16