Decodificar el mensaje de los paquetes de datos enviados a través de la red

A través de la red, los mensajes se envían como paquetes de datos. Cada paquete de datos es una serie de bytes (8 bits = 1 byte). La tarea es decodificar el paquete de datos ( str ) de longitud N. El formato del paquete de datos es el siguiente:

• El paquete se puede dividir en 2 partes.
• El primer byte representa un valor único, digamos K .
• Los bytes restantes en el paquete de datos representan el mensaje a decodificar.
• Cada byte del mensaje se debe aplicar XOR al primer byte, lo que da como resultado un conjunto de caracteres ASCII alfanuméricos para obtener el mensaje legible.

Si la longitud del paquete de datos no es válida, devuelva -1.

Ejemplos:

Entrada: str = “101010101110001011001111110001101100011011000101”, N = 48
Salida: Hola
Explicación: Aquí K = 10101010, y los otros bytes son:
“11100010”, “11001111”, “11000110”, “110001001”, “110001001”.
Los valores Xor con K son “01001000”, “01100101”, “01101100”, “01101100”, “01101111”
que tienen valores ASCII 72, 101, 108, 108, 111 y los caracteres son ‘H’, ‘e’, ‘l’, ‘l’ y ‘o’.

Entrada: str = “1010101011100010111000101111”, N = 28
Salida: -1
Explicación: La longitud del paquete no es válida. A un byte del mensaje le faltan algunos bits.

Enfoque: la solución al problema se basa en la implementación. Compruebe la validez de la longitud del paquete. Si es válido, entonces haz lo que se dice en la pregunta. Siga los pasos que se mencionan a continuación:

• Compruebe si la longitud de entrada es divisible por 8 , si no, devuelva -1.
• Ahora, para el primer byte, es decir, los primeros 8 bits, calcule el valor decimal y guárdelo en una variable.
• Ahora, para cada byte entrante, XOR con el primer byte almacenado e imprima el carácter correspondiente que tiene el valor ASCII.

A continuación se muestra la implementación del enfoque anterior.

// Java program to implement the approach
import java.util.*;
 
public class Main {
 
    // Function to decode the message
    static String decode(String str, int N)
    {
        // If length of packet is invalid
        if (N % 8 != 0)
            return "-1";
 
        String res = "";
        int j = 0, k = 0, first = 0, K = 0;
 
        for (int i = 0; i < N; i++) {
            k++;
 
            // If one byte length is reached
            if (k == 8) {
                k = 0;
                String s
                    = str.substring(j, i + 1);
                int n
                    = Integer.parseInt(s, 2);
                j = i + 1;
 
                // If not the first byte add
                // character to decoded message
                if (first == 1) {
                    int z = n ^ K;
                    char ch = (char)z;
                    res += ch;
                }
 
                // If it is the first byte
                else if (first == 0) {
                    first = 1;
                    K = n;
                }
            }
        }
        return res;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        String str = "101010101110001011001111110001101100011011000101";
        int N = 48;
        String ans = decode(str, N);
        System.out.println(ans);
    }
}

# Python code for the above approach
 
# Function to decode the message
def decode(strr: str, N: int) -> str:
     
    # If length of packet is invalid
    if N % 8 != 0:
        return "-1"
 
    res = ""
     
    j, k, first, K = 0, 0, 0, 0
     
    for i in range(N):
        k += 1
           
        # If one byte length is reached
        if k == 8:
            k = 0
            s = strr[j : i + 1]
            n = int(s, 2)
            j = i + 1
             
            # If not the first byte add
            # character to decoded message
            if first == 1:
                z = n ^ K
                ch = chr(z)
                res += ch
                 
            # If it is the first byte
            elif first == 0:
                first = 1
                K = n
    return res
   
# Driver code
if __name__ == "__main__":
     
    strr = "101010101110001011001111110001101100011011000101"
    N = 48
    ans = decode(strr, N)
    print(ans)
 
# This code is contributed by N SaiSuprabhanu

// C# program to implement the approach
using System;
using System.Data;
 
public class GFG {
 
    // Function to decode the message
    static String decode(String str, int N)
    {
        // If length of packet is invalid
        if (N % 8 != 0)
            return "-1";
 
        String res = "";
        int j = 0, k = 0, first = 0, K = 0;
 
        for (int i = 0; i < N; i++) {
            k++;
 
            // If one byte length is reached
            if (k == 8) {
                k = 0;
                String s
                    = str.Substring(j, i + 1-j);
                int n
                    = Convert.ToInt32(s,2);
                j = i + 1;
 
                // If not the first byte add
                // character to decoded message
                if (first == 1) {
                    int z = n ^ K;
                    char ch = (char)z;
                    res += ch;
                }
 
                // If it is the first byte
                else if (first == 0) {
                    first = 1;
                    K = n;
                }
            }
        }
        return res;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        String str = "101010101110001011001111110001101100011011000101";
        int N = 48;
        String ans = decode(str, N);
        Console.WriteLine(ans);
    }
}
 
// This code contributed by shikhasingrajput

<script>
        // JavaScript code for the above approach
 
        // Function to decode the message
        function decode(str, N)
        {
         
            // If length of packet is invalid
            if (N % 8 != 0)
                return "-1";
 
            let res = "";
            let j = 0, k = 0, first = 0, K = 0;
 
            for (let i = 0; i < N; i++) {
                k++;
 
                // If one byte length is reached
                if (k == 8) {
                    k = 0;
                    let s = str.slice(j, i + 1);
                    let n = parseInt(s, 2);
                    j = i + 1;
 
                    // If not the first byte add
                    // character to decoded message
                    if (first == 1) {
                        let z = n ^ K;
                        let ch = String.fromCharCode(z);
                        res += ch;
                    }
 
                    // If it is the first byte
                    else if (first == 0) {
                        first = 1;
                        K = n;
                    }
                }
            }
            return res;
        }
 
        // Driver code
        let str = "101010101110001011001111110001101100011011000101";
        let N = 48;
        let ans = decode(str, N);
        document.write(ans);
 
       // This code is contributed by Potta Lokesh
    </script>

Hello

Complejidad temporal: O(N)
Espacio auxiliar: O(logN)