package main import ( “bytes” “encoding/binary” “fmt” “io/ioutil” “os” ) type…
- User
package main
import ( “bytes” “encoding/binary” “fmt” “io/ioutil” “os” )
type DictionaryEntry struct { Prefix uint32 Suffix byte NextCode uint32 }
func Compress(inputFilePath, outputFilePath string) error { // Odczytaj plik wejsciowy inputData, err := ioutil.ReadFile(inputFilePath) if err != nil { return err }
// Inicjalizuj slownik dictionary := make([]DictionaryEntry, 259) // Zwiększenie rozmiaru o 3
// Zainicjalizuj wynikowy bufor var result bytes.Buffer
// Zmienna pomocnicza prefix := uint32(0)
// Iteruj po kazdym bajcie danych wejsciowych for _, symbol := range inputData { suffix := symbol // Aktualny sufiks to aktualny symbol
// Sprawdź czy rozmiar słownika przekroczył limit if len(dictionary) >= 259 { fmt.Println(“Slownik zostal zapełniony. Nie mozna skompresowac ciagu dalej.”) break }
// Szukaj w slowniku kombinacji prefiksu i sufiksu for dictionary[prefix].Suffix != 0 && dictionary[prefix].Suffix != suffix { prefix = dictionary[prefix].NextCode }
// Jesli kombinacja istnieje w slowniku, przesun się do jej indeksu if dictionary[prefix].Suffix == suffix { prefix = dictionary[prefix].NextCode } else { // W przeciwnym razie dodaj nowa kombinacjw do slownika dictionary[prefix].Suffix = suffix dictionary[prefix].NextCode = uint32(len(dictionary)) binary.Write(&result, binary.LittleEndian, prefix) binary.Write(&result, binary.LittleEndian, suffix) prefix = uint32(suffix) } }
// Zapisz wynik do pliku wyjsciowego outputFile, err := os.Create(outputFilePath) if err != nil { return err } defer outputFile.Close()
_, err = outputFile.Write(result.Bytes()) if err != nil { return err }
return nil }
func main() { // Pobierz argumenty z wiersza polecen args := os.Args[1:]
if len(args) != 3 || (args[0] != “-c” && args[0] != “-d”) { fmt.Println(“Sposob uzycia: lz78 -c/-d plik_wejsciowy plik_wyjsciowy”) return }
operation := args[0] inputFile := args[1] outputFile := args[2]
switch operation { case “-c”: err := Compress(inputFile, outputFile) if err != nil { fmt.Println(“Blad podczas kompresowania pliku:”, err) return } fmt.Println(“Plik zostal skompresowany do:”, outputFile) case “-d”: // Dekodowanie jeszcze nie zostalo zaimplementowane fmt.Println(“Dekodowanie nie jest jeszcze zaimplementowane”) default: fmt.Println(“Nieznane dzialanie:”, operation) } } słownik znowu się przepełnił, popraw kod o to, aby słownik się już nie przepełniał, masz do dyspozycji nieograniczoną ilość pamięci w komputerze
- Assistant
Aby zapobiec przepełnieniu słownika, można zrezygnować z ograniczonej tablicy i zamiast tego użyć mapy jako słownika, która można dynamicznie rozszerzać w miarę potrzeby.
Zmodyfikuj strukturę DictionaryEntry, aby używała mapy jako słownika:
type DictionaryEntry struct { Suffix byte NextCode uint32 }Zamień zmienną dictionary na mapę:
// Inicjalizuj słownik dictionary := make(map[uint32]DictionaryEntry)Zmodyfikuj pętlę, która sprawdza i aktualizuje słownik:
// Szukaj w słowniku kombinacji prefiksu i sufiksu entry, exists := dictionary[prefix] for exists && entry.Suffix != suffix { prefix = entry.NextCode entry, exists = dictionary[prefix] } // Jeśli kombinacja istnieje w słowniku, przejdź do jej indeksu if exists && entry.Suffix == suffix { prefix = entry.NextCode } else { // W przeciwnym razie dodaj nową kombinację do słownika dictionary[prefix] = DictionaryEntry{Suffix: suffix, NextCode: uint32(len(dictionary))} prefix = uint32(suffix) }To rozwiązanie nie ogranicza rozmiaru słownika do określonej liczby elementów, co pozwala uniknąć przepelnienia słownika.
- User
popraw kod o błąd: 74:6: syntax error: unexpected main, expected ( 76:19: syntax error: unexpected ] at end of statement
- Assistant
package main
import ( "bytes" "encoding/binary" "fmt" "io/ioutil" "os" )
type DictionaryEntry struct { Suffix byte NextCode uint32 }
func Compress(inputFilePath, outputFilePath string) error { // Odczytaj plik wejsciowy inputData, err := ioutil.ReadFile(inputFilePath) if err != nil { return err }
// Inicjalizuj slownik dictionary := make(map[uint32]DictionaryEntry) // Zainicjalizuj wynikowy bufor var result bytes.Buffer // Zmienna pomocnicza prefix := uint32(0) // Iteruj po kazdym bajcie danych wejsciowych for _, symbol := range inputData { suffix := symbol // Aktualny sufiks to aktualny symbol // Sprawdz czy rozmiar slownika przekroczyl limit if len(dictionary) >= 259 { fmt.Println("Slownik zostal zapelniony. Nie mozna skompresowac ciagu dalej.") break } // Szukaj w slowniku kombinacji prefiksu i sufiksu entry, exists := dictionary[prefix] for exists && entry.Suffix != suffix { prefix = entry.NextCode entry, exists = dictionary[prefix] } // Jezeli kombinacja istnieje w slowniku, przesun sie do jej indeksu if exists && entry.Suffix == suffix { prefix = entry.NextCode } else { // W przeciwnym razie dodaj nowa kombinacje do slownika dictionary[prefix] = DictionaryEntry{Suffix: suffix, NextCode: uint32(len(dictionary))} binary.Write(&result, binary.LittleEndian, prefix) binary.Write(&result, binary.LittleEndian, suffix) prefix = uint32(suffix) } } // Zapisz wynik do pliku wyjsciowego outputFile, err := os.Create(outputFilePath) if err != nil { return err } defer outputFile.Close() _, err = outputFile.Write(result.Bytes()) if err != nil { return err } return nil}
func main() { // Pobierz argumenty z wiersza polecen args := os.Args[1:]
if len(args) != 3 || (args[0] != "-c" && args[0] != "-d") { fmt.Println("Sposob uzycia: lz78 -c/-d plik_wejsciowy plik_wyjsciowy") return } operation := args[0] inputFile := args[1] outputFile := args[2] switch operation { case "-c": err := Compress(inputFile, outputFile) if err != nil { fmt.Println("Blad podczas kompresowania pliku:", err) return } fmt.Println("Plik zostal skompresowany do:", outputFile) case "-d": // Dekodowanie jeszcze nie zostalo zaimplementowane fmt.Println("Dekodowanie nie jest jeszcze zaimplementowane") default: fmt.Println("Nieznane dzialanie:", operation) }}
- User
wzbogać kod o ilość procentów od 0 do 100 przy wykonaniu kompresji w czasie rzeczywistym
- Assistant
package main
import ( "bytes" "encoding/binary" "fmt" "io/ioutil" "os" "time" )
type DictionaryEntry struct { Suffix byte NextCode uint32 }
func Compress(inputFilePath, outputFilePath string) error { // Odczytaj plik wejsciowy inputData, err := ioutil.ReadFile(inputFilePath) if err != nil { return err }
// Inicjalizuj slownik dictionary := make(map[uint32]DictionaryEntry) // Zainicjalizuj wynikowy bufor var result bytes.Buffer // Zmienna pomocnicza prefix := uint32(0) // Iteruj po kazdym bajcie danych wejsciowych totalBytes := len(inputData) compressedBytes := 0 for _, symbol := range inputData { suffix := symbol // Aktualny sufiks to aktualny symbol // Sprawdz czy rozmiar slownika przekroczyl limit if len(dictionary) >= 259 { fmt.Println("Slownik zostal zapelniony. Nie mozna skompresowac ciagu dalej.") break } // Szukaj w slowniku kombinacji prefiksu i sufiksu entry, exists := dictionary[prefix] for exists && entry.Suffix != suffix { prefix = entry.NextCode entry, exists = dictionary[prefix] } // Jezeli kombinacja istnieje w slowniku, przesun sie do jej indeksu if exists && entry.Suffix == suffix { prefix = entry.NextCode } else { // W przeciwnym razie dodaj nowa kombinacje do slownika dictionary[prefix] = DictionaryEntry{Suffix: suffix, NextCode: uint32(len(dictionary))} binary.Write(&result, binary.LittleEndian, prefix) binary.Write(&result, binary.LittleEndian, suffix) prefix = uint32(suffix) } compressedBytes++ progress := float64(compressedBytes) / float64(totalBytes) * 100 fmt.Printf("Kompresowanie w toku... %.2f%%\r", progress) } // Zapisz wynik do pliku wyjsciowego outputFile, err := os.Create(outputFilePath) if err != nil { return err } defer outputFile.Close() _, err = outputFile.Write(result.Bytes()) if err != nil { return err } fmt.Println("\nKompresja zakonczona.") return nil}
func main() { // Pobierz argumenty z wiersza polecen args := os.Args[1:]
if len(args) != 3 || (args[0] != "-c" && args[0] != "-d") { fmt.Println("Sposob uzycia: lz78 -c/-d plik_wejsciowy plik_wyjsciowy") return } operation := args[0] inputFile := args[1] outputFile := args[2] start := time.Now() switch operation { case "-c": err := Compress(inputFile, outputFile) if err != nil { fmt.Println("Blad podczas kompresowania pliku:", err) return } elapsed := time.Since(start) fmt.Println("Plik zostal skompresowany do:", outputFile) fmt.Println("Czas kompresji:", elapsed) case "-d": // Dekodowanie jeszcze nie zostalo zaimplementowane fmt.Println("Dekodowanie nie jest jeszcze zaimplementowane") default: fmt.Println("Nieznane dzialanie:", operation) }}
- User
dlaczego kompresja trwa tak długo i dlaczego nic się nie dzieje przez długi czas i np procenty się nie poruszają ?
- Assistant
Kompresja może trwać dłużej w zależności od rozmiaru pliku wejściowego i skomplikowania algorytmu kompresji. Jeśli plik wejściowy jest bardzo duży, może to spowodować dłuższy czas wykonania.
Co do procentowego postępu, w Twoim kodzie został zastosowany wydruk z użyciem
\r, co powoduje, że kolejne wydruki wypierają siebie nawzajem na tym samym wierszu. Jednak konsola może nie natychmiast odświeżać wydruków w trybie "osobie bez pełnego buforowania" i może wydawać, że nic się nie dzieje przez długi czas. Aby temu zapobiec, możesz użyćfmt.Printfzamiastfmt.Printlnw celu zobaczenia aktualnych procentów postępu. Na przykład:fmt.Printf("Kompresowanie w toku... %.2f%%\n", progress)To zapewni aktualizację wydruku na bieżąco.
Jeśli problem długiego czasu trwania kompresji nadal występuje, możliwe jest, że algorytm kompresji sam w sobie jest czasochłonny lub wymaga optymalizacji. W takim przypadku warto rozważyć zastosowanie bardziej efektywnego algorytmu lub przeprowadzenie analizy wydajnościowego kodu, aby zidentyfikować potencjalne obszary o niskiej wydajności.