Solve a Hidato puzzle: Difference between revisions

* [[N-queens problem]]

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

* [[Solve a Hopido puzzle]]

* [[Solve a Numbrix puzzle]]

* [[Solve the no connection puzzle]];

<br><br>

 

=={{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:

17 7 6 3

5 4</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}}==

presets = Vector{Int}()

board[i, j] = 0

continue

else # numeral, get 2 digits

push!(presets, board[i, j])

if board[i, j] == 1

end

end

end

end

 

return true

return false

end

board[row, col] = sought # try board with this cell set to next number

return true

end

end

 

map(x -> d[x] = rpad(lpad(string(x), 2), 3), 1:maximum(board))

println(join([d[i] for i in hcat(board, fill(-2, size(board)[1]))'], ""))

end

 

hidat = """

. . . . . . 5 __"""

 

printboard(board)

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}}==

 

 

 

 

__ __ 24 22 __ . . .

__ __ __ 21 __ __ . .

__ 26 __ 13 40 11 . .

27 __ __ __ 9 __ 1 .

echo("")

echo("Found:")

{{out}}

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

 

=={{header|Perl}}==

use List::Util 'max';

 

 

print "\033[2J";

32 33 35 36 37

31 34 24 22 38

17 7 6 3

5 4

 

=={{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}}

_ _ _ _ 17 7 6 3

_ _ _ _ _ _ 5 4</pre>

 

=={{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:

HLPsolver may be used to solve [[Knight's tour#Ruby|Knight's tour]]:

 

=={{header|Seed7}}==

 

var set of integer: given is {};

printBoard;

end if;

 

{{out}}

. . . . . . . 5 4 .

. . . . . . . . . .

</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>

</pre>

More complex cases are solvable with an [[/Extended Tcl solution|extended version of this code]], though that has more onerous version requirements.

 

=={{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>