Operadores Bitwise

[Diogo Fonseca]

Ola pessoal, primeiro brigado a quem responder.

Estou com duvidas neste exercicio ja pensei e pensei e não consigo chegar a resposta.

O Exercicio é o seguinte:

Escreva a função findsaw que procura, no inteiro value, a mais longa sequência de bits consecutivos com valores alternados. A função retorna apenas o índice do primeiro bit dessa sequência, sendo 0 o índice do bit de menor peso. No caso de haver mais do que uma resposta possível, deve ser retornada a que corresponder ao menor índice. Por exemplo, a chamada findsaw(0xEAEA476B) deve retornar 23.

unsigned int findsaw(int value);

OBS: eu fiz algumas coisas so que não estou a conseguir encontrar a "máscara" necessária para resolver o problema

Abaixo Segue o que eu consegui fazer.

[code]

#include <stdio.h>

unsigned int findsaw(int value);

int main(){
    printf("%d\n", findsaw(0x6));
    return 0;
}

unsigned int findsaw(int value){
    int count;
    int bigger;
    
    for(count = 0; value != 0; value >>= 1){
        if((value & 01) || (value & 010))
            count++;
        else if((value & 00) || (value & 011)){
            if(count > bigger)
                bigger = count;
            count = 0;
        }
        bigger = count;
    }
            
    return bigger;
}

[/code]

Ups sou novo neste forum e não consegui por o codigo bem desculpem pensava que tinha de usar

 [\code]

mas não deu

Penso que dá para entender de qualquer forma 

Obrigado desde já :)

[isrnick]

Para postar códigos aperte o botão <> no topo do campo de respostas, este é o botão da tag CODE.

 

Acho que é melhor sempre armazenar o bit do ciclo anterior e comparar com o atual, e contar se forem diferentes. Aqui eu fiz uma solução:

unsigned int findsaw(int value) {
    int previous, index = 0, count = 0, maxcount = 0, bigger = 0;
    previous = value & 0x01;
    for (value >>= 1; value != 0; value >>= 1) {
        if( (value & 0x01) != previous)
            count++;
        else {
            if (count > maxcount) {
                maxcount = count;
                bigger = index - count;
            }
            count = 0;
        }
        previous = value & 0x01;
        index++;
    }
    if (count > maxcount) {
        maxcount = count;
        bigger = index - count;
    }
    return bigger;
}

 

[Diogo Fonseca]

O

3 horas atrás, isrnick disse:

Para postar códigos aperte o botão <> no topo do campo de respostas, este é o botão da tag CODE.

 

Acho que é melhor sempre armazenar o bit do ciclo anterior e comparar com o atual, e contar se forem diferentes. Aqui eu fiz uma solução:

unsigned int findsaw(int value) {
    int previous, index = 0, count = 0, maxcount = 0, bigger = 0;
    previous = value & 0x01;
    for (value >>= 1; value != 0; value >>= 1) {
        if( (value & 0x01) != previous)
            count++;
        else {
            if (count > maxcount) {
                maxcount = count;
                bigger = index - count;
            }
            count = 0;
        }
        previous = value & 0x01;
        index++;
    }
    if (count > maxcount) {
        maxcount = count;
        bigger = index - count;
    }
    return bigger;
}

 

Muito obrigado pela ajuda Valeu :)

[isrnick]

Se tiver qualquer dúvida sobre o código é só perguntar.

[Diogo Fonseca]

12 minutos atrás, isrnick disse:

Se tiver qualquer dúvida sobre o código é só perguntar.

Havia umas partes que estavam mal mas deu para entender a lógica ficando assim no final o que voce acha?

 

#include <stdio.h>

unsigned int findsaw(int value);

int main(){
    int number = 0xEAEA476B;
    printf("%d\n", findsaw(number));
    
    return 0;
}

unsigned int findsaw(int value1) {
    int last;
    int count, bigger;
    int idx, biggerIdx;
    unsigned value = value1;
    
    last      = value & 01;
    count     = 1;
    bigger    = 1;
    idx          = 0;
    biggerIdx = 0;
   
    
    for (value1 >>= 1; value != 0; value >>= 1){
        
        if (last != (value & 01))
            ++count;
        else {
            if(count > bigger){
                bigger       = count;
                biggerIdx = idx;
            }
            count = 1;
        }
        last = value & 01;
        ++idx;    
    }
    
    if(count > bigger){
        bigger       = count;
        biggerIdx = idx;
    }
        
    return biggerIdx-bigger;
}

Obrigado desde já :)

[isrnick]

Algum motivo pelo qual você prefere usar o número 1 na forma octal 01? Normalmente hexadecimal é preferido quando lidando com binários.

 

O primeiro parâmetro desse for não parece ter função alguma para a lógica do seu programa:

for ( \* value1 >>= 1 *\ ; value != 0; value >>= 1){

Então, poderia ser removido.

 

E atualmente, a primeira execução do for apenas repete o que já tinha sido declarado inicialmente fora do ciclo ("count = 1;" e "last = value & 01;") e incrementa o índice ("++idx"), já que "value" ainda não foi deslocado e atualizado.