16

Seu objetivo é escrever um programa que cria um 10x10 mapa aleatório usando 0, 1e 2, e encontra o caminho mais curto de canto superior esquerdo para canto inferior direito, assumindo que:

0 representa um campo de grama: qualquer um pode andar sobre ele;
1 representa um muro: você não pode atravessá-lo;
2 representa um portal: ao entrar em um portal, você pode mover para qualquer outro portal no mapa.

Especificações:

O elemento superior esquerdo e o inferior direito devem ser 0 ;
Ao criar o mapa aleatório, todo campo deve ter 60% de chance de ser 0 , 30% de ser 1 e 10% de ser 2 ;
Você pode mover-se em qualquer campo adjacente (mesmo na diagonal);
Seu programa deve gerar o mapa e o número de etapas do caminho mais curto;
Se não houver um caminho válido que leve ao campo inferior direito, seu programa deve gerar apenas o mapa;
Você pode usar qualquer recurso que desejar;
O menor código vence.

Cálculo de etapas:
Uma etapa é um movimento real; toda vez que você altera o campo, você incrementa o contador.

Resultado:

code-golf path-finding maze

— Vereos
fonte

Não podemos simplesmente produzir o programa pelo caminho mais curto? Gerar é outra questão.

— Mikaël Mayer

Você não especificou que o mapa aleatório deve ser diferente de cada vez :)

— marinus

@marinus LoooL! Bem, nas especificações, escrevi as chances de gerar, então acho que escrever um mapa padrão com 60 0, 30 1 e 10 2 não será a solução certa: P

— Vereos

@ MikaëlMayer Acho que você tem razão, mas acho que seria mais desafiador assim. Estou errado?

— Vereos

Como se trata de uma questão de código-golfe, o critério vencedor é o código mais curto. O que acontece se esse código é realmente lento e leva séculos para ser executado?

— Victor Stafusa

3

GolfScript, 182 caracteres

;0`{41 3 10rand?/3%`}98*0`]10/n*n+.[12n*.]*.0{[`/(,\+{,)1$+}*;]}:K~\2K:P+${[.12=(]}%.,,{.{\1==}+2$\,{~;.P?0<!P*3,{10+}%1+{2$1$-\3$+}%+~}%`{2$~0<@@?-1>&2$[~;@)](\@if}++%}/-1=1=.0<{;}*

Exemplos:

— Howard
fonte

4

Mathematica (344)

Bônus: destaque do caminho

n = 10;
m = RandomChoice[{6, 3, 1} -> {0, 1, 2}, {n, n}];
m[[1, 1]] = m[[n, n]] = 0;

p = FindShortestPath[Graph@DeleteDuplicates@Join[Cases[#, Rule[{ij__}, {k_, l_}] /; 
      0 < k <= n && 0 < l <= n && m[[ij]] != 1 && m[[k, l]] != 1] &@
   Flatten@Table[{i, j} -> {i, j} + d, {i, n}, {j, n}, {d, Tuples[{-1, 0, 1}, 2]}], 
  Rule @@@ Tuples[Position[m, 2], 2]], {1, 1}, {n, n}];

Grid@MapAt[Style[#, Red] &, m, p]
If[# > 0, #-1] &@Length[p]

insira a descrição da imagem aqui

Crio o gráfico de todos os filmes possíveis para os vértices vizinhos e adiciono todos os "teleports" possíveis.

— ybeltukov
fonte

3

Mathematica, 208 202 caracteres

Baseie-se nas soluções de David Carraher e ybeltukov. E graças à sugestão de ybeltukov.

m=RandomChoice[{6,3,1}->{0,1,2},n={10,10}];m〚1,1〛=m〚10,10〛=0;Grid@m
{s,u}=m~Position~#&/@{0,2};If[#<∞,#]&@GraphDistance[Graph[{n/n,n},#<->#2&@@@Select[Subsets[s⋃u,{2}],Norm[#-#2]&@@#<2||#⋃u==u&]],n/n,n]

— alefalpha
fonte

Bom, +1! Otimização adicional: n/nem vez de n/10:)

— ybeltukov

Boa racionalização. E você imprime o mapa imediatamente.

— DavidC

E 〚〛para suportes (é símbolos unicode corretos)

— ybeltukov

Você pode explicar o critério de seleção,Norm[# - #2] & @@ # < 2 || # \[Union] u == u &

— DavidC

@DavidCarraher Norm[# - #2] & @@ # < 2significa que a distância entre dois pontos é menor que 2, então eles devem estar adjacentes. # ⋃ u == usignifica que ambos os pontos estão em u.

— alephalpha

2

Python 3, 279

Alguma variante Dijkstra. Feio, mas jogou golfe o máximo que pude ...

from random import*
R=range(10)
A={(i,j):choice([0,0,1]*3+[2])for i in R for j in R}
A[0,0]=A[9,9]=0
for y in R:print(*(A[x,y]for x in R))
S=[(0,0,0,0)]
for x,y,a,c in S:A[x,y]=1;x*y-81or print(c)+exit();S+=[(X,Y,b,c+1)for(X,Y),b in A.items()if a+b>3or~-b and-2<X-x<2and-2<Y-y<2]

Execução de amostra

0 1 1 1 0 0 1 0 1 0
0 0 0 1 0 1 0 1 0 0
0 1 2 1 2 1 0 0 1 0
0 1 0 1 0 0 0 0 0 1
0 1 0 1 0 0 1 0 0 1
0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 1 0 1
1 0 0 1 0 0 1 1 1 0
0 0 0 0 1 0 0 0 0 1
0 1 2 1 0 1 1 0 0 0
10

— Restabelecer Monica
fonte

1

Mathematica 316 279 275

O objeto básico é uma matriz 10x10 com aproximadamente 60 0, 30 1 e 10 2. A matriz é usada para modificar um 10x10 GridGraph, com todas as arestas conectadas. Os nós que correspondem às células que contêm 1 na matriz são removidos do gráfico. Esses nós "segurando 2" estão todos conectados um ao outro. Em seguida, o Caminho Mais Curto é procurado entre o vértice 1 e o vértice 100. Se esse caminho não existir, o mapa será retornado; se esse caminho existir, o mapa e o menor comprimento do caminho serão mostrados.

m = Join[{0}, RandomChoice[{6, 3, 1} -> {0, 1, 2}, 98], {0}];
{s,t,u}=(Flatten@Position[m,#]&/@{0,1,2});
g=Graph@Union[EdgeList[VertexDelete[GridGraph@{10,10},t]],Subsets[u,{2}] 
/.{a_,b_}:>a \[UndirectedEdge] b];
If[IntegerQ@GraphDistance[g,1,100],{w=Grid@Partition[m,10],  
Length@FindShortestPath[g,1,100]-1},w]

Exemplo de execução :

gráfico

— DavidC
fonte

11

"Você pode se mover em qualquer campo adjacente (mesmo na diagonal)".

— precisa saber é o seguinte

0

Python (1923)

Pesquisa de retorno

É certo que não é o mais curto nem o mais eficiente, embora exista alguma memoização.

import random
l = 10
map = [
    [(lambda i: 0 if i < 7 else 1 if i < 10 else 2)(random.randint(1, 10))
     for i in range(0, l)]
    for i in range(0, l)
    ]
map[0][0] = map[l-1][l-1] = 0
print "\n".join([" ".join([str(i) for i in x]) for x in map])

paths = {}
def step(past_path, x, y):
    shortest = float("inf")
    shortest_path = []

    current_path = past_path + [(x, y)]
    pos = map[x][y]
    if (x, y) != (0, 0):
        past_pos = map[past_path[-1][0]][past_path[-1][1]]

    if (((x, y) in paths or str(current_path) in paths)
        and (pos != 2 or past_pos == 2)):
        return paths[(x, y)]
    elif x == l-1 and y == l-1:
        return ([(x, y)], 1)

    if pos == 1:
        return (shortest_path, shortest)
    if pos == 2 and past_pos != 2:
        for i2 in range(0, l):
            for j2 in range(0, l):
                pos2 = map[i2][j2]
                if pos2 == 2 and (i2, j2) not in current_path:
                    path, dist = step(current_path, i2, j2)
                    if dist < shortest and (x, y) not in path:
                        shortest = dist
                        shortest_path = path
    else:
        for i in range(x - 1, x + 2):
            for j in range(y - 1, y + 2):
                if i in range(0, l) and j in range(0, l):
                    pos = map[i][j]
                    if pos in [0, 2] and (i, j) not in current_path:
                        path, dist = step(current_path, i, j)
                        if dist < shortest and (x, y) not in path:
                            shortest = dist
                            shortest_path = path
    dist = 1 + shortest
    path = [(x, y)] + shortest_path
    if dist != float("inf"):
        paths[(x, y)] = (path, dist)
    else:
        paths[str(current_path)] = (path, dist)
    return (path, dist)

p, d = step([], 0, 0)
if d != float("inf"):
    print p, d

— vinod
fonte

11

Uau, agora isso é uma contagem de caracteres para um código de golfe! Eu acho que sua bola caiu em bruto.

— Tim Seguine

Haha, sim, eu não me incomodei em jogar o código ou tentar encontrar a implementação mais curta, mas coloquei a contagem de caracteres para que as pessoas soubessem que poderiam ignorar essa solução. Parecia um problema divertido.

— Vinod

0

JavaScript (541)

z=10
l=[[0]]
p=[]
f=[[0]]
P=[]
for(i=0;++i<z;)l[i]=[],f[i]=[]
for(i=0;++i<99;)P[i]=0,l[i/z|0][i%z]=99,f[i/z|0][i%z]=(m=Math.random(),m<=.6?0:m<=.9?1:(p.push(i),2))
f[9][9]=0
l[9][9]=99
Q=[0]
for(o=Math.min;Q.length;){if(!P[s=Q.splice(0,1)[0]]){P[s]=1
for(i=-2;++i<2;)for(j=-2;++j<2;){a=i+s/z|0,b=j+s%z
if(!(a<0||a>9||b<0||b>9)){q=l[a][b]=o(l[s/z|0][s%z]+1,l[a][b])
if(f[a][b]>1){Q=Q.concat(p)
for(m=0;t=p[m];m++)l[t/z|0][t%z]=o(l[t/z|0][t%z],q+1)}!f[a][b]?Q.push(a*z+b):''}}}}for(i=0;i<z;)console.log(f[i++])
console.log((k=l[9][9])>98?"":k)

A geração de gráficos ocorre nas cinco primeiras linhas. fcontém os campos, pmantém os portais. A pesquisa real é implementada via BFS.

Exemplo de saída:

> node maze.js
[0, 0, 0, 0, 1, 0, 0, 0, 2, 0]
[0, 1, 1, 0, 0, 1, 0, 0, 0, 2]
[0, 0, 0, 1, 0, 0, 0, 0, 1, 0]
[1, 1, 1, 0, 2, 2, 0, 1, 0, 1]
[1, 1, 0, 0, 0, 0, 1, 0, 0, 0]
[1, 1, 0, 0, 1, 0, 0, 0, 1, 1]
[0, 0, 1, 1, 0, 1, 0, 0, 2, 0]
[0, 0, 1, 0, 1, 2, 0, 1, 0, 1]
[1, 0, 0, 0, 1, 1, 1, 0, 1, 1]
[0, 1, 0, 0, 0, 0, 0, 0, 1, 0]

> node maze.js
[0, 0, 0, 0, 1, 0, 1, 0, 0, 1]
[0, 2, 0, 1, 1, 2, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
[0, 0, 0, 1, 2, 1, 1, 0, 1, 0]
[2, 0, 1, 0, 2, 2, 2, 0, 1, 0]
[1, 0, 0, 0, 1, 0, 0, 0, 1, 0]
[0, 0, 1, 0, 0, 1, 0, 1, 0, 0]
[0, 1, 2, 0, 0, 0, 0, 0, 0, 1]
[1, 0, 2, 1, 0, 1, 2, 0, 0, 1]
[0, 1, 2, 0, 0, 0, 0, 0, 0, 0]
5

— Zeta
fonte

0

Python 3 (695)

import random as r
if __name__=='__main__':
    x=144
    g,t=[1]*x,[]
    p=lambda i:12<i<131 and 0<i%12<11
    for i in range(x):
        if p(i):
            v=r.random()
            g[i]=int((v<=0.6 or i in (13,130)) and .1 or v<=0.9 and 1 or 2)
            if g[i]>1:t+=[i]
            print(g[i],end='\n' if i%12==10 else '')
    d=[99]*x
    d[13]=0
    n = list(range(x))
    m = lambda i:[i-1,i+1,i-12,i+12,i-13,i+11,i+11,i+13]
    while n:
        v = min(n,key=lambda x:d[x])
        n.remove(v)
        for s in m(v)+(t if g[v]==2 else []):
            if p(s) and g[s]!=1 and d[v]+(g[s]+g[v]<4)<d[s]:
                d[s]=d[v]+(g[s]+g[v]<3)
    if d[130]<99:print('\n'+str(d[130]))

Dijkstra!

Exemplo de saída:

— muede
fonte

0

Python, 314

import random,itertools as t
r=range(10)
a,d=[[random.choice([0]*6+[1]*3+[2])for i in r]for j in r],eval(`[[99]*10]*10`)
a[0][0]=a[9][9]=d[0][0]=0
for q,i,j,m,n in t.product(r*10,r,r,r,r):
 if a[m][n]!=1and abs(m-i)<2and abs(n-j)<2or a[i][j]==a[m][n]==2:d[m][n]=min(d[i][j]+1,d[m][n])
w=d[9][9]
print a,`w`*(w!=99)

É uma implementação nojenta da Bellman-Ford. Este algoritmo é O (n ^ 6)! (O que é aceitável para n = 10)

— Sanjeev Murty
fonte

O mapa parece realmente feio. Isso funciona se forem necessárias mais de 10 etapas?

— Reintegrar Monica

@WolframH Naturalmente: en.wikipedia.org/wiki/…

— Sanjeev Murty

Eu poderia fazer isso print '\n'.join(map(str,a)); Eu fiz print apelo bem do golfe.

— precisa saber é o seguinte

Não duvidei da correção do algoritmo :-). Eu simplesmente não tinha percebido que você faz loop com bastante frequência (o que faz; r*10tem 100 elementos).

— Reintegrar Monica

Sim. Na verdade 100 é um exagero; 99 é tudo o que é necessário.

— Sanjeev Murty

Caminho Mais Curto do Labirinto do Portal

GolfScript, 182 caracteres

Mathematica (344)

Mathematica, 208 202 caracteres

Python 3, 279

Mathematica 316 279 275

Python (1923)

JavaScript (541)

Exemplo de saída:

Python 3 (695)

Exemplo de saída:

Python, 314