Skip to content
The Chat Archive
gpt-3.5-turbo-0613· OpenAI WildChat-4.8M (AI2)

package main import ( "bytes" "encoding/binary" "fmt" "io/ioutil" "os" "time" ) type…

  1. User

    package main

    import ( "bytes" "encoding/binary" "fmt" "io/ioutil" "os" "time" )

    type DictionaryEntry struct { Prefix uint16 Suffix byte NextPos uint16 }

    func Compress(inputFilePath, outputFilePath string) error { // Odczytaj plik wejsciowy inputData, err := ioutil.ReadFile(inputFilePath) if err != nil { return err }

    // Inicjalizuj slownik
    dictionary := make(map[uint16]DictionaryEntry)
    
    // Inicjalizuj wynikowy bufor
    var result bytes.Buffer
    
    // Zmienna pomocnicza
    pos := uint16(0)
    
    // Iteruj po kazdym bajcie danych wejsciowych
    totalBytes := len(inputData)
    compressedBytes := 0
    
    // Dodaj poczatkowe wpisy do slownika
    for i := 0; i < 256; i++ {
    	dictionary[uint16(i)] = DictionaryEntry{Prefix: 0, Suffix: byte(i), NextPos: uint16(i) + 1}
    }
    
    // Iteruj po kazdym symbolu danych wejsciowych
    for pos < uint16(totalBytes) {
    	// Znajdz najdluzsza kombinacje powtarzajacych sie symboli
    	prefixPos, suffix := findLongestMatch(inputData, pos, dictionary)
    
    	// Dodaj kombinacje do slownika
    	dictionary[pos] = DictionaryEntry{Prefix: prefixPos, Suffix: suffix, NextPos: pos + 1}
    
    	// Zapisz wynik do bufora
    	binary.Write(&result, binary.LittleEndian, prefixPos)
    	result.WriteByte(suffix)
    
    	// Przesun pozycje w danych wejsciowych
    	pos++
    
    	compressedBytes++
    
    	progress := float64(compressedBytes) / float64(totalBytes) * 100
    	fmt.Printf("Kompresowanie w toku… %.2f%%\r", progress)
    }
    
    // Otworz plik wyjsciowy
    outputFile, err := os.Create(outputFilePath)
    if err != nil {
    	return err
    }
    defer outputFile.Close()
    
    // Zapisz zawartosc bufora do pliku wyjsciowego
    _, err = outputFile.Write(result.Bytes())
    if err != nil {
    	return err
    }
    
    fmt.Println("\nKompresja zakonczona.")
    return nil
    

    }

    func Decompress(inputFilePath, outputFilePath string) error { // Odczytaj plik wejsciowy inputData, err := ioutil.ReadFile(inputFilePath) if err != nil { return err }

    // Inicjalizuj slownik
    dictionary := make(map[uint16]DictionaryEntry)
    
    // Inicjalizuj bufor do przechowywania zdekodowanych danych
    var result bytes.Buffer
    
    // Iteruj po kazdych trzech bajtach danych wejsciowych
    for i := 0; i+2 < len(inputData); i += 3 {
    	prefixPosBytes := inputData[i : i+2]
    	suffixByte := inputData[i+2]
    
    	var prefixPos uint16
    
    	// Odczytaj wartosc pozycji prefiksu
    	err := binary.Read(bytes.NewReader(prefixPosBytes), binary.LittleEndian, &prefixPos)
    	if err != nil {
    		return err
    	}
    
    	// Sprawdz czy kombinacja istnieje w slowniku
    	entry, exists := dictionary[prefixPos]
    	if exists {
    		// Jesli kombinacja istnieje, zapisz sufiks jako wynik dekodowania
    		result.WriteByte(entry.Suffix)
    
    		// Dodaj nowa kombinacje do slownika
    		dictionary[uint16(len(dictionary))] = DictionaryEntry{Prefix: prefixPos, Suffix: entry.Suffix, NextPos: uint16(len(dictionary))}
    	} else {
    		// Jesli kombinacja nie istnieje, dodaj nowa kombinacje do slownika na podstawie prefiksu i sufiksu
    		dictionary[uint16(len(dictionary))] = DictionaryEntry{Prefix: prefixPos, Suffix: suffixByte, NextPos: uint16(len(dictionary))}
    		result.WriteByte(suffixByte)
    	}
    }
    
    // Zapisz wynik do pliku wyjsciowego
    err = ioutil.WriteFile(outputFilePath, result.Bytes(), 0644)
    if err != nil {
    	return err
    }
    
    fmt.Println("Dekompresja zakonczona.")
    return nil
    

    }

    func findLongestMatch(inputData []byte, pos uint16, dictionary map[uint16]DictionaryEntry) (uint16, byte) { maxMatchLen := uint16(0) maxMatchPos := uint16(0) nextSymbol := byte(0)

    // Iteruj po wszystkich kombinacjach w slowniku
    for dictPos, entry := range dictionary {
    	if entry.Prefix == pos && uint16(entry.Suffix) > maxMatchLen {
    		maxMatchLen = uint16(entry.Suffix)
    		maxMatchPos = dictPos
    		nextSymbol = inputData[pos+maxMatchLen]
    	}
    }
    
    return maxMatchPos, nextSymbol
    

    }

    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: lz77 -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":
    	err := Decompress(inputFile, outputFile)
    	if err != nil {
    		fmt.Println("Blad podczas dekompresowania pliku:", err)
    		return
    	}
    	elapsed := time.Since(start)
    	fmt.Println("Plik zostal zdekompresowany do:", outputFile)
    	fmt.Println("Czas dekompresji:", elapsed)
    default:
    	fmt.Println("Nieznane dzialanie:", operation)
    }
    

    }

    przy kompresji nadal występują puste linie lub spacje, a przy dekompresji powtarzająca się litera r , skoryguj te błędy

  2. Assistant

    W celu skorygowania problemów z pustymi liniami i powtarzającą się literą "r" podczas kompresji lub dekompresji, należy dokonać kilku zmian w kodzie.

    1. Aby usunąć puste linie lub spacje podczas kompresji, możemy zastosować funkcję "TrimSpace" z pakietu "strings" do usunięcia niepotrzebnych znaków białych przed odczytaniem pliku wejściowego. Oto zmieniony kod funkcji "Compress":
    func Compress(inputFilePath, outputFilePath string) error {
    	// Odczytaj plik wejsciowy
    	inputData, err := ioutil.ReadFile(inputFilePath)
    	if err != nil {
    		return err
    	}
    
    	// Usuń puste linie i spacje
    	inputData = bytes.TrimSpace(inputData)
    
    	// Inicjalizuj slownik
    	dictionary := make(map[uint16]DictionaryEntry)
    
    	// Inicjalizuj wynikowy bufor
    	var result bytes.Buffer
    
    	// ...
    }
    
    1. Aby skorygować problem ze zduplikowaną literą "r" podczas dekompresji, musimy zmienić sposób zapisu danych wejściowych w pętli "for" funkcji "Decompress". Zamiast iterować po każdych trzech bajtach danych wejściowych, zmienimy to na iterację co dwa bajty. Oto zmieniony kod:
    func Decompress(inputFilePath, outputFilePath string) error {
    	// Odczytaj plik wejsciowy
    	inputData, err := ioutil.ReadFile(inputFilePath)
    	if err != nil {
    		return err
    	}
    
    	// Inicjalizuj slownik
    	dictionary := make(map[uint16]DictionaryEntry)
    
    	// Inicjalizuj bufor do przechowywania zdekodowanych danych
    	var result bytes.Buffer
    
    	// Iteruj po kazdych dwoch bajtach danych wejsciowych
    	for i := 0; i+1 < len(inputData); i += 2 {
    		prefixPosBytes := inputData[i : i+2]
    
    		// ...
    	}
    }
    

    Te zmiany powinny rozwiązać problemy z pustymi liniami i powtarzającą się literą "r" podczas kompresji i dekompresji.

  3. User

    popraw kod o błąd: go:119:85: undefined: suffixByte go:120:21: undefined: suffixByte

  4. Assistant

    Przepraszam za błąd w wcześniejszej odpowiedzi. Aby naprawić błąd "undefined: suffixByte", musimy zainicjować zmienną "suffixByte" przed pętlą for w funkcji "Decompress". Oto poprawiony kod:

    func Decompress(inputFilePath, outputFilePath string) error {
    	// Odczytaj plik wejsciowy
    	inputData, err := ioutil.ReadFile(inputFilePath)
    	if err != nil {
    		return err
    	}
    
    	// Inicjalizuj slownik
    	dictionary := make(map[uint16]DictionaryEntry)
    
    	// Inicjalizuj bufor do przechowywania zdekodowanych danych
    	var result bytes.Buffer
    
    	// Inicjalizuj zmienną suffixByte
    	var suffixByte byte
    
    	// Iteruj po kazdych dwoch bajtach danych wejsciowych
    	for i := 0; i+1 < len(inputData); i += 2 {
    		prefixPosBytes := inputData[i : i+2]
    		
    		// Odczytaj wartosc pozycji prefiksu
    		err := binary.Read(bytes.NewReader(prefixPosBytes), binary.LittleEndian, &prefixPos)
    		if err != nil {
    			return err
    		}
    
    		// ...
    	}
    }
    

    Po tych zmianach błąd "undefined: suffixByte" powinien być naprawiony.

package main import ( "bytes" "encoding/binary" "fmt" "io/ioutil" "os" "time" ) type… · The Chat Archive