Haru Hoshizora's questions

Eu estava tentando resolver o exercício que diz

Exercício 2-7. Escreva a função rightrot(b, n) que rotaciona o inteiro b para a direita em n posições de bits.

e eu codifiquei, aqui está o código

#include <stdio.h>

int rightrot(int b, int n) {
    char i = 1;

    while (n > 0) {
        if ((b & i) == i) {
            b = b >> 1;
            b = b << 25;
            b = ~b;
            b = b >> 1;
            b = ~b;
            b = b >> 24;
        }
        else
            b = b >> 1;
        n--;
    }

    return b;
}

int main() {
    int i, j, k;

    printf("Enter number: ");
    scanf("%d", &i);
    printf("Enter rotation: ");
    scanf("%d", &j);
    
    k = rightrot(i, j);
    printf("%d\n", k);
    return 0;
}

entradas e saídas são

Enter number: 153
Enter rotation: 3
-13

153 em binário é 0000000000000000000000000010011001, então quando ele entra no loop while dentro do while ele entra no if pela primeira vez (quando n é 3), e como você vê dentro do if há 6 linhas de código com operadores bit a bit para manipular b e é isso que eu acho que essas 6 linhas devem mudar b

00000000000000000000000001001100
10011000000000000000000000000000
01100111111111111111111111111111
00110011111111111111111111111111
11001100000000000000000000000000
00000000000000000000000011001100

e então n é 2 e então outros 2 loops while devem passar, senão não vou explicar, pois o código de 6 linhas do if em si não funciona como eu quero, eu sei disso porque testei-os separadamente.

Além disso, tudo isso é porque estou rotacionando o binário, pois ele é de 8 bits e não de 32 bits.

O resultado final deve ser 51, e estou usando o Arch Linux, que é de 64 bits, totalmente atualizado, o terminal é st by suckless, o editor de texto é vim, compilei o código usando "gcc main.c -o main".

Eu estava tentando resolver uma questão de codificação que diz:

Escreva uma versão alternativa squeeze(s1, s2)que exclua cada caractere em s1que corresponda a qualquer caractere na string s2.".

Bem, eu codifiquei e a versão funcional é.

#include <stdio.h>

char s1a[1001], s2a[1001];

void squeeze() {
    int i, j, k;
    extern char s1a[], s2a[];

    for (i = 0; s2a[i] != '\0'; i++) {
        for (k = j = 0; s1a[j] != '\0'; j++) {
            if (s1a[j] != s2a[i]) s1a[k++] = s1a[j];
        }
        s1a[k] = '\0';
    }
    printf("%d/n", k); /*k's value*/
}

int main() {
    int c, s1 = 0, i = 0, j = 0;
    extern char s1a[], s2a[];

    while ((c = getchar()) != EOF && i < 1000) {
        if (c != '\n' && s1 == 0) {
            s1a[i++] = c;
        }
        else if (c == '\n' && s1 == 0) {
            s1a[i] = '\0';
            i = 0;
            s1++;
        }
        else if (c != '\n' && s1 == 1) {
            s2a[j++] = c;
        }
        else if (c == '\n' && s1 == 1) {
            s2a[j] = '\0';
            j = 0;
            squeeze();
            printf("%s\n", s1a);
            s1a[0] = '\0';
            s2a[0] = '\0';
            s1 = 0;
        }
    }
}

Eu digitei "hello\nhell\n".

Funciona bem, mas a 13ª linha neste código estava fora dos dois loops for antes, onde print k (na 15ª linha) está, então ele estava imprimindo k como 5 e quando adicionei o terminador de string onde está agora, ele imprime k como 1. Ele funciona bem e imprime "o", mas antes ele estava imprimindo "ooooo".

Edição: O problema, pelo meu entendimento, era que s1a tinha 5 o's no final, então k era 5 quando não terminava depois de ser reduzido.