proszę popraw program, aby nie stał w miejscu, nie zawieszał się po skończeniu…
- User
proszę popraw program, aby nie stał w miejscu, nie zawieszał się po skończeniu kompresji, oto kod: 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 }
outputFile.Sync() // Dodaj synchronizację, aby zagwarantować zapis do pliku 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) } }
- 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 } err = outputFile.Sync() // Dodaj synchronizację, aby zagwarantować zapis do pliku 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
ile trwa kompresja tym algorytmem z plikiem wejściowym zajmującym 150 kilo ?
- Assistant
Czas kompresji zależy od wielu czynników, takich jak moc obliczeniowa komputera, szybkość dysku twardego i rozmiar pliku wejściowego. Nie można dokładnie określić czasu kompresji dla konkretnego pliku wejściowego bez wykonania pomiarów na konkretnej maszynie.
Jednakże, możesz użyć funkcji time do zmierzenia czasu kompresji dla Twojego pliku wejściowego. Wycinek kodu poniżej pokazuje, jak to zrobić:
start := time.Now() err := Compress(inputFile, outputFile) if err != nil { fmt.Println("Blad podczas kompresowania pliku:", err) return } elapsed := time.Since(start) fmt.Println("Czas kompresji:", elapsed)Po wykonaniu tego kodu, otrzymasz informację w formacie "Czas kompresji: Xs", gdzie X będzie oznaczać czas trwania kompresji w sekundach. Należy pamiętać, że ten czas jest tylko orientacyjny i różne czynniki mogą wpływać na dokładność tego pomiaru.
- User
zmodyfikuj kod, aby wykorzystywał wszystkie dostępne rdzenie procesora, aby przyśpieszyć kompresję
- Assistant
Aby wykorzystać wszystkie dostępne rdzenie procesora i przyspieszyć kompresję, możesz użyć współbieżności. Możemy zaimplementować to przy użyciu gorutyn.
Oto zmodyfikowany kod:
package main import ( "bytes" "encoding/binary" "fmt" "io/ioutil" "os" "runtime" "sync" "time" ) type DictionaryEntry struct { Suffix byte NextCode uint32 } func Compress(inputFilePath, outputFilePath string) error { // Odczytaj plik wejściowy inputData, err := ioutil.ReadFile(inputFilePath) if err != nil { return err } // Inicjalizuj słownik dictionary := make(map[uint32]DictionaryEntry) mutex := sync.Mutex{} // Dodaj mutex do synchronizacji dostępu do słownika // Inicjalizuj wynikowy bufor var result bytes.Buffer // Zmienna pomocnicza prefix := uint32(0) // Iteruj po każdym bajcie danych wejściowych totalBytes := len(inputData) compressedBytes := 0 // Pobierz liczbę dostępnych rdzeni procesora numCPU := runtime.NumCPU() // Utwórz semafor, aby ograniczyć liczbę gorutyn semaphore := make(chan struct{}, numCPU) wg := sync.WaitGroup{} wg.Add(totalBytes) // Iteruj po każdym symbolu danych wejściowych for _, symbol := range inputData { // Wykorzystaj gorutynę do kompresji symbolu go func(symbol byte) { // Ogranicz liczbę jednocześnie działających gorutyn semaphore <- struct{}{} defer func() { <-semaphore wg.Done() }() suffix := symbol // Aktualny sufiks to aktualny symbol // Sprawdz czy rozmiar słownika przekroczył limit mutex.Lock() if len(dictionary) >= 259 { fmt.Println("Słownik został zapełniony. Nie można skompresować ciągu dalej.") mutex.Unlock() return } // Szukaj w słowniku kombinacji prefiksu i sufiksu entry, exists := dictionary[prefix] for exists && entry.Suffix != suffix { prefix = entry.NextCode entry, exists = dictionary[prefix] } // Jezeli kombinacja istnieje w słowniku, przesuń się 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))} mutex.Unlock() binary.Write(&result, binary.LittleEndian, prefix) binary.Write(&result, binary.LittleEndian, suffix) mutex.Lock() prefix = uint32(suffix) } compressedBytes++ progress := float64(compressedBytes) / float64(totalBytes) * 100 fmt.Printf("Kompresowanie w toku... %.2f%%\r", progress) mutex.Unlock() }(symbol) } // Czekaj na zakończenie wszystkich gorutyn wg.Wait() // Zapisz wynik do pliku wyjściowego outputFile, err := os.Create(outputFilePath) if err != nil { return err } defer outputFile.Close() _, err = outputFile.Write(result.Bytes()) if err != nil { return err } err = outputFile.Sync() // Dodaj synchronizację, aby zagwarantować zapis do pliku if err != nil { return err } fmt.Println("\nKompresja zakończona.") return nil } func main() { // Pobierz argumenty z wiersza poleceń args := os.Args[1:] if len(args) != 3 || (args[0] != "-c" && args[0] != "-d") { fmt.Println("Sposób użycia: lz78 -c/-d plik_wejściowy plik_wyjściowy") 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("Błąd podczas kompresowania pliku:", err) return } elapsed := time.Since(start) fmt.Println("Plik został skompresowany do:", outputFile) fmt.Println("Czas kompresji:", elapsed) case "-d": // Dekodowanie nie zostało jeszcze zaimplementowane fmt.Println("Dekodowanie nie jest jeszcze zaimplementowane") default: fmt.Println("Nieznane działanie:", operation) } }W tym kodzie używamy semaforów, aby ograniczyć liczbę jednocześnie działających gorutyn do liczby dostępnych rdzeni procesora. Każda iteracja pętli for wywołuje gorutynę do kompresji danego symbolu, co umożliwia równoległe przetwarzanie danych. Mutex jest używany do synchronizacji dostępu do słownika, aby uniknąć wyścigów i niepoprawnych wyników kompresji.
- User
wymuś na programie zapis do pliku wynikowego, jak tylko program osiągnie maksymalną kompresję
- Assistant
Aby wymusić zapis do pliku wynikowego, jak tylko program osiągnie maksymalną kompresję, modyfikujemy kod w sekcji "W przeciwnym razie dodaj nową kombinację do słownika" w funkcji
Compress.Oto zmodyfikowany kod, który dodaje zapis do pliku wynikowego, gdy słownik zostanie zapełniony:
// W przeciwnym razie dodaj nową kombinację do słownika 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 wyjściowego _, err = outputFile.Write(result.Bytes()) if err != nil { return err } err = outputFile.Sync() if err != nil { return err } // Wyślij sygnał o maksymalnej kompresji fmt.Println("Osiągnięto maksymalną kompresję. Zapisuję do pliku wynikowego.") breakDodaliśmy kod zapisu do pliku wynikowego zaraz po dodaniu nowej kombinacji do słownika. Następnie wywołujemy
outputFile.Sync(), aby zagwarantować, że dane zostaną zapisane na dysku.Po wyświetleniu komunikatu o osiągnięciu maksymalnej kompresji, przerywamy pętlę
forza pomocąbreak, aby zakończyć kompresję.W ten sposób, gdy słownik zostanie zapełniony, program natychmiast zapisze wynik do pliku wyjściowego.
- User
zaimplementuj ostatnią poprawkę kodu do całego kodu źródłowego
- Assistant
Oto pełny kod źródłowy z zaimplementowaną ostatnią poprawką:
package main import ( "bytes" "encoding/binary" "fmt" "io/ioutil" "os" "runtime" "sync" "time" ) type DictionaryEntry struct { Suffix byte NextCode uint32 } func Compress(inputFilePath, outputFilePath string) error { // Odczytaj plik wejściowy inputData, err := ioutil.ReadFile(inputFilePath) if err != nil { return err } // Inicjalizuj słownik dictionary := make(map[uint32]DictionaryEntry) mutex := sync.Mutex{} // Dodaj mutex do synchronizacji dostępu do słownika // Inicjalizuj wynikowy bufor var result bytes.Buffer // Zmienna pomocnicza prefix := uint32(0) // Iteruj po każdym bajcie danych wejściowych totalBytes := len(inputData) compressedBytes := 0 // Pobierz liczbę dostępnych rdzeni procesora numCPU := runtime.NumCPU
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.