Endless maze
Endless maze is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
- Task
This program randomly generates a potentially endless maze. It can be traversed by entering the subjective direction to go into. The purpose of it is to compare different programming languages.
AppleScript's syntax is really not the best fit for this task...but somehow, it works!
set xp to 127
set yp to 127
set na to 0
set e to {}
set x to {}
set y to {}
set d to -1
set f to random number from 1 to 4
repeat while d is not 5
set a to na + 1
repeat with n from 1 to na
if item n of x = xp and item n of y = yp then
set a to n
exit repeat
end if
end repeat
if a = na + 1 then
set na to na + 1
set x to x & xp
set y to y & yp
repeat 4 times
set e to e & some item of {true, false}
end repeat
repeat with n from 1 to na
if item n of x = (item a of x) + 1 and item n of y = item a of y then
set item (4 * (a - 1) + 1) of e to item (4 * (n - 1) + 3) of e
end if
if item n of x = item a of x and item n of y = (item a of y) + 1 then
set (item (4 * (a - 1) + 2) of e) to item (4 * (n - 1) + 4) of e
end if
if item n of x = (item a of x) - 1 and item n of y = item a of y then
set (item (4 * (a - 1) + 3) of e) to item (4 * (n - 1) + 1) of e
end if
if item n of x = item a of x and item n of y = (item a of y) - 1 then
set (item (4 * (a - 1) + 4) of e) to item (4 * (n - 1) + 2) of e
end if
end repeat
end if
set pathlist to {}
if item (4 * (a - 1) + f) of e then
set pathlist to pathlist & "ahead "
end if
repeat with i from 1 to 3
if item (1 + 4 * (a - 1) + ((f - 1 + i) mod 4)) of e then
set pathlist to pathlist & item i of {"right ", "back ", "left "}
end if
end repeat
set d to -1
repeat while d < 0
display alert ("Paths: " & pathlist as text)
set entry to text returned of (display dialog "Choose a path:" default answer "")
if entry = "ahead" then
set d to f
else if entry = "right" then
set d to 1 + (f mod 4)
else if entry = "back" then
set d to 1 + ((f + 1) mod 4)
else if entry = "left" then
set d to 1 + ((f + 2) mod 4)
else if entry = "exit" then
if xp = 127 and yp = 127 then
display alert "You have exited the maze."
set d to 5
else
display alert "You are not at the exit."
end if
else if entry = "quit" then
set d to 5
else
display alert "Invalid entry."
end if
end repeat
if d = 1 then
if item (4 * (a - 1) + 1) of e then
set xp to xp + 1
set d to f
else
set d to -1
end if
else if d = 2 then
if item (4 * (a - 1) + 2) of e then
set yp to yp + 1
set d to f
else
set d to -1
end if
else if d = 3 then
if item (4 * (a - 1) + 3) of e then
set xp to xp - 1
set d to f
else
set d to -1
end if
else if d = 4 then
if item (4 * (a - 1) + 4) of e then
set yp to yp - 1
set d to f
else
set d to -1
end if
end if
if d < 0 then display alert "No path."
end repeat
xp = 127
yp = 127
a = 0
na = 0
f = int(rand * 4)
dim x[1]
dim y[1]
dim e[1]
while true
a = na
for n = 0 to na - 1
if x[n] = xp and y[n] = yp then
a = n
exit for
end if
next
if a = na then
na = na + 1
redim x[na]
redim y[na]
redim e[4 * na]
x[a] = xp
y[a] = yp
for n = 0 to 3
e[4 * a + n] = int(rand * 2)
next
for n = 0 to na - 1
if x[n] = x[a] + 1 and y[n] = y[a] then
e[4 * a + 0] = e[4 * n + 2]
else
if x[n] = x[a] and y[n] = y[a] + 1 then
e[4 * a + 1] = e[4 * n + 3]
else
if x[n] = x[a] - 1 and y[n] = y[a] then
e[4 * a + 2] = e[4 * n + 0]
else
if x[n] = x[a] and y[n] = y[a] - 1 then
e[4 * a + 3] = e[4 * n + 1]
end if
end if
end if
end if
next
end if
print "Paths:";
dim paths$(4)
paths$[0] = " ahead"
paths$[1] = " right"
paths$[2] = " back"
paths$[3] = " left"
for n = 0 to 3
if e[4 * a + ((f + n) mod 4)] = 1 then print paths$[n];
next
print
d = -1
entry$ = ""
while d < 0
input "> ", entry$
entry$ = lower(entry$)
begin case
case entry$ = "ahead"
d = (f + 0) mod 4
case entry$ = "right"
d = (f + 1) mod 4
case entry$ = "back"
d = (f + 2) mod 4
case entry$ = "left"
d = (f + 3) mod 4
case entry$ = "quit"
end
else
print "Invalid input."
end case
begin case
case d = 0
if e[4 * a + 0] then xp = xp + 1 : f = d else d = -1
case d = 1
if e[4 * a + 1] then yp = yp + 1 : f = d else d = -1
case d = 2
if e[4 * a + 2] then xp = xp - 1 : f = d else d = -1
case d = 3
if e[4 * a + 3] then yp = yp - 1 : f = d else d = -1
end case
if d < 0 then print "No path."
end while
end while
100 cls
110 maxn = 1000
120 dim x(maxn)
130 dim y(maxn)
140 dim e(4*maxn)
150 xp = 127
160 yp = 127
170 a = 0
180 na = 0
190 randomize timer
200 f = int(rnd(4))
210 while true
220 a = na
230 for n = 0 to na-1
240 if x(n) = xp and y(n) = yp then
250 a = n
260 exit for
270 endif
280 next n
290 if a = na then
300 if na < maxn then
310 x(na) = xp
320 y(na) = yp
330 for n = 0 to 3
340 e(4*na+n) = int(rnd(2))
350 next n
360 for n = 0 to na-1
370 if x(n) = x(na)+1 and y(n) = y(na) then
380 e(4*na+0) = e(4*n+2)
390 elseif x(n) = x(na) and y(n) = y(na)+1 then
400 e(4*na+1) = e(4*n+3)
410 elseif x(n) = x(na)-1 and y(n) = y(na) then
420 e(4*na+2) = e(4*n+0)
430 elseif x(n) = x(na) and y(n) = y(na)-1 then
440 e(4*na+3) = e(4*n+1)
450 endif
460 next n
470 na = na+1
480 else
490 print "Max array size reached."
500 end
510 endif
520 endif
530 print "Paths:";
540 dim paths$(3)
550 paths$(0) = " ahead"
560 paths$(1) = " right"
570 paths$(2) = " back"
580 paths$(3) = " left"
590 for n = 0 to 3
600 if e(4*a+((f+n) mod 4)) = 1 then print paths$(n);
610 next n
620 print
630 d = -1
640 while d < 0
650 input "> ",entry$
660 entry$ = lcase$(entry$)
670 select case entry$
680 case "ahead"
690 d = (f+0) mod 4
700 case "right"
710 d = (f+1) mod 4
720 case "back"
730 d = (f+2) mod 4
740 case "left"
750 d = (f+3) mod 4
760 case "quit"
770 goto 970
780 case else
790 print "Invalid input."
800 d = -1
810 end select
820 if d >= 0 then
830 select case d
840 case 0
850 if e(4*a+0) = 1 then xp = xp+1 : f = d else d = -1
860 case 1
870 if e(4*a+1) = 1 then yp = yp+1 : f = d else d = -1
880 case 2
890 if e(4*a+2) = 1 then xp = xp-1 : f = d else d = -1
900 case 3
910 if e(4*a+3) = 1 then yp = yp-1 : f = d else d = -1
920 end select
930 endif
940 if d < 0 then print "No path."
950 wend
960 wend
970 end
CONST MAXN = 1000
DIM x(MAXN) AS INTEGER
DIM y(MAXN) AS INTEGER
DIM e(4 * MAXN) AS INTEGER
xp = 127
yp = 127
a = 0
na = 0
RANDOMIZE TIMER
f = INT(RND * 4)
DO
a = na
FOR n = 0 TO na - 1
IF x(n) = xp AND y(n) = yp THEN
a = n
EXIT FOR
END IF
NEXT n
IF a = na THEN
IF na < MAXN THEN
x(na) = xp
y(na) = yp
FOR n = 0 TO 3
e(4 * na + n) = INT(RND * 2)
NEXT n
FOR n = 0 TO na - 1
IF x(n) = x(na) + 1 AND y(n) = y(na) THEN
e(4 * na + 0) = e(4 * n + 2)
ELSEIF x(n) = x(na) AND y(n) = y(na) + 1 THEN
e(4 * na + 1) = e(4 * n + 3)
ELSEIF x(n) = x(na) - 1 AND y(n) = y(na) THEN
e(4 * na + 2) = e(4 * n + 0)
ELSEIF x(n) = x(na) AND y(n) = y(na) - 1 THEN
e(4 * na + 3) = e(4 * n + 1)
END IF
NEXT n
na = na + 1
ELSE
PRINT "Max array size reached."
END
END IF
END IF
PRINT "Paths:";
DIM paths$(3)
paths$(0) = " ahead"
paths$(1) = " right"
paths$(2) = " back"
paths$(3) = " left"
FOR n = 0 TO 3
IF e(4 * a + ((f + n) MOD 4)) = 1 THEN PRINT paths$(n);
NEXT n
PRINT
d = -1
DO WHILE d < 0
INPUT "> ", entry$
entry$ = LCASE$(entry$)
SELECT CASE entry$
CASE "ahead"
d = (f + 0) MOD 4
CASE "right"
d = (f + 1) MOD 4
CASE "back"
d = (f + 2) MOD 4
CASE "left"
d = (f + 3) MOD 4
CASE "quit"
END
CASE ELSE
PRINT "Invalid input."
d = -1
END SELECT
IF d >= 0 THEN
SELECT CASE d
CASE 0
IF e(4 * a + 0) = 1 THEN xp = xp + 1: f = d ELSE d = -1
CASE 1
IF e(4 * a + 1) = 1 THEN yp = yp + 1: f = d ELSE d = -1
CASE 2
IF e(4 * a + 2) = 1 THEN xp = xp - 1: f = d ELSE d = -1
CASE 3
IF e(4 * a + 3) = 1 THEN yp = yp - 1: f = d ELSE d = -1
END SELECT
END IF
IF d < 0 THEN PRINT "No path."
LOOP
LOOP
ReDim x(0) As Integer
ReDim y(0) As Integer
ReDim e(0) As Integer
xp = 127
yp = 127
a = 0
na = 0
Randomize Timer
f = Int(Rnd * 4)
Do
a = na
For n = 0 To na - 1
If x(n) = xp And y(n) = yp Then
a = n
Exit For
End If
Next n
If a = na Then
na = na + 1
ReDim _Preserve x(na - 1)
ReDim _Preserve y(na - 1)
ReDim _Preserve e(4 * na - 1)
x(a) = xp
y(a) = yp
For n = 0 To 3
e(4 * a + n) = Int(Rnd * 2)
Next n
For n = 0 To na - 1
If x(n) = x(a) + 1 And y(n) = y(a) Then
e(4 * a + 0) = e(4 * n + 2)
ElseIf x(n) = x(a) And y(n) = y(a) + 1 Then
e(4 * a + 1) = e(4 * n + 3)
ElseIf x(n) = x(a) - 1 And y(n) = y(a) Then
e(4 * a + 2) = e(4 * n + 0)
ElseIf x(n) = x(a) And y(n) = y(a) - 1 Then
e(4 * a + 3) = e(4 * n + 1)
End If
Next n
End If
Print "Paths:";
Dim paths$(3)
paths$(0) = " ahead"
paths$(1) = " right"
paths$(2) = " back"
paths$(3) = " left"
For n = 0 To 3
If e(4 * a + ((f + n) Mod 4)) = 1 Then Print paths$(n);
Next n
Print
d = -1
Do While d < 0
Input "> ", entry$
entry$ = LCase$(entry$)
Select Case entry$
Case "ahead"
d = (f + 0) Mod 4
Case "right"
d = (f + 1) Mod 4
Case "back"
d = (f + 2) Mod 4
Case "left"
d = (f + 3) Mod 4
Case "quit"
End
Case Else
Print "Invalid input."
d = -1
End Select
If d >= 0 Then
Select Case d
Case 0
If e(4 * a + 0) = 1 Then xp = xp + 1: f = d Else d = -1
Case 1
If e(4 * a + 1) = 1 Then yp = yp + 1: f = d Else d = -1
Case 2
If e(4 * a + 2) = 1 Then xp = xp - 1: f = d Else d = -1
Case 3
If e(4 * a + 3) = 1 Then yp = yp - 1: f = d Else d = -1
End Select
End If
If d < 0 Then Print "No path."
Loop
Loop
xp = 127
yp = 127
a = 0
na = 0
f = int(ran(4))
dim x(1)
dim y(1)
dim e(1)
while true
a = na
for n = 0 to na-1
if x(n) = xp and y(n) = yp then
a = n
break
fi
next
if a = na then
na = na + 1
redim x(na)
redim y(na)
redim e(4*na)
x(a) = xp
y(a) = yp
for n = 0 to 3
e(4*a+n) = int(ran(2))
next
for n = 0 to na-1
if x(n) = x(a)+1 and y(n)=y(a) then
e(4*a) = e(4*n+2)
elsif x(n)=x(a) and y(n)=y(a)+1 then
e(4*a+1) = e(4*n+3)
elsif x(n)=x(a)-1 and y(n)=y(a) then
e(4*a+2) = e(4*n)
elsif x(n)=x(a) and y(n)=y(a)-1 then
e(4*a+3) = e(4*n+1)
fi
next
fi
print "Paths:";
dim paths$(3)
paths$(0) = " ahead"
paths$(1) = " right"
paths$(2) = " back"
paths$(3) = " left"
for n = 0 to 3
if e(4*a + mod((f+n), 4)) = 1 print paths$(n);
next
print
d = -1
entry$ = ""
while d < 0
input "> " entry$
entry$ = lower$(entry$)
if entry$ = "ahead" then
d = mod(f, 4)
elsif entry$ = "right" then
d = mod((f+1), 4)
elsif entry$ = "back" then
d = mod((f+2), 4)
elsif entry$ = "left" then
d = mod((f+3), 4)
elsif entry$ = "quit" then
end
else
print "Invalid input."
fi
if d = 0 then
if e(4*a) then xp = xp+1 : f = d else d = -1 : fi
elsif d = 1 then
if e(4*a+1) then yp = yp+1 : f = d else d = -1 : fi
elsif d = 2 then
if e(4*a+2) then xp = xp-1 : f = d else d = -1 : fi
elsif d = 3 then
if e(4*a+3) then yp = yp-1 : f = d else d = -1 : fi
fi
if d < 0 print "No path."
wend
wend
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
int xp=127, yp=127, a=0, na=0, n, f, d, *x, *y, *e;
char entry[255];
int main(void) {
srand(time(NULL));
f = rand()%4;
while (1) {
a=na;
for (n=0;n<na;n++) {
if (x[n]==xp && y[n]==yp) {a=n; break;}
}
if (a == na) {
na++;
x = (int*) (a<1)?malloc(sizeof(int)):realloc(x,na*sizeof(int));
y = (int*) (a<1)?malloc(sizeof(int)):realloc(y,na*sizeof(int));
e = (int*) (a<1)?malloc(4*sizeof(int)):realloc(e,4*na*sizeof(int));
x[a]=xp; y[a]=yp;
for (n=0;n<4;n++) {e[4*a+n] = rand()%2;}
for(n=0;n<na;n++) {
if (x[n]==x[a]+1 && y[n]==y[a] ) {e[4*a ]=e[4*n+2];}
else if (x[n]==x[a] && y[n]==y[a]+1) {e[4*a+1]=e[4*n+3];}
else if (x[n]==x[a]-1 && y[n]==y[a] ) {e[4*a+2]=e[4*n ];}
else if (x[n]==x[a] && y[n]==y[a]-1) {e[4*a+3]=e[4*n+1];}
}
}
printf("Paths:");
if ( e[4*a+(f )%4] ) { printf(" ahead"); }
if ( e[4*a+(f+1)%4] ) { printf(" right"); }
if ( e[4*a+(f+2)%4] ) { printf(" back"); }
if ( e[4*a+(f+3)%4] ) { printf(" left"); }
printf("\n");
d=-1;
entry[0]=0;
while (d<0) {
printf(">");
scanf("%s",&entry);
if (!strcmp(entry,"ahead")) { d=f%4; }
else if (!strcmp(entry,"right")) { d=(f+1)%4; }
else if (!strcmp(entry,"back")) { d=(f+2)%4; }
else if (!strcmp(entry,"left")) { d=(f+3)%4; }
else if (!strcmp(entry,"quit")) { getchar(); return(0); }
else {printf("Invalid.\n"); continue;}
switch (d) {
case 0: if (e[4*a ]) {xp++; f=d;} else {d=-1;}; break;
case 1: if (e[4*a+1]) {yp++; f=d;} else {d=-1;}; break;
case 2: if (e[4*a+2]) {xp--; f=d;} else {d=-1;}; break;
case 3: if (e[4*a+3]) {yp--; f=d;} else {d=-1;}; break;
}
if (d<0) {printf("No path.");}
}
}
}
#include <iostream>
#include <vector>
#include <string>
#include <random>
int main() {
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<int> d4(0, 3);
std::uniform_int_distribution<int> d2(0, 1);
int xp = 127, yp = 127, a = 0, na = 0, f = d4(gen);
std::vector<int> x;
std::vector<int> y;
std::vector<int> e;
while (true) {
a = na;
for (int n = 0; n < na; n++) {
if (x[n] == xp && y[n] == yp) {
a = n;
break;
}
}
if (a == na) {
na++;
x.resize(na);
y.resize(na);
e.resize(4 * na);
x[a] = xp;
y[a] = yp;
for (int n = 0; n < 4; n++) {
e[4 * a + n] = d2(gen);
}
for (int n = 0; n < na; n++) {
if (x[n] == x[a] + 1 && y[n] == y[a]) {
e[4 * a + 0] = e[4 * n + 2];
} else if (x[n] == x[a] && y[n] == y[a] + 1) {
e[4 * a + 1] = e[4 * n + 3];
} else if (x[n] == x[a] - 1 && y[n] == y[a]) {
e[4 * a + 2] = e[4 * n + 0];
} else if (x[n] == x[a] && y[n] == y[a] - 1) {
e[4 * a + 3] = e[4 * n + 1];
}
}
}
std::cout << "Paths:";
if (e[4 * a + (f) % 4]) std::cout << " ahead";
if (e[4 * a + (f + 1) % 4]) std::cout << " right";
if (e[4 * a + (f + 2) % 4]) std::cout << " back";
if (e[4 * a + (f + 3) % 4]) std::cout << " left";
std::cout << std::endl;
int d = -1;
std::string entry;
while (d < 0) {
std::cout << "> ";
std::cin >> entry;
if (entry == "ahead") {
d = f % 4;
} else if (entry == "right") {
d = (f + 1) % 4;
} else if (entry == "back") {
d = (f + 2) % 4;
} else if (entry == "left") {
d = (f + 3) % 4;
} else if (entry == "quit") {
return 0;
} else {
std::cout << "Invalid." << std::endl;
continue;
}
switch (d) {
case 0:
if (e[4 * a + 0]) {
xp++;
f = d;
} else {
d = -1;
}
break;
case 1:
if (e[4 * a + 1]) {
yp++;
f = d;
} else {
d = -1;
}
break;
case 2:
if (e[4 * a + 2]) {
xp--;
f = d;
} else {
d = -1;
}
break;
case 3:
if (e[4 * a + 3]) {
yp--;
f = d;
} else {
d = -1;
}
break;
}
if (d < 0) {
std::cout << "No path." << std::endl;
}
}
}
}
import 'dart:io';
import 'dart:math';
void main() {
int xp = 127, yp = 127, a = 0, na = 0;
Random rand = Random();
int f = rand.nextInt(4);
int d = -1;
List<int> x = [];
List<int> y = [];
List<int> e = [];
while (true) {
a = na;
for (int n = 0; n < na; n++) {
if (x[n] == xp && y[n] == yp) {
a = n;
break;
}
}
if (a == na) {
na++;
x.add(xp);
y.add(yp);
e.addAll(List.filled(4, 0)); // expand e by 4 elements
for (int n = 0; n < 4; n++) {
e[4 * a + n] = rand.nextInt(2);
}
for (int n = 0; n < na; n++) {
if (x[n] == x[a] + 1 && y[n] == y[a]) {
e[4 * a + 0] = e[4 * n + 2];
} else if (x[n] == x[a] && y[n] == y[a] + 1) {
e[4 * a + 1] = e[4 * n + 3];
} else if (x[n] == x[a] - 1 && y[n] == y[a]) {
e[4 * a + 2] = e[4 * n + 0];
} else if (x[n] == x[a] && y[n] == y[a] - 1) {
e[4 * a + 3] = e[4 * n + 1];
}
}
}
stdout.write("Paths:");
if (e[4 * a + (f) % 4] == 1) stdout.write(" ahead");
if (e[4 * a + (f + 1) % 4] == 1) stdout.write(" right");
if (e[4 * a + (f + 2) % 4] == 1) stdout.write(" back");
if (e[4 * a + (f + 3) % 4] == 1) stdout.write(" left");
print("");
d = -1;
while (d < 0) {
stdout.write("> ");
String? entry = stdin.readLineSync()?.toLowerCase();
if (entry == null) continue;
switch (entry) {
case "ahead":
d = f % 4;
break;
case "right":
d = (f + 1) % 4;
break;
case "back":
d = (f + 2) % 4;
break;
case "left":
d = (f + 3) % 4;
break;
case "quit":
return;
default:
print("Invalid.");
d = -1;
continue;
}
switch (d) {
case 0:
if (e[4 * a + 0] == 1) {
xp++;
f = d;
} else {
d = -1;
}
break;
case 1:
if (e[4 * a + 1] == 1) {
yp++;
f = d;
} else {
d = -1;
}
break;
case 2:
if (e[4 * a + 2] == 1) {
xp--;
f = d;
} else {
d = -1;
}
break;
case 3:
if (e[4 * a + 3] == 1) {
yp--;
f = d;
} else {
d = -1;
}
break;
}
if (d < 0) print("No path.");
}
}
}
global x[] y[] e[] pos dir offx offy .
#
dx[] = [ 1 0 -1 0 ]
dy[] = [ 0 1 0 -1 ]
#
proc draw .
if x[pos] + offx < 0 : offx += 1
if x[pos] + offx >= 25 : offx -= 1
if y[pos] + offy < 0 : offy += 1
if y[pos] + offy >= 25 : offy -= 1
gclear
gcolor 888
for i to len x[]
x = 4 * x[i] + 0.25 + offx * 4
y = 4 * y[i] + 0.25 + offy * 4
grect x y 3.5 3.5
x += 1.75
y += 1.75
for d to 4 : if e[4 * i + d] <> -1
gcircle x + dx[d] * 2, y + dy[d] * 2, 1.2
.
.
gcolor 057
x = 4 * x[pos] + 2 + offx * 4
y = 4 * y[pos] + 2 + offy * 4
gcircle x y 1.2
gcolor 000
gcircle x + dx[dir] * 0.7 y + dy[dir] * 0.7 0.3
.
gbackground 000
#
proc init .
x[] = [ 12 ]
y[] = [ 12 ]
dir = 1
# alignment padding
e[] = [ 0 0 0 0 ]
for n = 1 to 4 : e[] &= random 2 - 2
offx = 0
offy = 0
pos = 1
draw
gcolor 777
gtextsize 5
gtext 8 85 "arrow keys to navigate"
gtext 8 78 "n for new maze"
.
init
#
on key_down
k$ = keybkey
# for absolute navigation
# dir = 2
if k$ = "ArrowUp"
h = dir mod1 4
elif k$ = "ArrowLeft"
h = (dir + 1) mod1 4
elif k$ = "ArrowDown"
h = (dir + 2) mod1 4
elif k$ = "ArrowRight"
h = (dir + 3) mod1 4
else
if k$ = "n" : init
return
.
if e[4 * pos + h] = -1 : return
npos = e[4 * pos + h]
dir = h
if npos = 0
x[] &= x[pos] + dx[dir]
y[] &= y[pos] + dy[dir]
pos = len x[]
for d = 1 to 4 : e[] &= random 2 - 2
for i to len x[] : for d = 1 to 4
if x[pos] + dx[d] = x[i] and y[pos] + dy[d] = y[i]
e[4 * pos + d] = e[4 * i + (d + 2) mod1 4]
if e[4 * pos + d] = 0
e[4 * pos + d] = i
e[4 * i + (d + 2) mod1 4] = pos
.
.
.
else
pos = npos
.
draw
.program maze;
var xp:integer = 127;
yp:integer = 127;
na:integer=0;
a,d,f,n:integer;
e:array of integer;
x:array of integer;
y:array of integer;
entry:string;
begin
setlength(e,0);
setlength(x,0);
setlength(y,0);
f=random(4);
while (true) do begin
a:=na;
for n:=0 to na-1 do
if (x[n]=xp) and (y[n]=yp) then begin
a:=n;
break;
end;
if (a=na) then begin
na:=na+1;
setlength(x,length(x)+1);
setlength(y,length(y)+1);
setlength(e,length(e)+4);
x[a]:=xp;
y[a]:=yp;
for n:=0 to 3 do e[4*a+n] := random(2);
for n:=0 to na do
if (x[n]=x[a]+1) and (y[n]=y[a] ) then e[4*a ]:=e[4*n+2]
else if (x[n]=x[a] ) and (y[n]=y[a]+1) then e[4*a+1]:=e[4*n+3]
else if (x[n]=x[a]-1) and (y[n]=y[a] ) then e[4*a+2]:=e[4*n ]
else if (x[n]=x[a] ) and (y[n]=y[a]-1) then e[4*a+3]:=e[4*n+1];
end;
write('Paths:');
if e[4*a+f ]=1 then write(' ahead');
if e[4*a+(f+1) mod 4]=1 then write(' right');
if e[4*a+(f+2) mod 4]=1 then write(' back');
if e[4*a+(f+3) mod 4]=1 then write(' left');
writeln();
d:=-1;
entry:='';
while d<0 do begin
write('> ');
readln(entry);
if entry='ahead' then d:=f
else if entry='right' then d:=(f+1) mod 4
else if entry='back' then d:=(f+2) mod 4
else if entry='left' then d:=(f+3) mod 4
else if entry='exit' then
if (xp=127) and (yp=127) then begin
writeln('You have exited the maze.');
readln();
exit;
end
else writeln('You are not at the exit.')
else if entry='quit' then begin
readln();
exit
end
else writeln('Entry invalid.');
end;
case d of
0: if e[4*a ]=1 then begin xp := xp + 1; f := d; end else d:=-1;
1: if e[4*a+1]=1 then begin yp := yp + 1; f := d; end else d:=-1;
2: if e[4*a+2]=1 then begin xp := xp - 1; f := d; end else d:=-1;
3: if e[4*a+3]=1 then begin yp := yp - 1; f := d; end else d:=-1;
end;
end;
end.
Dim As Integer xp = 127
Dim As Integer yp = 127
Dim As Integer a = 0
Dim As Integer na = 0
Dim As Integer n, f, d
Dim As Integer x(), y(), e()
Dim As String entry
Randomize Timer
f = Int(Rnd * 4)
Do
a = na
For n = 0 To na - 1
If x(n) = xp And y(n) = yp Then
a = n
Exit For
End If
Next
If a = na Then
na += 1
Redim Preserve x(na - 1)
Redim Preserve y(na - 1)
Redim Preserve e(4 * na - 1)
x(a) = xp
y(a) = yp
' Inicializar posibles caminos (0 o 1)
For n = 0 To 3
e(4 * a + n) = Int(Rnd * 2)
Next
' Actualizar estados de caminos relacionados con vecinos
For n = 0 To na - 1
If x(n) = x(a) + 1 And y(n) = y(a) Then
e(4 * a) = e(4 * n + 2)
Elseif x(n) = x(a) And y(n) = y(a) + 1 Then
e(4 * a + 1) = e(4 * n + 3)
Elseif x(n) = x(a) - 1 And y(n) = y(a) Then
e(4 * a + 2) = e(4 * n)
Elseif x(n) = x(a) And y(n) = y(a) - 1 Then
e(4 * a + 3) = e(4 * n + 1)
End If
Next
End If
Print "Paths:";
'If e(4 * a + (f Mod 4)) Then Print " ahead";
'If e(4 * a + ((f + 1) Mod 4)) Then Print " right";
'If e(4 * a + ((f + 2) Mod 4)) Then Print " back";
'If e(4 * a + ((f + 3) Mod 4)) Then Print " left";
Dim paths(3) As String = {" ahead", " right", " back", " left"}
For n = 0 To 3
If e(4 * a + ((f + n) Mod 4)) = 1 Then Print paths(n);
Next
Print
d = -1
entry = ""
While d < 0
Input "> ", entry
Select Case Lcase(entry)
Case "ahead"
d = f Mod 4
Case "right"
d = (f + 1) Mod 4
Case "back"
d = (f + 2) Mod 4
Case "left"
d = (f + 3) Mod 4
Case "quit"
Exit Do
Case Else
Print "Invalid input."
End Select
Select Case d
Case 0
If e(4 * a) Then xp += 1 : f = d Else d = -1
Case 1
If e(4 * a + 1) Then yp += 1 : f = d Else d = -1
Case 2
If e(4 * a + 2) Then xp -= 1 : f = d Else d = -1
Case 3
If e(4 * a + 3) Then yp -= 1 : f = d Else d = -1
End Select
If d < 0 Then Print "No path."
Wend
Loop
Sleep
package maze.pgm;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
public class runnable {
static int areasize = 10;
static Random r = new Random();
static Scanner s = new Scanner(System.in);
static ArrayList<Boolean> e = new ArrayList<Boolean>();
static ArrayList<Integer> x = new ArrayList<Integer>();
static ArrayList<Integer> y = new ArrayList<Integer>();
static int a=0,xp=127,yp=127,f,na=0,d;
static boolean ok;
static String entry;
public static void main(String[] args) {
f=r.nextInt(4);
while (true) {
a=na;
for (int n=0;n<na;n++) {
if (x.get(n)==xp && y.get(n)==yp) {a=n; break;}
}
if (a==na) {
na++;
x.add(xp);
y.add(yp);
for (int n=0; n<4; n++) {e.add(r.nextBoolean());}
for (int n=0; n<na; n++) {
if ((x.get(n)==x.get(a)+1) && (y.get(n)==y.get(a) )) {e.set(4*a ,e.get(4*n+2));}
else if ((x.get(n)==x.get(a) ) && (y.get(n)==y.get(a)+1)) {e.set(4*a+1,e.get(4*n+3));}
else if ((x.get(n)==x.get(a)-1) && (y.get(n)==y.get(a) )) {e.set(4*a+2,e.get(4*n ));}
else if ((x.get(n)==x.get(a) ) && (y.get(n)==y.get(a)-1)) {e.set(4*a+3,e.get(4*n+1));}
}
}
System.out.print("Paths: ");
if (e.get(4*a+ f %4)) {System.out.print(" ahead");}
if (e.get(4*a+(f+1)%4)) {System.out.print(" right");}
if (e.get(4*a+(f+2)%4)) {System.out.print(" back");}
if (e.get(4*a+(f+3)%4)) {System.out.print(" left");}
System.out.println();
d=-1;
System.out.print("> ");
entry=s.nextLine();
while (d<0) {
if (entry.equals("ahead")) {d= f %4;}
else if (entry.equals("right")) {d=(f+1)%4;}
else if (entry.equals("back")) {d=(f+2)%4;}
else if (entry.equals("left")) {d=(f+3)%4;}
else if (entry.equals("quit")) {s.next(); System.exit(0);}
if (d<0) {
System.out.println("Entry invalid.");
System.out.print("> ");
entry=s.nextLine();
}
ok = false;
switch(d) {
case 0: if (e.get(4*a )) {xp++; f=d; ok=true;} break;
case 1: if (e.get(4*a+1)) {yp++; f=d; ok=true;} break;
case 2: if (e.get(4*a+2)) {xp--; f=d; ok=true;} break;
case 3: if (e.get(4*a+3)) {yp--; f=d; ok=true;} break;
}
if (d>=0 && !ok) {System.out.println("No path.");}
}
}
}
}
function run_pathfinder()
xp = 127
yp = 127
a = 0
na = 0
f = rand(0:3)
x = Int[]
y = Int[]
e = Int[]
entry = ""
while true
a = na
for n in 1:na
if x[n] == xp && y[n] == yp
a = n
break
end
end
if a == na
na += 1
push!(x, xp)
push!(y, yp)
append!(e, zeros(Int,4))
for n in 0:3
e[4*a + n + 1] = rand(0:1)
end
for n in 1:na
if x[n] == x[a+1] + 1 && y[n] == y[a+1]
e[4*a + 1] = e[4*(n-1) + 3]
elseif x[n] == x[a+1] && y[n] == y[a+1] + 1
e[4*a + 2] = e[4*(n-1) + 4]
elseif x[n] == x[a+1] - 1 && y[n] == y[a+1]
e[4*a + 3] = e[4*(n-1) + 1]
elseif x[n] == x[a+1] && y[n] == y[a+1] - 1
e[4*a + 4] = e[4*(n-1) + 2]
end
end
end
print("Paths:")
paths = [" ahead", " right", " back", " left"]
for n in 0:3
if e[4*a + ((f + n) % 4) + 1] == 1
print(paths[n+1])
end
end
println()
d = -1
while d < 0
print("> ")
entry = strip(readline())
entry = lowercase(entry)
if entry == "ahead"
d = f % 4
elseif entry == "right"
d = (f + 1) % 4
elseif entry == "back"
d = (f + 2) % 4
elseif entry == "left"
d = (f + 3) % 4
elseif entry == "quit"
return
else
println("Invalid input.")
continue
end
if d == 0
if e[4*a + 1] == 1
xp += 1
f = d
else
d = -1
end
elseif d == 1
if e[4*a + 2] == 1
yp += 1
f = d
else
d = -1
end
elseif d == 2
if e[4*a + 3] == 1
xp -= 1
f = d
else
d = -1
end
elseif d == 3
if e[4*a + 4] == 1
yp -= 1
f = d
else
d = -1
end
end
if d < 0
println("No path.")
end
end
end
end
run_pathfinder()
xp=127;
yp=127;
na=0;
x=[];
y=[];
e=[];
d=-1;
f=randi([1,4]);
while d~=5
a=na+1;
for n=1:na
if x(n)==xp && y(n)==yp
a=n;
break
end
end
if (a==na+1)
na=na+1;
x=[x,xp];
y=[y,yp];
for n=1:4
e=[e,logical(randi([0,1]))];
end
for n=1:na
if (x(n)==x(a)+1) && (y(n)==y(a))
e(1+4*(a-1))=e(1+4*(n-1)+2);
end
if (x(n)==x(a)) && (y(n)==y(a)+1)
e(1+4*(a-1)+1)=e(1+4*(n-1)+3);
end
if (x(n)==x(a)-1) && (y(n)==y(a))
e(1+4*(a-1)+2)=e(1+4*(n-1));
end
if (x(n)==x(a)) && (y(n)==y(a)-1)
e(1+4*(a-1)+3)=e(1+4*(n-1)+1);
end
end
end
str = "Paths:";
if e(1+4*(a-1)+(f-1))
str = strcat(str," ahead");
end
if e(1+4*(a-1)+mod((f-1)+1,4))
str = strcat(str," right");
end
if e(1+4*(a-1)+mod((f-1)+2,4))
str = strcat(str," back");
end
if e(1+4*(a-1)+mod((f-1)+3,4))
str = strcat(str," left");
end
disp(str)
d=-1;
while d<0
entry=input("What? ","s");
if entry=="ahead"
d=f;
elseif entry == "right"
d=mod((f-1)+1,4)+1;
elseif entry == "back"
d=mod((f-1)+2,4)+1;
elseif entry == "left"
d=mod((f-1)+3,4)+1;
elseif entry=="quit"
d=5;
end
end
if (d>0) && (d<5)
switch d
case 1
if e(1+(a-1)*4)
xp=xp+1;
end
case 2
if e(1+(a-1)*4+1)
yp=yp+1;
end
case 3
if e(1+(a-1)*4+2)
xp=xp-1;
end
case 4
if e(1+(a-1)*4+3)
yp=yp-1;
end
end
f=d;
end
end
$xp=127;
$yp=127;
while (1) {
$a = $na;
for ($n=0; $n<$na; $n++) {
if (($x[$n]==$xp) && ($y[$n]==$yp)) {
$a=$n;
last;
}
}
if ($a == $na) {
$na++;
$x[$a]=$xp;
$y[$a]=$yp;
for ($n=0; $n<4; $n++) {
$e[4*$a+$n] = int(rand(2));
}
for ($n=0; $n<$na; $n++) {
if (($x[$n]==$x[$a]+1) && ($y[$n]==$y[$a] )) {$e[4*$a]=$e[4*$n+2];}
elsif (($x[$n]==$x[$a] ) && ($y[$n]==$y[$a]+1)) {$e[4*$a+1]=$e[4*$n+3];}
elsif (($x[$n]==$x[$a-1]) && ($y[$n]==$y[$a] )) {$e[4*$a+2]=$e[4*$n];}
elsif (($x[$n]==$x[$a] ) && ($y[$n]==$y[$a]-1)) {$e[4*$a+3]=$e[4*$n+1];}
}
}
print("Paths: ");
if ($e[4*$a+$f]) {print(" ahead");}
if ($e[4*$a+($f+1)%4]) {printf(" right");}
if ($e[4*$a+($f+2)%4]) {printf(" back" );}
if ($e[4*$a+($f+3)%4]) {printf(" left" );}
printf("\n");
$d=-1;
while ($d<0) {
print("> ");
$entry=<>;
chomp($entry);
if ($entry eq "ahead") {$d=$f%4;}
elsif ($entry eq "right") {$d=($f+1)%4;}
elsif ($entry eq "back") {$d=($f+2)%4;}
elsif ($entry eq "left") {$d=($f+3)%4;}
elsif ($entry eq "quit") {exit;}
if ($d==0) {if ($e[4*$a]) {$xp++; $f=$d;} else {$d=-1;}}
elsif ($d==1) {if ($e[4*$a+1]) {$yp++; $f=$d;} else {$d=-1;}}
elsif ($d==2) {if ($e[4*$a+2]) {$xp--; $f=$d;} else {$d=-1;}}
elsif ($d==3) {if ($e[4*$a+3]) {$yp--; $f=$d;} else {$d=-1;}}
if ($d<0) {print "No path.\n";}
}
}
You can run this online here. You need to use the correct arrow keys depending on which direction you are facing! Except at the start, you can always go back, which is always the downarrow key, but you will about-turn and need to start using the uparrow key to carry on in that new direction.
-- demo\rosetta\text_maze.exw
with javascript_semantics
requires("1.0.6") -- (not yet shipped)
include theGUI.e
sequence x, y, e
integer pos, xp, yp, offx = 0, offy = 0
procedure init()
xp = 12
yp = 12
x = {xp}
y = {yp}
e = {0,0,0}
for n=1 to 4 do e &= rand(2)=2 end for
pos = 1
end procedure
init()
function create_xpms()
string hdr = """
15 15 2 1
. c None
* c #FF0000
""",
pixels = """
...............
.......*.......
......***......
.....*****.....
....*******....
...*********...
..***********..
.....*****.....
.....*****.....
.....*****.....
.....*****.....
.....*****.....
.....*****.....
.....*****.....
...............
"""
sequence res = {gImage_from_XPM(hdr&pixels)}
for i=1 to 3 do
-- rotate 90 degrees:
sequence p = split(pixels,'\n'), -- (corrupt not)
q = split(pixels,'\n') -- (same size)
for r=1 to 15 do
for c=1 to 15 do -- put each row in
q[c,-r] = p[r,c] -- an ascending column
end for
end for
pixels = join(q,'\n')
res &= gImage_from_XPM(hdr&pixels)
end for
return res
end function
constant xpm = create_xpms()
integer f = 1
procedure redraw(gdx canvas)
integer xp = x[pos],
yp = y[pos]
if xp+offx<0 then offx += 1 end if
if yp+offy<0 then offy += 1 end if
if xp+offx>=25 then offx -= 1 end if
if yp+offy>=25 then offy -= 1 end if
gSetAttribute(canvas,"FGCLR",TG_WHITE)
for i=1 to length(x) do
integer rx = 24*x[i]+12+offx*24,
ry = 24*y[i]+12+offy*24
gDrawRect(canvas, rx-10, rx+10, ry-10, ry+10, true)
if e[4*i+0] then gDrawCircle(canvas,rx+10,ry,6,true) end if
if e[4*i+2] then gDrawCircle(canvas,rx-10,ry,6,true) end if
if e[4*i+1] then gDrawCircle(canvas,rx,ry+10,6,true) end if
if e[4*i+3] then gDrawCircle(canvas,rx,ry-10,6,true) end if
end for
integer px = 24*xp+5+offx*24,
py = 24*yp+5+offy*24
gDrawImage(xpm[f],canvas,px,py)
if length(x)=1 then
gDrawText(canvas,5,12,"arrow keys to navigate")
gDrawText(canvas,5,28,"n for new maze")
end if
end procedure
function key_cb(gdx canvas, integer c)
integer d = -1
switch c do
case VK_UP: d = rmdr(f+2,4)
case VK_LEFT: d = rmdr(f+1,4)
case VK_DOWN: d = rmdr(f+0,4)
case VK_RIGHT: d = rmdr(f+3,4)
case 'n','N': init(); gRedraw(canvas)
end switch
if d!=-1 and e[4*pos+d]=1 then
// for relative directions:
f = {2,3,4,1}[d+1]
if even(d) then xp += 1-d
else yp += 2-d end if
pos = length(x)+1
for n=1 to length(x) do
if x[n]=xp and y[n]=yp then
pos = n
exit
end if
end for
if pos>length(x) then
x &= xp
y &= yp
for n=1 to 4 do e &= rand(2)=2 end for
integer px = x[pos], py = y[pos]
for n,xn in x do
integer yn = y[n]
if xn=px+1 and yn = py then e[4*pos+0] = e[4*n+2]
elsif xn=px and yn = py+1 then e[4*pos+1] = e[4*n+3]
elsif xn=px-1 and yn = py then e[4*pos+2] = e[4*n+0]
elsif xn=px and yn = py-1 then e[4*pos+3] = e[4*n+1]
end if
end for
end if
gRedraw(canvas)
end if
return TG_DEFAULT
end function
gdx canvas = gCanvas(redraw,"SIZE=601x601, BGCLR=TG_BLACK"),
dialog = gDialog(canvas,"Text Maze")
gSetHandler(canvas, `KEY`, key_cb);
gMainLoop(dialog)
local xp = 127
local yp = 127
local a = 0
local na = 0
local x = {}
local y = {}
local e = {}
local f = math.random(0, 3)
local d
local entry
while true do
a = na
for n = 1, na do
if x[n] == xp and y[n] == yp then
a = n - 1
break
end
end
if a == na then
na += 1
x:insert(xp)
y:insert(yp)
for _ = 0, 3 do e:insert(math.random(0, 1) == 0 ? false : true) end
for n = 0, na - 1 do
if x[n + 1] == x[a + 1] + 1 and y[n + 1]==y[a + 1] then
e[4 * a + 1] = e[4 * n + 3]
elseif x[n + 1] == x[a + 1] and y[n + 1] == y[a + 1] + 1 then
e[4 * a + 2] = e[4 * n + 4]
elseif x[n + 1] == x[a + 1] - 1 and y[n + 1] == y[a + 1] then
e[4 * a + 3] = e[4 * n + 1]
elseif x[n + 1] == x[a + 1] and y[n + 1] == y[a + 1] - 1 then
e[4 * a + 4] = e[4 * n + 2]
end
end
end
io.write("Paths:")
if e[4 * a + (f ) % 4 + 1] then io.write(" ahead") end
if e[4 * a + (f + 1) % 4 + 1] then io.write(" right") end
if e[4 * a + (f + 2) % 4 + 1] then io.write(" back") end
if e[4 * a + (f + 3) % 4 + 1] then io.write(" left") end
print()
d = -1
while d < 0 do
io.write("> ")
io.output():flush()
entry = io.read()
if entry == "a" or entry == "ahead" then
d = f % 4
elseif entry == "r" or entry == "right" then
d = (f + 1) % 4
elseif entry == "b" or entry == "back" then
d = (f + 2) % 4
elseif entry == "l" or entry == "left" then
d = (f + 3) % 4
elseif entry == "q" or entry == "quit" then
os.exit(0)
else
print("Invalid")
continue
end
end
if d == 0 then
if e[4 * a + 1] then
xp += 1
f = d
else
d = -1
end
elseif d == 1 then
if e[4 * a + 2] then
yp += 1
f = d
else
d = -1
end
elseif d == 2 then
if e[4 * a + 3] then
xp -= 1
f = d
else
d = -1
end
elseif d == 3 then
if e[4 * a + 4] then
yp -= 1
f = d
else
d = -1
end
end
if d < 0 then print("No path") end
end
- Output:
Sample input/output:
Paths: right left > l Paths: ahead back left > a Paths: right back left > a No path Paths: right back left > ri Invalid > r Paths: ahead right back left > q
$xp = 127
$yp = 127
$a = 0
$na = 0
$x = @()
$y = @()
$e = @()
$f = (random 4)
while ($true) {
$a = $na;
for ($n=0; $n-lt$na; $n++) {
if (($x[$n]-eq$xp) -and ($y[$n]-eq$yp)) {$a=$n; break}
}
if ($a -eq $na) {
$na++
$x += $xp
$y += $yp
(0..3) |% {$e+=($true,$false)[(random 2)]}
(0..($na-1)) |% {
if (($x[$_]-eq$x[$a]+1) -and ($y[$_]-eq$y[$a] )) {$e[4*$a ]=$e[4*$_+2];}
elseif (($x[$_]-eq$x[$a] ) -and ($y[$_]-eq$y[$a]+1)) {$e[4*$a+1]=$e[4*$_+3];}
elseif (($x[$_]-eq$x[$a]-1) -and ($y[$_]-eq$y[$a] )) {$e[4*$a+2]=$e[4*$_ ];}
elseif (($x[$_]-eq$x[$a] ) -and ($y[$_]-eq$y[$a]-1)) {$e[4*$a+3]=$e[4*$_+1];}
}
}
$str = "Paths:"
if ($e[4*$a+$f%4]) {$str+=" ahead"}
if ($e[4*$a+($f+1)%4]) {$str+=" right"}
if ($e[4*$a+($f+2)%4]) {$str+=" back"}
if ($e[4*$a+($f+3)%4]) {$str+=" left"}
write-output $str
$d=-1;
while ($d-lt0) {
write-host -n "> "
$entry = (read-host)
if ($entry-eq"ahead") {$d=$f}
elseif ($entry-eq"right") {$d=($f+1)%4}
elseif ($entry-eq"back") {$d=($f+2)%4}
elseif ($entry-eq"left") {$d=($f+3)%4}
elseif ($entry-eq"quit") {read-host; exit}
else {write-host "Entry invalid."}
}
switch($d) {
0 {if ($e[4*$a ]) {$xp++; $f=$d} else {$d=-1}}
1 {if ($e[4*$a+1]) {$yp++; $f=$d} else {$d=-1}}
2 {if ($e[4*$a+2]) {$xp--; $f=$d} else {$d=-1}}
3 {if ($e[4*$a+3]) {$yp--; $f=$d} else {$d=-1}}
}
if ($d-lt0) {write-host "No path."}
}
from random import randrange
xp, yp, na, x, y, e, d, f = 127, 127, 0, [], [], [], -1, randrange(4)
while d != 4:
a = na
for n in range(na):
if x[n] == xp and y[n] == yp:
a = n
break
if a == na:
na += 1
x.append(xp)
y.append(yp)
for i in range(4):
e.append(bool(randrange(2)))
for n in range(na):
if x[n] == x[a] + 1 and y[n] == y[a]:
e[4*a] = e[4*n + 2]
elif x[n] == x[a] and y[n] == y[a] + 1:
e[4*a + 1] = e[4*n + 3]
elif x[n] == x[a] - 1 and y[n] == y[a]:
e[4*a + 2] = e[4*n]
elif x[n] == x[a] and y[n] == y[a] - 1:
e[4*a + 3] = e[4*n + 1]
print("Paths:", end = "")
paths = [" ahead", " right", " back", " left"]
for i in range(4):
if e[4*a + (f + i)%4]:
print(paths[i], end = "")
d = -1
while d < 0:
entry = input("\n> ")
match entry:
case "ahead":
d = f
case "right":
d = (f + 1)%4
case "back":
d = (f + 2)%4
case "left":
d = (f + 3)%4
case "exit":
if xp == 127 and yp == 127:
print("You have exited the maze.")
d = 4
else:
print("You are not at the exit.")
case "quit":
d = 4
case _:
print("Entry invalid.")
continue
match d:
case 0:
if e[4*a]:
xp += 1
d = f
else:
d = -1
case 1:
if e[4*a + 1]:
yp += 1
d = f
else:
d = -1
case 2:
if e[4*a + 2]:
xp -= 1
d = f
else:
d = -1
case 3:
if e[4*a + 3]:
yp -= 1
d = f
else:
d = -1
if(d < 0):
print("No path.")
text_maze <- function() {
xp <- yp <- 127
na <- 0
x <- y <- e <- c()
d <- -1
f <- sample(4, 1)
repeat {
a <- na + 1
for(n in seq_len(na)) {
if(x[n] == xp && y[n] == yp) {
a <- n
break
}
}
if(a == na + 1) {
na <- na + 1
x <- c(x, xp)
y <- c(y, yp)
e <- c(e, sample(c(TRUE, FALSE), 4, replace = TRUE))
for(n in seq_len(na)) {
if(x[n] == x[a] + 1 && y[n] == y[a]) {
e[4*(a - 1) + 1] <- e[4*(n - 1) + 3]
}
if(x[n] == x[a] && y[n] == y[a] + 1) {
e[4*(a - 1) + 2] <- e[4*(n - 1) + 4]
}
if(x[n] == x[a] - 1 && y[n] == y[a]) {
e[4*(a - 1) + 3] <- e[4*(n - 1) + 1]
}
if(x[n] == x[a] && y[n] == y[a] - 1) {
e[4*(a - 1) + 4] <- e[4*(n - 1) + 2]
}
}
}
cat("Paths:")
paths <- c(" ahead", " right", " back", " left")
if(e[4*(a - 1) + f]) cat(paths[1])
for(i in 1:3) {
if(e[1 + 4*(a - 1) + (f - 1 + i)%%4]) cat(paths[i+1])
}
d <- -1
while(d < 0) {
entry <- readline("> ")
switch(entry,
"ahead" = eval(d <- f),
"right" = eval(d <- 1 + f%%4),
"back" = eval(d <- 1 + (f + 1)%%4),
"left" = eval(d <- 1 + (f + 2)%%4),
"exit" = eval(if(xp == 127 && yp == 127) d <- 5 else cat("You are not at the exit.\n")),
"quit" = eval(d <- 5),
cat("Invalid entry.\n"))
}
switch(d,
ifelse(e[4*(a - 1) + 1], eval(xp <- xp + 1), eval(d <- -1)),
ifelse(e[4*(a - 1) + 2], eval(yp <- yp + 1), eval(d <- -1)),
ifelse(e[4*(a - 1) + 3], eval(xp <- xp - 1), eval(d <- -1)),
ifelse(e[4*(a - 1) + 4], eval(yp <- yp - 1), eval(d <- -1)))
if(d < 0) {
cat("No path.\n")
} else if(d == 5) {
cat("You have exited the maze. Or just quit the program.\n")
break
} else d <- f
}
}
text_maze()
(define (pathfinder)
(define xp 127)
(define yp 127)
(define a 0)
(define na 0)
(define f (random 4))
(define x (make-vector 0))
(define y (make-vector 0))
(define e (make-vector 0))
(define paths #(" ahead" " right" " back" " left"))
(define (resize-preserve v new-size fill)
(define old-size (vector-length v))
(define new-v (make-vector new-size fill))
(for ([i (in-range (min old-size new-size))])
(vector-set! new-v i (vector-ref v i)))
new-v)
(define (update-e n a)
(cond
[(and (= (vector-ref x n) (+ (vector-ref x a) 1))
(= (vector-ref y n) (vector-ref y a)))
(vector-set! e (* 4 a) (vector-ref e (+ (* 4 n) 2)))]
[(and (= (vector-ref x n) (vector-ref x a))
(= (vector-ref y n) (+ (vector-ref y a) 1)))
(vector-set! e (+ (* 4 a) 1) (vector-ref e (+ (* 4 n) 3)))]
[(and (= (vector-ref x n) (- (vector-ref x a) 1))
(= (vector-ref y n) (vector-ref y a)))
(vector-set! e (+ (* 4 a) 2) (vector-ref e (* 4 n)))]
[(and (= (vector-ref x n) (vector-ref x a))
(= (vector-ref y n) (- (vector-ref y a) 1)))
(vector-set! e (+ (* 4 a) 3) (vector-ref e (+ (* 4 n) 1)))]))
;; main program
(let loop ()
(set! a na)
(for ([i (in-range na)])
(when (and (= (vector-ref x i) xp) (= (vector-ref y i) yp))
(set! a i)))
(when (= a na)
(set! na (+ na 1))
(set! x (resize-preserve x na 0))
(set! y (resize-preserve y na 0))
(set! e (resize-preserve e (* 4 na) 0))
(vector-set! x a xp)
(vector-set! y a yp)
(for ([i (in-range 4)])
(vector-set! e (+ (* 4 a) i) (random 2)))
(for ([n (in-range na)])
(update-e n a)))
(display "Paths:")
(for ([i (in-range 4)])
(when (= (vector-ref e (+ (* 4 a) (modulo (+ f i) 4))) 1)
(display (vector-ref paths i))))
(newline)
(flush-output)
(let input-loop ()
(display "> ")
(flush-output)
(define entry (string-downcase (read-line)))
(define d -1)
(cond
[(string=? entry "ahead") (set! d (modulo f 4))]
[(string=? entry "right") (set! d (modulo (+ f 1) 4))]
[(string=? entry "back") (set! d (modulo (+ f 2) 4))]
[(string=? entry "left") (set! d (modulo (+ f 3) 4))]
[(string=? entry "quit") (exit 0)]
[else (begin (display "Invalid input.\n") (input-loop))])
(cond
[(= d 0) (if (= (vector-ref e (+ (* 4 a) 0)) 1)
(begin (set! xp (+ xp 1)) (set! f d))
(set! d -1))]
[(= d 1) (if (= (vector-ref e (+ (* 4 a) 1)) 1)
(begin (set! yp (+ yp 1)) (set! f d))
(set! d -1))]
[(= d 2) (if (= (vector-ref e (+ (* 4 a) 2)) 1)
(begin (set! xp (- xp 1)) (set! f d))
(set! d -1))]
[(= d 3) (if (= (vector-ref e (+ (* 4 a) 3)) 1)
(begin (set! yp (- yp 1)) (set! f d))
(set! d -1))])
(when (= d -1)
(display "No path.\n")
(input-loop)))
(loop)))
(pathfinder)
As an alternative to entering the direction in full you can just enter the first letter though you still need to press the return key afterwards.
import "random" for Random
import "io" for Stdin, Stdout
var xp = 127
var yp = 127
var a = 0
var na = 0
var x = []
var y = []
var e = []
var r = Random.new()
var f = r.int(4)
var d
var entry
while (true) {
a = na
for (n in 0...na) {
if (x[n] == xp && y[n] == yp) {
a = n
break
}
}
if (a == na) {
na = na + 1
x.add(xp)
y.add(yp)
for (n in 0..3) e.add(r.int(2) == 0 ? false : true)
for (n in 0...na) {
if (x[n] == x[a] + 1 && y[n]==y[a]) {
e[4 * a ] = e[4 * n + 2]
} else if (x[n] == x[a] && y[n] == y[a] + 1) {
e[4 * a + 1] = e[4 * n + 3]
} else if (x[n] == x[a] - 1 && y[n] == y[a]) {
e[4 * a + 2] = e[4 * n]
} else if (x[n] == x[a] && y[n] == y[a] - 1) {
e[4 * a + 3] = e[4 * n + 1]
}
}
}
System.write("Paths:")
if (e[4 * a + (f ) % 4]) System.write(" ahead")
if (e[4 * a + (f + 1) % 4]) System.write(" right")
if (e[4 * a + (f + 2) % 4]) System.write(" back")
if (e[4 * a + (f + 3) % 4]) System.write(" left")
System.print()
d = -1
while (d < 0) {
System.write("> ")
Stdout.flush()
entry = Stdin.readLine().trim()
if (entry == "a" || entry == "ahead") {
d = f % 4
} else if (entry == "r" || entry == "right") {
d = (f + 1) % 4
} else if (entry == "b" || entry == "back") {
d = (f + 2) % 4
} else if (entry == "l" || entry == "left") {
d = (f + 3) % 4
} else if (entry == "q" || entry == "quit") {
return
} else {
System.print("Invalid")
continue
}
}
if (d == 0) {
if (e[4 * a]) {
xp = xp + 1
f = d
} else {
d = -1
}
} else if (d == 1) {
if (e[4 * a + 1]) {
yp = yp + 1
f = d
} else {
d = -1
}
} else if (d == 2) {
if (e[4 * a + 2]) {
xp = xp - 1
f = d
} else {
d = -1
}
} else if (d == 3) {
if (e[4 * a + 3]) {
yp = yp - 1
f = d
} else {
d = -1
}
}
if (d < 0) System.print("No path")
}
- Output:
Sample input/output:
Paths: ahead left > a Paths: ahead back left > l Paths: ahead back > a Paths: ahead back left > r No path Paths: ahead back left > le Invalid > l Paths: right back left > q
include xpllib; \for StrCmp, TextIn, Print, and IntSize
int XP, YP, A, NA, N, F, D, X, Y, E;
char Entry(255);
[XP:= 127; YP:= 127; A:= 0; NA:= 0;
F:= Ran(4);
while 1 do
[A:= NA;
for N:= 0 to NA-1 do
if X(N) = XP and Y(N) = YP then
[A:= N; N:= NA];
if A = NA then
[NA:= NA+1;
X:= if A<1 then MAlloc(IntSize) else ReallocMem(X, NA*IntSize);
Y:= if A<1 then MAlloc(IntSize) else ReallocMem(Y, NA*IntSize);
E:= if A<1 then Malloc(4*IntSize) else ReallocMem(E, 4*NA*IntSize);
X(A):= XP; Y(A):= YP;
for N:=0 to 4-1 do
E(4*A+N):= Ran(2);
for N:= 0 to NA-1 do
[ if X(N) = X(A)+1 and Y(N) = Y(A) then [E(4*A ):= E(4*N+2)]
else if X(N) = X(A) and Y(N) = Y(A)+1 then [E(4*A+1):= E(4*N+3)]
else if X(N) = X(A)-1 and Y(N) = Y(A) then [E(4*A+2):= E(4*N )]
else if X(N) = X(A) and Y(N) = Y(A)-1 then [E(4*A+3):= E(4*N+1)];
];
];
Print("Paths:");
if E(4*A + (F &3)) then Print(" ahead");
if E(4*A + ((F+1)&3)) then Print(" right");
if E(4*A + ((F+2)&3)) then Print(" back");
if E(4*A + ((F+3)&3)) then Print(" left");
Print("\n");
D:= -1;
Entry(0):= 0;
while D < 0 do
[Print(">");
TextIn(0, Entry, 255);
if StrCmp(Entry, "ahead") = 0 then D:= F&3
else if StrCmp(Entry, "right") = 0 then D:= (F+1)&3
else if StrCmp(Entry, "back") = 0 then D:= (F+2)&3
else if StrCmp(Entry, "left") = 0 then D:= (F+3)&3
else if StrCmp(Entry, "quit") = 0 then return(0)
else [Print("Invalid.\n"); \continue\ D:= -2];
case D of
0: if E(4*A ) then [XP:= XP+1; F:= D] else D:= -1;
1: if E(4*A+1) then [YP:= YP+1; F:= D] else D:= -1;
2: if E(4*A+2) then [XP:= XP-1; F:= D] else D:= -1;
3: if E(4*A+3) then [YP:= YP-1; F:= D] else D:= -1
other [];
if D = -1 then Print("No path.\n");
];
];
]- Output:
Paths: ahead right back left >ahead Paths: right back left >right Paths: ahead right back >back Paths: ahead back left >qkjl Invalid. >quit