Solve a Hopido puzzle: Difference between revisions

{{trans|Python}}

V cnt = 0

V pWid = 0

print()

E

{{out}}

=={{header|AutoHotkey}}==

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

{

}

return StrReplace(map, ">")

Grid := [["",0 ,0 ,"",0 ,0 ,""]

,[0 ,0 ,0 ,0 ,0 ,0 ,0]

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

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

Outputs:<pre> 17 24 16 25

22 8 11 21 7 10 20

Any non-numeric value indicates a no-go.<br/>

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

using System.Collections.Generic;

using static System.Console;

}

{{out}}

<pre style="height:30ex;overflow:scroll">

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

#include <vector>

#include <sstream>

return system( "pause" );

}

{{out}}

<pre>

{{trans|C++}}

From the refactored C++ version with more precise typing. This tries all possible start positions. The HopidoPuzzle struct is created at compile-time, so its pre-conditions can catch most malformed puzzles at compile-time.

else

writefln("One solution:\n%(%-(%2s %)\n%)", solution);

{{out}}

<pre>One solution:

{{trans|Ruby}}

This solution uses HLPsolver from [[Solve_a_Hidato_puzzle#Elixir | here]]

adjacent = [{-3, 0}, {0, -3}, {0, 3}, {3, 0}, {-2, -2}, {-2, 2}, {2, -2}, {2, 2}]

. . . 1 . . .

"""

{{out}}

=={{header|Go}}==

{{trans|Java}}

import (

}

printResult()

{{out}}

Minor variant of [[Solve_a_Holy_Knight's_tour]]. Works in Unicon only.

record Pos(r,c)

QMouse(puzzle, visit(loc.r, loc.c+3), self, val)

QMouse(puzzle, visit(loc.r-2,loc.c+2), self, val)

Sample run:

=={{header|Java}}==

{{works with|Java|8}}

public class Hopido {

}

}

<pre>

=={{header|Julia}}==

Uses the Hidato puzzle solver module, which has its source code listed [[Solve_a_Hidato_puzzle#Julia | here]] in the Hadato task.

const hopid = """

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

printboard(board)

0 0 0 0

0 0 0 0 0 0 0

=={{header|Kotlin}}==

{{trans|Java}}

val board = listOf(

printResult()

{{out}}

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

Uses shortest tours on graphs to solve it:

puzz //= StringSplit[#, "\n"] & /* Map[Characters];

puzz //= Transpose /* Map[Reverse];

g = Graph[UndirectedEdge @@@ moves];

ord = Most[FindShortestTour[g][[2]]];

{{out}}

Shows a graphical solution.

{{trans|Go}}

const Moves = [(-3, 0), (0, 3), ( 3, 0), ( 0, -3),

var hopido = initHopido(Board)

hopido.findSolution()

{{out}}

=={{header|Perl}}==

use strict; # http://www.rosettacode.org/wiki/Solve_a_Hopido_puzzle

. 0 0 0 0 0 .

. . 0 0 0 . .

{{out}}

<pre>

=={{header|Phix}}==

Simple brute force approach.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">board</span>

. . . 0 . . ."""</span>

<span style="color: #000000;">Hopido</span><span style="color: #0000FF;">(</span><span style="color: #000000;">board1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">)</span>

The best and worse cases observed were:

<pre>

</pre>

=={{header|Picat}}==

import sat.

main =>

if C = NC then nl end

end.

Output:

<pre> 24 15 23 26

This is a pure prolog implementation (no cuts,etc..), the only libary predicate used is select/3 witch is pure.

select(C,Grid,RGrid),

solve(RGrid,C,Solved,Xs,Ys).

j3(O,N,[O,_,_,N|_]).

To test send in a list of p/2 terms that represent points that can be hopped to (order is not important).

The grid coords can be anything so need to specify the valid coordinates as a list (in this case numbers between 0 and 6).

p(1,0),p(2,0) ,p(4,0),p(5,0),

p(0,1),p(1,1),p(2,1),p(3,1),p(4,1),p(5,1),p(6,1),

XYs = [0,1,2,3,4,5,6],

hopido(P,S,XYs,XYs),

{{out}}

<pre>

=={{header|Python}}==

from sys import stdout

else:

stdout.write("No solution!")

01 25 17 03

27 13 10 07 14 11 08

essentially the neighbourhood function.

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

#(_ _ 0 0 0 _ _)

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

{{out}}

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

[2, -2], [2, 2],

[0, -3], [0, 3],

say "$tries tries";

{{out}}

No particular effort was made to reduce the elapsed time in solving the puzzle.

call time 'Reset' /*reset the REXX elapsed timer to zero.*/

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

say _

end /*r*/

'''output''' &nbsp; when the input is: <br>

<tt> 1 4 1 \2 3 . . . \3 2 . . . . . \4 1 . . . . . . . \5 1 . . . . . . . \6 2 . . \6 5 . . </tt>

=={{header|Ruby}}==

This solution uses HLPsolver from [[Solve_a_Hidato_puzzle#With_Warnsdorff | here]]

ADJACENT = [[-3, 0], [0, -3], [0, 3], [3, 0], [-2, -2], [-2, 2], [2, -2], [2, 2]]

t0 = Time.now

HLPsolver.new(board1).solve

Which produces:

<pre>

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

oo::class create HopidoSolver {

HopidoSolver create hop $puzzle

hop solve

{{out}}

<pre>

{{libheader|Wren-sort}}

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

if (pos >= nRows * nCols) break

}

{{out}}

=={{header|zkl}}==

This solution uses the code from [[Solve_a_Numbrix_puzzle#zkl]]

#<<<

" X 0 0 X 0 0 X

println();

puzzle.print_board();

{{out}}

<pre>