Solve a Hidato puzzle: Difference between revisions

* [[N-queens problem]]

* [[Solve a Holy Knight's tour]]

* [[Solve a Hopido puzzle]]

* [[Solve a Numbrix puzzle]]

{{trans|Python}}

 

[Int] given

V start = (-1, -1)

 

V hi =

 

setup(hi)

solve(start[0], start[1], 1)

print()

 

{{out}}

 

=={{header|AutoHotkey}}==

if (R&&C) ; if neighbors (not first iteration)

{

}

return StrReplace(map, ">")

Grid := [[ "Y" , 33 , 35 , "Y" , "Y"]

,[ "Y" , "Y" , 24 , 22 , "Y"]

;--------------------------------

MsgBox, 262144, ,% SolveHidato(Grid, Locked, Max, row, col)

Outputs:<pre>32 33 35 36 37

31 34 24 22 38

 

=={{header|Bracmat}}==

( hidato

= Line solve lowest Ncells row column rpad

: ?board

& out$(hidato$!board)

Output:

<pre>

=={{header|C}}==

Depth-first graph, with simple connectivity check to reject some impossible situations early. The checks slow down simpler puzzles significantly, but can make some deep recursions backtrack much earilier.

#include <stdlib.h>

#include <string.h>

 

return 0;

{{out}}

<pre> Before:

If there are cells that require more characters, then a 2-dimensional array of ints must be used. Any number < 0 indicates a no-go.<br/>

The puzzle can be made circular (the end cell must connect to the start cell). In that case, no start cell needs to be given.

using System.Collections.Generic;

using static System.Console;

}

 

{{out}}

<pre>

 

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

#include <iostream>

#include <sstream>

}

//--------------------------------------------------------------------------------------------------

Output:

<pre>

{{Works with|PAKCS}}

Probably not efficient.

import Constraint (andC, anyC)

import Findall (unpack)

] = success

 

{{Output}}

<pre>Execution time: 1440 msec. / elapsed: 2270 msec.

This version retains some of the characteristics of the original C version. It uses global variables, it doesn't enforce immutability and purity. This style is faster to write for prototypes, short programs or less important code, but in larger programs you usually want more strictness to avoid some bugs and increase long-term maintainability.

{{trans|C}}

 

int[][] board;

solve(start[0], start[1], 1);

printBoard;

{{out}}

<pre> . . . . . . . . . .

 

With this coding style the changes in the code become less bug-prone, but also more laborious. This version is also faster, its total runtime is about 0.02 seconds or less.

std.algorithm, std.exception, std.range, std.typetuple;

 

. . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ ."

);

{{out}}

<pre>Problem:

=={{header|Elixir}}==

{{trans|Ruby}}

#

defmodule HLPsolver do

end)

end

 

'''Test:'''

 

"""

. . 0 0 0 . 0 0 0 . 0 0 0 . 0 0 0 . 0 0 0 . 0 0 0 . 0

"""

 

{{out}}

=={{header|Erlang}}==

To simplify the code I start a new process for searching each potential path through the grid. This means that the default maximum number of processes had to be raised ("erl +P 50000" works for me). The task takes about 1-2 seconds on a low level Mac mini. If faster times are needed, or even less performing hardware is used, some optimisation should be done.

-module( solve_hidato_puzzle ).

 

 

store( {Key, Value}, Dict ) -> dict:store( Key, Value, Dict ).

{{out}}

<pre>

=={{header|Go}}==

{{trans|Java}}

 

import (

solve(start[0], start[1], 1, 0)

printBoard()

 

{{out}}

 

=={{header|Haskell}}==

{-# LANGUAGE Rank2Types #-}

 

, ". . . . 0 7 0 0"

, ". . . . . . 5 0"

{{Out}}

<pre> 0 33 35 0 0

 

This is an Unicon-specific solution but could easily be adjusted to work in Icon.

record Pos(r,c)

 

QMouse(puzzle, goWest(), self, val)

QMouse(puzzle, goNW(), self, val)

 

Sample run:

{{trans|D}}

{{works with|Java|7}}

import java.util.Collections;

import java.util.List;

}

}

 

Output:

=={{header|Julia}}==

This solution utilizes a Hidato puzzle solver module which is also used for the Hopido and knight move tasks.

 

export hidatosolve, printboard, hidatoconfigure

 

end # module

 

hidat = """

hidatosolve(board, maxmoves, kingmoves, fixed, starts[1][1], starts[1][2], 1)

printboard(board)

__ 33 35 __ __

__ __ 24 22 __

=={{header|Kotlin}}==

{{trans|Java}}

 

lateinit var board: List<IntArray>

solve(start[0], start[1], 1, 0)

printBoard()

 

{{out}}

 

=={{header|Mathprog}}==

 

Find a solution to a Hidato problem

;

Using the data in the model produces the following:

{{out}}

Model has been successfully processed

</pre>

 

=={{header|Nim}}==

 

type Hidato = object

 

 

__ 33 35 __ __ . . .

__ __ 24 22 __ . . .

__ 26 __ 13 40 11 . .

27 __ __ __ 9 __ 1 .

 

hidato.print()

echo("")

echo("Found:")

discard hidato.solve(hidato.start[0], hidato.start[1], 1)

{{out}}

<pre> . . . . . . . . . .

 

=={{header|Perl}}==

use List::Util 'max';

 

 

print "\033[2J";

32 33 35 36 37

31 34 24 22 38

 

=={{header|Phix}}==

{{out}}

<pre style="font-size: 8px">

5 6 7 . . 14 15 16 . . 23 24 25 . . 32 33 34 . . 41 42 43 . . 50 51 52 . . 59 60 61 . . 68 69 70 . . 77 78 79 . . .

solution found in 82 tries (0.02s)

</pre>

 

=={{header|PicoLisp}}==

 

(de hidato (Lst)

(disp Grid 0

'((This)

Test:

(quote

(T 33 35 T T)

(NIL NIL T T 18 T T)

(NIL NIL NIL NIL T 7 T T)

Output:

<pre> +---+---+---+---+---+---+---+---+

Works with SWI-Prolog and library(clpfd) written by '''Markus Triska'''.<br>

Puzzle solved is from the Wilkipedia page : http://en.wikipedia.org/wiki/Hidato

 

hidato :-

 

my_write_1(X) :-

{{out}}

<pre>?- hidato.

 

=={{header|Python}}==

given = []

start = None

solve(start[0], start[1], 1)

print

{{out}}

<pre> __ 33 35 __ __

immediately when tested with custom 2d vector library.

 

#lang racket

(require math/array)

;main function

(define (hidato board) (put-path board (hidato-path board)))

{{out}}

<pre>

essentially the neighbourhood function.

 

(require "hidato-family-solver.rkt")

 

#( _ _ _ _ 0 7 0 0)

#( _ _ _ _ _ _ 5 0)))))

 

{{out}}

* [[Solve the no connection puzzle#Raku|Solve the no connection puzzle]]

 

[ 0, -1], [ 0, 1],

[ 1, -1], [ 1, 0], [ 1, 1];

say "$tries tries";

 

=={{header|REXX}}==

 

''Hidato'' &nbsp; and &nbsp; ''Numbrix'' &nbsp; are registered trademarks.

maxR=0; maxC=0; maxX=0; minR=9e9; minC=9e9; minX=9e9; cells=0; @.=

parse arg xxx; PZ='Hidato puzzle' /*get the cell definitions from the CL.*/

say _

end /*r*/

'''output''' &nbsp; when using the following as input:

<br> <tt> 1 7 5 .\2 5 . 7 . .\3 3 . . 18 . .\4 1 27 . . . 9 . 1\5 1 . 26 . 13 40 11\6 1 . . . 21 . .\7 1 . . 24 22 .\8 1 . 33 35 . .</tt>

===Without Warnsdorff===

The following class provides functionality for solving a hidato problem:

#

class Hidato

(msg ? [msg] : []) + str + [""]

end

 

'''Test:'''

board1 = <<EOS

. 4

t0 = Time.now

Hidato.new(board3).solve

 

{{out}}

===With Warnsdorff===

I modify method as follows to implement [[wp:Knight's_tour#Warnsdorff|Warnsdorff]] like

#

class HLPsolver

(msg ? [msg] : []) + str + [""]

end

Which may be used as follows to solve Hidato Puzzles:

 

ADJACENT = [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0], [1, 1]]

t0 = Time.now

HLPsolver.new(board3).solve

 

Which produces:

 

=={{header|Rust}}==

use std::cmp::{max, min};

use std::fmt;

}

 

{{out}}

<pre>

</pre>

=={{header|Seed7}}==

 

var set of integer: given is {};

printBoard;

end if;

 

{{out}}

=={{header|Tailspin}}==

{{trans|Java}}

def input:

'__ 33 35 __ __ . . .

templates hidato

composer setup

$given

end setup

 

templates solve

when <{ n: <=$@hidato.given(last).n>, row: <=$@hidato.given(last).row>, col: <=$@hidato.given(last).col> }> do $@hidato.board !

otherwise

def guess: $;

def back: $@hidato.board($.row; $.col);

@hidato.board($.row; $.col): $.n;

@hidato.board($.row; $.col): $back;

end solve

 

@: $ -> setup;

end hidato

 

';

' ->!OUT::write

{{out}}

<pre>

 

=={{header|Tcl}}==

global grid max filled

set max 1

puts ""

printgrid

Demonstrating (dots are “outside” the grid, and zeroes are the cells to be filled in):

0 33 35 0 0 . . .

0 0 24 22 0 . . .

. . . . 0 7 0 0

. . . . . . 5 0

{{out}}

<pre>

{{libheader|Wren-sort}}

{{libheader|Wren-fmt}}

 

var board = []

System.print("\nFound:")

solve.call(start[0], start[1], 1, 0)

 

{{out}}

=={{header|zkl}}==

{{trans|Python}}

#<<<

"0 33 35 0 0 X X X

solve(board,given, start.xplode(), 1);

println();

d:=D(-1," ", 0,"__");

foreach r in (board[1,-1]){

board[r][c]=back;

False

{{out}}

<pre>