Mensajes

Por cierto, el código está implementado con Python.

Hola a todos!!
Querría saber cómo se podría implementar el código que muestro a continuación pero utilizando bitarrays.

Código (python) [Seleccionar] Expandir


# Importamos las librerías necesarias
from tqdm import tqdm
import os
import sys

# Variables globales que apuntan a los ficheros
global archivo


# Función que muestra por pantalla las opciones que tendrá que elegir el usuario
# Por tanto, no tiene parámetros de entrada
# Pero sí de salida. Devuelve la opción que haya introducido el usuario
def menu():
   print("\nCodificación de texto con LZSS")
   print("------------------------------\n")
   
   print("\t\t MENU")
   print("1. Comprimir archivo")
   print("2. Descomprimir archivo")
   print("0. Salir")
   opcion=input("Introduzca el número de la opción a elegir: ")
   return opcion


# Función que tiene como objetivo leer un fichero
# Como parámetro de entrada se le pasa la ruta del fichero que ha introducido el usuario
# Y como parámetro de salida tiene una lista que devuelve el contenido del fichero leido
def Leer_Fichero(ruta):
   archivo = open(ruta,'r',encoding="utf-8",errors='ignore') #ponemos el utf-8 porque nuestro archivo contiene caracteres especiales
   datos = []
   for linea in archivo:
       datos.append(linea)
   archivo.close()
   return datos

# Funcion para escribir texto comprimido en archivo
def Escribe_Fichero(dest,Texto,lInsp,lMem):
   archivo = open(dest,"w")
   archivo.write(str(lInsp) + '\n')
   archivo.write(str(lMem) + '\n')
   archivo.write(Texto)
   archivo.close()
   
def Escribe_Fichero2(Ruta,Texto):
   archivo = open(Ruta,"w")
   archivo.write(Texto)
   archivo.close()
   

# Funcion para codificar
def _encode(prim,cnt):
   aux = '(' + str(hex(prim))[2:] + ',' + str(hex(cnt))[2:] + ')'
   return aux

#Funcion que devuelve inicio y fin en enteros
def _decode(Coded):
   poscoma = str.find(Coded,',')
   if poscoma != -1:
       try:
           ini = int(Coded[1 : poscoma],16)
       except:
           return 0,0
       try:
           fin = int(Coded[poscoma + 1: len(Coded)-1],16)
       except:
           return 0,0
       return ini,fin
   else:
       return 0,0

# Cadena con espacios
def _blancos(Cad,Cantidad):
   Cad = Cad + " " * Cantidad
   return Cad

# Inserta blancos al frente
def _fblancos(Cad,Cantidad):
   Cad = " " * Cantidad + Cad
   return Cad

# Mueve caracteres a la ventana de inspeccion
def _toshift(Vdel,Vins,cantidad):
   Vins = Vins[cantidad:] + Vdel[:cantidad]
   Vdel = Vdel[cantidad:]
   return Vdel,Vins

# Funcion para buscar coincidencias
def _matches(mem,insp):
   while insp != '':
       pos = str.find(mem,insp)
       if pos != -1:
           break
       else:
           insp = insp[:-1]
   return pos,len(insp)

# Funcion que devuelve un texto comprimido
def Comprimir(Texto,TamInsp,TamMem):
   V_Mem = ''
   V_Insp = ''
   V_Mem = _blancos(V_Mem,TamMem)
   V_Insp = _blancos(V_Insp,TamInsp)
   Comprimido = [] #Array donde junto el texto a guardar
   for L in tqdm(Texto):
       cant = len(L)
       cont = 1
       shcant = cont
       L_Comp = "" #Linea a comprimir
       L, V_Insp = _toshift(L,V_Insp,TamInsp)#Inicializo mi ventana insp  
       L = _blancos(L,TamInsp)
       while cont < cant:
           inicio,fin = _matches(V_Mem,V_Insp)
       #Unicamente se codificaran las coincidencias
       #mayores a la codificacion
           if (fin - inicio) < len(str(TamMem)*2)+3:
               L_Comp = L_Comp[:] + V_Insp[0]
               #Muevo un solo caracter del texto a inspeccion
               shcant = 1
               cont += shcant
           else:
               L_Comp = L_Comp[:] + _encode(inicio,fin)
               shcant = fin
               cont += shcant
           V_Insp, V_Mem = _toshift(V_Insp,V_Mem,shcant)
           V_Insp = _fblancos(V_Insp,shcant)
           L, V_Insp = _toshift(L,V_Insp,shcant)
           L = _blancos(L,TamInsp)
       Comprimido.append(L_Comp)
   return '\n'.join(Comprimido)  


def Descomprime(Texto):
   szInsp = int(Texto[0])
   szMem = int(Texto[1])
   Texto = Texto[2:]
   l_Descomp = []
   V_Mem =''
   V_Mem = _blancos(V_Mem,szMem)  
   for l in tqdm(Texto):
       s_Descomp = ''
       while l != '\n' and l!= '':
           if l[0] != '(':
               V_Mem = V_Mem[1:] + l[0]
               s_Descomp = s_Descomp + l[0]
               l = l[1:]
           else:
               PosFin = str.find(l,')')
               Encoded = l[0:PosFin+1]
               i,f = _decode(Encoded)
               if (i != 0 or f !=0):
                   s_Descomp = s_Descomp + V_Mem[i:i+f]
                   V_Mem = V_Mem[f:] + V_Mem[i:i+f]
                   l = l[PosFin+1:]
               else:
                   V_Mem = V_Mem[1:] + l[0]
                   s_Descomp = s_Descomp + l[0]
                   l = l[1:]
       l_Descomp.append(s_Descomp)
   return '\n'.join(l_Descomp)                

   
#funcion principal que llama al resto de funciones
def main():
   
   opcion = menu()
   
   while(opcion=='1'):
       flag = False
       
       while(flag==False):
           ruta=input("¿Qué texto desea comprimir? Introduzca la ruta completa:\n")
       
           if (os.path.exists(ruta) == False):
               print("\n*Archivo no encontrado*")
               print("Introduce un archivo existente.")
           else:
               flag = True
       
       TamInsp = int(input('Tamaño ventana inspección: '))
       TamMem = int(input('Tamaño ventana memoria: '))
       Documento = Leer_Fichero(ruta)
       
       if Documento != None:  
           Txt_Comp = Comprimir(Documento,TamInsp,TamMem)
           print("\n¡El archivo se ha comprimido satisfactoriamente!")
           
           dest = input('¿Dónde desea guardar dicha compresión? Introduzca la ruta destino:\n')
           
           Escribe_Fichero(dest,Txt_Comp,TamInsp,TamMem)
           print("\nEl archivo se ha guardado.\n")
       else:
           print ('NO EXISTE EL ARCHIVO/ARCHIVO VACIO')
           
       continuar = input('Pulse "INTRO" para finalizar.')
       sys.exit()
       
       
   while(opcion=='2'):
       flag = False
       
       while(flag==False):
           ruta=input("¿Que fichero desea descomprimir? Introduzca la ruta completa:\n")
           
           if (os.path.exists(ruta) == False):
               print("*Archivo no encontrado*")
               print("Introduce un archivo existente.")
           else:
               flag = True
       
       Documento=Leer_Fichero(ruta)
       toArchivo=Descomprime(Documento)
       print("\n¡El archivo se ha descomprimido satisfactoriamente!")
       dest = input('¿Dónde desea guardar la descompresión? Introduzca la ruta destino:\n')
       Escribe_Fichero2(dest,toArchivo)
       print("\nEl archivo se ha guardado.\n")
       
       continuar = input('Pulse "INTRO" para finalizar.')
       sys.exit()


main()

Muchas gracias por tu aportación, me sirve de mucho.
Pero por cierto, ¿cómo quedaría dicho código utilizando bitarrays?
Gracias.