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

Comentarios

Entradas populares de este blog

El juego del ahorcado, escrito en assembler i8086

ayuda memoria sobre conversion dinamica descendente y polimorfismo