Una posible implementacion en modo texto de una sopa de letras con python ( 2013 )
#-------------------------------------------------------------------------------
# Name: version estructurada del TP de AED-1 con python
# Purpose: desarrollar un juego estrucutarado que contenga
# las ideas fundamentales del trabajo con matrices
# Author: D'Achary Vladimiro Gaston
#
# Created: 20/10/2013
# Copyright: (c) NERV 2013
# Licence: <licenciatura en sistemas - UNGS>
#
# Aclaracion: La version no tien verificacion de indices para el
# ingreso de las coordenadas, si se las ingresa adecuadamente
# el programa no va a tener problema con los indices de la matriz
#-------------------------------------------------------------------------------
# --------------------------------------------------------------
# IMPORTACION DE LIBRERIAS
# --------------------------------------------------------------
from math import sqrt
from time import sleep
# -----------------------------------------------------------------
# INICIALIZACION DE LAS CONSTANTES LOCALES DEL PROGRAMA PRINCIPAL
# -----------------------------------------------------------------
opcionesValidas=["horizontal","vertical","diag creciente","diag decreciente","exit"]
# ---------------------------------------------------------------
# INICIALIZACION DE LAS VARIABLES LOCALES DEL PROGRAMA PRINCIPAL
# ---------------------------------------------------------------
## para la creacion de la matriz
cadena=""
listaCadena=[]
tokens=[]
## contadores
cantFallidos=0
cantAciertos=0
## bandera
llegoElFin=False
## variables del usuario
opcionUsuario=""
fila=0
desde=0
hasta=0
# --------------------------------------------------------------
# DECLARACION DE FUNCIONES Y PROCEDIMIENTOS
# --------------------------------------------------------------
## la funcion borra una ocurrencia c de una cadena s
def borraOcurrencia(s,c):
i=0
largo=len(s)
nuevaCadena=""
while i<=largo-1:
if s[i]!=c:
nuevaCadena=nuevaCadena+s[i]
i=i+1
return nuevaCadena
## la funcion borra una serie de ocurrencias
def limpiaPalabra(cad):
cad=borraOcurrencia(cad," ")
cad=borraOcurrencia(cad,"'")
cad=borraOcurrencia(cad,"[")
cad=borraOcurrencia(cad,",")
cad=borraOcurrencia(cad,"]")
return cad
# recibe una cadena de caracteres y la devuelve invertida
def inviertePalabra(cad):
cadVacia=""
for i in range(len(cad)-1,-1,-1):
cadVacia=cadVacia+cad[i]
return cadVacia
# elimina todos los elementos $tok de una lista
# ejemplo. A=[1,0,1,3,2,0]
# A=(eliminaDeLista(A,0)) --> A=[1,1,3,2]
def eliminador(lista,tok):
if lista!=[]:
i=len(lista)-1
while (i>=0):
if lista[i]==tok:
lista.pop(i)
i=i-1
else:
lista=-1
return lista
# devuelve true si el token $tok esta en la lista
# ejemplo: a="mariana,jorge,patito,titi"
# seekLista(a,"pimba") -->> False
def seekLista(lista,tok):
i=0
llegoElFin=False
contieneElTok=False
while (i<=len(lista)-1) and (llegoElFin!=True):
if lista[i]==tok:
contieneElTok=True
llegoElFin=True
i=i+1
return contieneElTok
# procedimiento que imprime en pantalla la partada del juego
def presentacion():
print(" ------------------------------")
print(" juego de sopa de letras ")
print(" programado por vladimiroGaston")
print("-------------------------------")
print()
print()
sleep(5)
for i in range(0,300):
print()
# la funcion recibe en su parametro los argumentos lista, la cual debe ser una
# lista vacia, la cantidad de filas y columnas que va a contener.
# ejemplo:
# creaMatriz(matriz,2,2)--> [0,0]
# --> [0,0]
def creaMatriz(lista
,filas
,columnas):
todoBien=False
if (lista==[]) and (filas>0) and (columnas>0):
listaUno=[]
for i in range(0,columnas):
listaUno.append(0)
for i in range(0,filas):
lista.append(listaUno)
todoBien=True
if todoBien==False:
return -1
else:
return lista
# la funcion cargaMatriz recibe como argumentos a una matriz y a una cadena de
# caracteres, la que va a ir cargandose con cada uno de sus caracteres en las
# distintas posiciones de la matriz
def cargaMatriz(matriz,cadena):
## determina si la raiz cuadrada es exacta
def esCuadradoPerfecto(numero):
num=numero
numb=int(num)
esCuadrado=False
if (sqrt(numb)*sqrt(numb)) == num:
esCuadrado=True
return esCuadrado
lista=list(cadena)
valor=int(sqrt(len(cadena)))
todoBien=(esCuadradoPerfecto(len(cadena))==True)
if todoBien==True:
matriz=[]
matriz=creaMatriz(matriz,valor,valor)
desde=0
hasta=valor
for i in range(0,valor):
matriz[i]=lista[desde:hasta]
desde=hasta
hasta=desde+valor
return matriz
else:
matriz=-1
return matriz
# el procedimiento imprime matriz, va a dibujar la matriz en la pantalla, como
# su cabecera y la leyenda con la cantidad de palabras a encontrar en la matriz
# la cantidad de aciertos y desaciertos
def imprimeMatriz(matriz
,cadena
,palabras
,cantFallidos
,cantAciertos):
## la funcion replica una n cantidad de un caracter c
def replicate(c,cant):
buff=""
for i in range(0,cant):
buff=buff+c
return buff
print(replicate("-",55))
print(" ^_^ SOPA DE LETRAS ^_^ ")
print(replicate("-",55))
for i in range(0,len(matriz)):
print(i,"->",matriz[i])
print(replicate("-",55))
print()
print()
print("encuentre las palabras",palabras)
print("intentos fallidos",cantFallidos)
print("aciertos: ",cantAciertos)
print()
if llegoElFin!=True:
print("ingrese las cordenadas de la palabra")
def creaPalabra(matriz,opcionUsuario,fila,desde,hasta):
## la funcion borra una ocurrencia c de una cadena s
def borraOcurrencia(s,c):
i=0
largo=len(s)
cad=""
while i<=largo-1:
if s[i]!=c:
cad=cad+s[i]
i=i+1
return cad
## la funcion borra una serie de ocurrencias
def limpiaPalabra(cad):
cad=borraOcurrencia(cad," ")
cad=borraOcurrencia(cad,"'")
cad=borraOcurrencia(cad,"[")
cad=borraOcurrencia(cad,",")
cad=borraOcurrencia(cad,"]")
return cad
pal=[]
palabra=""
if opcionUsuario=="horizontal":
pal.append(matriz[fila][desde:hasta])
palabra=str(pal)
palabra=limpiaPalabra(palabra)
else:
if opcionUsuario=="vertical":
for i in range(fila,desde):
pal.append(matriz[i][hasta])
palabra=str(pal)
palabra=limpiaPalabra(palabra)
else:
if opcionUsuario=="diag decreciente":
for i in range(fila,hasta):
pal.append(matriz[i][desde])
desde=desde+1
palabra=str(pal)
palabra=limpiaPalabra(palabra)
else:
if (opcionUsuario=="diag creciente"):
for i in range(desde,hasta,1):
pal.append(matriz[fila][i])
fila=fila-1
palabra=str(pal)
palabra=limpiaPalabra(palabra)
return palabra
# --------------------------------------------------------------
# -- INICIO -- CUERPO DEL PROGRAMA PRINCIPAL
# --------------------------------------------------------------
## ---------------------------------------------
## -- SE ABRE EL ARCHIVO FISICO --
## ---------------------------------------------
cadena="abcdeflhijklautorotuvwxyzabcrbocrabebcdofghijabcdvfghiaklmnapqrsvvvwxvozobciibnindefgnonaocdefgornln"
tokens=["auto", "barco", "avion","loro"]
## ----------------------------------------------
## ----------------------------------------------
## crea una matriz cargada con el string cadena y lo almacena en la
## variable matriz, del programa principal
matriz=[]
## carga la matriz con la cadena de caracteres de la sopa
matriz=cargaMatriz(matriz,cadena)
## carga en pantalla la presentacion del juego y el nombre del programador
presentacion()
## imprime la matriz ya creada, con las columnas y filas numeradas
imprimeMatriz(matriz
,cadena
,tokens
,cantFallidos
,cantAciertos)
## mientras no llegue el final del juego entonces ...
while (llegoElFin!=True):
## inicializa las variables "LOCALES DEL CUERPO DEL PROGRAMA"
## palabra para las coordenadas del usuario y pal para la sublista
## de esas coordenadas
palabra=""
pal=[]
## ingreso de la posicion de la palabra y las coordenadas
opcionUsuario=input("ingrese opcion")
## verifica que la opcion ingresada por el usuario es valida
while (seekLista(opcionesValidas,opcionUsuario) != True):
opcionUsuario=input("ingrese opcion")
if opcionUsuario!="exit":
## ingreso del juego de coordenadas
fila=int(input("elija la fila:"))
desde=int(input("desde la columna:"))
hasta=int(input("hasta la columna:"))
## si la opcion es horizontal
if ( opcionUsuario=="horizontal" ):
palabra=creaPalabra(matriz,opcionUsuario,fila,desde,hasta)
else:
if (opcionUsuario=="vertical"):
palabra=creaPalabra(matriz,opcionUsuario,fila,desde,hasta)
else:
if (opcionUsuario=="diag decreciente"):
palabra=creaPalabra(matriz,opcionUsuario,fila,desde,hasta)
else:
if (opcionUsuario=="diag creciente"):
palabra=creaPalabra(matriz,opcionUsuario,fila,desde,hasta)
print(palabra)
if seekLista(tokens,palabra)==True:
cantAciertos=cantAciertos+1
tokens=eliminador(tokens,palabra)
else:
if seekLista(tokens,inviertePalabra(palabra))==True:
cantAciertos=cantAciertos+1
palabra=inviertePalabra(palabra)
tokens=eliminador(tokens,palabra)
else:
cantFallidos=cantFallidos+1
if ( tokens==[] ):
llegoElFin=True
imprimeMatriz(matriz
,cadena
,tokens
,cantFallidos
,cantAciertos)
print("la palabra ingresada fue: ",palabra)
else:
llegoElFin=True
## ---------------------------------------------
## -- SE CIERRA EL ARCHIVO FISICO --
## ---------------------------------------------
sleep(3)
# --------------------------------------------------------------
# -- FIN -- CUERPO DEL PROGRAMA PRINCIPAL
# --------------------------------------------------------------
# Name: version estructurada del TP de AED-1 con python
# Purpose: desarrollar un juego estrucutarado que contenga
# las ideas fundamentales del trabajo con matrices
# Author: D'Achary Vladimiro Gaston
#
# Created: 20/10/2013
# Copyright: (c) NERV 2013
# Licence: <licenciatura en sistemas - UNGS>
#
# Aclaracion: La version no tien verificacion de indices para el
# ingreso de las coordenadas, si se las ingresa adecuadamente
# el programa no va a tener problema con los indices de la matriz
#-------------------------------------------------------------------------------
# --------------------------------------------------------------
# IMPORTACION DE LIBRERIAS
# --------------------------------------------------------------
from math import sqrt
from time import sleep
# -----------------------------------------------------------------
# INICIALIZACION DE LAS CONSTANTES LOCALES DEL PROGRAMA PRINCIPAL
# -----------------------------------------------------------------
opcionesValidas=["horizontal","vertical","diag creciente","diag decreciente","exit"]
# ---------------------------------------------------------------
# INICIALIZACION DE LAS VARIABLES LOCALES DEL PROGRAMA PRINCIPAL
# ---------------------------------------------------------------
## para la creacion de la matriz
cadena=""
listaCadena=[]
tokens=[]
## contadores
cantFallidos=0
cantAciertos=0
## bandera
llegoElFin=False
## variables del usuario
opcionUsuario=""
fila=0
desde=0
hasta=0
# --------------------------------------------------------------
# DECLARACION DE FUNCIONES Y PROCEDIMIENTOS
# --------------------------------------------------------------
## la funcion borra una ocurrencia c de una cadena s
def borraOcurrencia(s,c):
i=0
largo=len(s)
nuevaCadena=""
while i<=largo-1:
if s[i]!=c:
nuevaCadena=nuevaCadena+s[i]
i=i+1
return nuevaCadena
## la funcion borra una serie de ocurrencias
def limpiaPalabra(cad):
cad=borraOcurrencia(cad," ")
cad=borraOcurrencia(cad,"'")
cad=borraOcurrencia(cad,"[")
cad=borraOcurrencia(cad,",")
cad=borraOcurrencia(cad,"]")
return cad
# recibe una cadena de caracteres y la devuelve invertida
def inviertePalabra(cad):
cadVacia=""
for i in range(len(cad)-1,-1,-1):
cadVacia=cadVacia+cad[i]
return cadVacia
# elimina todos los elementos $tok de una lista
# ejemplo. A=[1,0,1,3,2,0]
# A=(eliminaDeLista(A,0)) --> A=[1,1,3,2]
def eliminador(lista,tok):
if lista!=[]:
i=len(lista)-1
while (i>=0):
if lista[i]==tok:
lista.pop(i)
i=i-1
else:
lista=-1
return lista
# devuelve true si el token $tok esta en la lista
# ejemplo: a="mariana,jorge,patito,titi"
# seekLista(a,"pimba") -->> False
def seekLista(lista,tok):
i=0
llegoElFin=False
contieneElTok=False
while (i<=len(lista)-1) and (llegoElFin!=True):
if lista[i]==tok:
contieneElTok=True
llegoElFin=True
i=i+1
return contieneElTok
# procedimiento que imprime en pantalla la partada del juego
def presentacion():
print(" ------------------------------")
print(" juego de sopa de letras ")
print(" programado por vladimiroGaston")
print("-------------------------------")
print()
print()
sleep(5)
for i in range(0,300):
print()
# la funcion recibe en su parametro los argumentos lista, la cual debe ser una
# lista vacia, la cantidad de filas y columnas que va a contener.
# ejemplo:
# creaMatriz(matriz,2,2)--> [0,0]
# --> [0,0]
def creaMatriz(lista
,filas
,columnas):
todoBien=False
if (lista==[]) and (filas>0) and (columnas>0):
listaUno=[]
for i in range(0,columnas):
listaUno.append(0)
for i in range(0,filas):
lista.append(listaUno)
todoBien=True
if todoBien==False:
return -1
else:
return lista
# la funcion cargaMatriz recibe como argumentos a una matriz y a una cadena de
# caracteres, la que va a ir cargandose con cada uno de sus caracteres en las
# distintas posiciones de la matriz
def cargaMatriz(matriz,cadena):
## determina si la raiz cuadrada es exacta
def esCuadradoPerfecto(numero):
num=numero
numb=int(num)
esCuadrado=False
if (sqrt(numb)*sqrt(numb)) == num:
esCuadrado=True
return esCuadrado
lista=list(cadena)
valor=int(sqrt(len(cadena)))
todoBien=(esCuadradoPerfecto(len(cadena))==True)
if todoBien==True:
matriz=[]
matriz=creaMatriz(matriz,valor,valor)
desde=0
hasta=valor
for i in range(0,valor):
matriz[i]=lista[desde:hasta]
desde=hasta
hasta=desde+valor
return matriz
else:
matriz=-1
return matriz
# el procedimiento imprime matriz, va a dibujar la matriz en la pantalla, como
# su cabecera y la leyenda con la cantidad de palabras a encontrar en la matriz
# la cantidad de aciertos y desaciertos
def imprimeMatriz(matriz
,cadena
,palabras
,cantFallidos
,cantAciertos):
## la funcion replica una n cantidad de un caracter c
def replicate(c,cant):
buff=""
for i in range(0,cant):
buff=buff+c
return buff
print(replicate("-",55))
print(" ^_^ SOPA DE LETRAS ^_^ ")
print(replicate("-",55))
for i in range(0,len(matriz)):
print(i,"->",matriz[i])
print(replicate("-",55))
print()
print()
print("encuentre las palabras",palabras)
print("intentos fallidos",cantFallidos)
print("aciertos: ",cantAciertos)
print()
if llegoElFin!=True:
print("ingrese las cordenadas de la palabra")
def creaPalabra(matriz,opcionUsuario,fila,desde,hasta):
## la funcion borra una ocurrencia c de una cadena s
def borraOcurrencia(s,c):
i=0
largo=len(s)
cad=""
while i<=largo-1:
if s[i]!=c:
cad=cad+s[i]
i=i+1
return cad
## la funcion borra una serie de ocurrencias
def limpiaPalabra(cad):
cad=borraOcurrencia(cad," ")
cad=borraOcurrencia(cad,"'")
cad=borraOcurrencia(cad,"[")
cad=borraOcurrencia(cad,",")
cad=borraOcurrencia(cad,"]")
return cad
pal=[]
palabra=""
if opcionUsuario=="horizontal":
pal.append(matriz[fila][desde:hasta])
palabra=str(pal)
palabra=limpiaPalabra(palabra)
else:
if opcionUsuario=="vertical":
for i in range(fila,desde):
pal.append(matriz[i][hasta])
palabra=str(pal)
palabra=limpiaPalabra(palabra)
else:
if opcionUsuario=="diag decreciente":
for i in range(fila,hasta):
pal.append(matriz[i][desde])
desde=desde+1
palabra=str(pal)
palabra=limpiaPalabra(palabra)
else:
if (opcionUsuario=="diag creciente"):
for i in range(desde,hasta,1):
pal.append(matriz[fila][i])
fila=fila-1
palabra=str(pal)
palabra=limpiaPalabra(palabra)
return palabra
# --------------------------------------------------------------
# -- INICIO -- CUERPO DEL PROGRAMA PRINCIPAL
# --------------------------------------------------------------
## ---------------------------------------------
## -- SE ABRE EL ARCHIVO FISICO --
## ---------------------------------------------
cadena="abcdeflhijklautorotuvwxyzabcrbocrabebcdofghijabcdvfghiaklmnapqrsvvvwxvozobciibnindefgnonaocdefgornln"
tokens=["auto", "barco", "avion","loro"]
## ----------------------------------------------
## ----------------------------------------------
## crea una matriz cargada con el string cadena y lo almacena en la
## variable matriz, del programa principal
matriz=[]
## carga la matriz con la cadena de caracteres de la sopa
matriz=cargaMatriz(matriz,cadena)
## carga en pantalla la presentacion del juego y el nombre del programador
presentacion()
## imprime la matriz ya creada, con las columnas y filas numeradas
imprimeMatriz(matriz
,cadena
,tokens
,cantFallidos
,cantAciertos)
## mientras no llegue el final del juego entonces ...
while (llegoElFin!=True):
## inicializa las variables "LOCALES DEL CUERPO DEL PROGRAMA"
## palabra para las coordenadas del usuario y pal para la sublista
## de esas coordenadas
palabra=""
pal=[]
## ingreso de la posicion de la palabra y las coordenadas
opcionUsuario=input("ingrese opcion")
## verifica que la opcion ingresada por el usuario es valida
while (seekLista(opcionesValidas,opcionUsuario) != True):
opcionUsuario=input("ingrese opcion")
if opcionUsuario!="exit":
## ingreso del juego de coordenadas
fila=int(input("elija la fila:"))
desde=int(input("desde la columna:"))
hasta=int(input("hasta la columna:"))
## si la opcion es horizontal
if ( opcionUsuario=="horizontal" ):
palabra=creaPalabra(matriz,opcionUsuario,fila,desde,hasta)
else:
if (opcionUsuario=="vertical"):
palabra=creaPalabra(matriz,opcionUsuario,fila,desde,hasta)
else:
if (opcionUsuario=="diag decreciente"):
palabra=creaPalabra(matriz,opcionUsuario,fila,desde,hasta)
else:
if (opcionUsuario=="diag creciente"):
palabra=creaPalabra(matriz,opcionUsuario,fila,desde,hasta)
print(palabra)
if seekLista(tokens,palabra)==True:
cantAciertos=cantAciertos+1
tokens=eliminador(tokens,palabra)
else:
if seekLista(tokens,inviertePalabra(palabra))==True:
cantAciertos=cantAciertos+1
palabra=inviertePalabra(palabra)
tokens=eliminador(tokens,palabra)
else:
cantFallidos=cantFallidos+1
if ( tokens==[] ):
llegoElFin=True
imprimeMatriz(matriz
,cadena
,tokens
,cantFallidos
,cantAciertos)
print("la palabra ingresada fue: ",palabra)
else:
llegoElFin=True
## ---------------------------------------------
## -- SE CIERRA EL ARCHIVO FISICO --
## ---------------------------------------------
sleep(3)
# --------------------------------------------------------------
# -- FIN -- CUERPO DEL PROGRAMA PRINCIPAL
# --------------------------------------------------------------
Comentarios
Publicar un comentario