UmPrograma

Boa tarde, tudo bem?

Gostaria de saber se a biblioteca conio.h é da linguagem C ou C++, e tambem da biblioteca sys/types.h.

Alguem sabe me informar. (estava estudando uns algoritmos na internet e me deparei com essas bibliotecas, elas sao exclusivas da linguagem C.

Nao vou menti que meu cerebro bug um pouco quando tenho que fazer essas mudancas de letra para numero. Nao entendo estão bem. 

Mas valeu...

17 horas atrás, isrnick disse:

char c = 'A'; //É o mesmo que: char c = 65;

nessa parte quer dizer que o alfabeto com as letras maiuscalas comeca com o numero 65, ne?! legal

nao conheco ascii. 

mas vou ver

@Flávio Pedroza

Gente, não sabia.

E o que eu faço? Uso a posicao da letra na string como valor para minha equação?

Assim me retorna a posição, mas tenho a leve sensação que quem escolheu a posição fui eu. Fora que teve colisões

#include <stdio.h>
#include <string.h>

int tamanhoTabela = 16;

void convert (char *dado){
    int i, vet[strlen(dado)], a=0;
    for(i=0;i<strlen(dado);i++){
        a++;
        vet[a]= 11*i/tamanhoTabela;
        printf("A letra %c ocupa na tabela a posicao %d.\n", dado[i], vet[a]);
    }
}
int main() {
    int i=0;
    char *dado = "UNIVERSIDADE";

    printf("\nA palavra a ser guardada na tababela hash sera UNIVERSIDADE.\n");

    convert(dado);
}

Oi, como vão?

Alguem poderia olhar a seguinte funcao e me dizer porque nao esta retornando, ficaria grato.

Algo me intui que estou usando a funcao 'atoi' errado, mas nao sei se é somente isso. Esse exercicio se trata de uma funcao hash, onde cada letra da palavra UNIVERSIDADE tem que ser transformada em um indice da tabela hash.

Segue a funcao.

#include <stdio.h>
#include <string.h>

int tamanhoTabela = 16;

void convert (char *dado){
    int i, vet[strlen(dado)];
    for(i=0;i<strlen(dado);i++){
        vet[i]= 11*atoi(dado[i])/tamanhoTabela;
        printf("A letra %s ocupa na tabela a posicao %d.\n", dado[i], vet[i]);
    }
}
int main() {
    int i=0;
    char *dado = "UNIVERSIDADE";

    printf("\nA palavra a ser guardada na tababela hash sera UNIVERSIDADE.\n");


    convert(dado);
}

uiii

kali esta ligado a pentest. ja que quero para o mesmo fim.

@loumier que isso?

nao entendi

que variaveis seriam essas?

pensei que sei atualizar com aquelas linhas de comando ja meio que conhecidas no linux, terminal do linux. Mas nao funciona

(NAO SEI O QUE FAZER) 

Aproveitando o embalo, o que acham do Kali Linux? (meu objetivo é realmente entender sobre pentest, segurança na internet, forense...)

Oi pessoal.

 estava querendo iniciar meus estudos em pentest e tal. Ai nao queria mudar para alguma distribuição linux, entao baixei o pentestbox no Windows mas não funciona. Nenhuma funcao é encontrada. e pede para atualizar e quando tento dar erro.

Alguem ja passou por isso aqui? podem me ajudar?

@r_Tray nao sei exatamente como seria otimizado. Mas agradeço. Valeu...a todos.

estou tendo que transformar uma funcao c++ para c, ai to me perdendo em tudo. Pois nao conheco c++ :-(

alias, a funcao puclic em c++ é o que?

Oi

Incluindo a biblioteca windows, isso permite que se use a funcao Sleep, que faz com que acha uma pausa/demora no tempo.

porém achava que ele funciona com segundos, mas os valores que coloco la dentro nao surtem tantos efeitos. So se for valores maiores. 

Ela funciona com segundos, milisegundos? com o que? alguem sabe?

todos os nos folhas (aqueles que nao tem filho) devem esta no mesmo nivel (na mesma altura)

Está otimo, perfeito diria. So que é uma arvore balanceada, acho que essa seja nao seja balanceada...

Nesse algortimo que fiz, nao sei se chegou a roda-lo, mas nele nao consigo passar para a funcao insere. Ai eu passei os valores no proprio main, e depois imprimir. (so que nem o meu é uma arvore 2-3) Não sei...

Mas eu posso mudar de tal forma que tenha a aparencia de uma arvore 2-3.

difícil ne?!

#include <stdio.h>
#include <stdlib.h>

typedef struct no{
    int key1;
    int key2;
    int nkey;
    struct no *left;
    struct no *middle;
    struct no *right;
}No;

No *CriaNovo(){
    No *aux;
    aux = malloc(sizeof(No));
    return aux;
}

No *criaNo(int ch1, int ch2, int nchaves, No *pl, No *pc, No *pr){
   No *n;
   n->key1=ch1;
   n->key2=ch2;
   n->nkey=nchaves;
   n->left=pl;
   n->middle=pc;
   n->right=pr;
   return n;
}

int isLeaf(No *no){
    if(no==NULL){
        return 1;
    }
}

void adicionaChave(No *no,int val, No* pon){
    no->key1 =val;
    no->key2=pon->key1;
}

No *quebraNo(No *no, int val, int *rval, No *subarvore){
    No *paux;

    if (val > no->key2) {  // val esta mais a direita
       *rval = no->key2;   // promove a antiga maior
       paux = no->right;
       no->right = NULL;   // elimina o terceiro filho
       no->nkey = 1;      // atualiza o número de chaves
       return criaNo(val, 0, 1, paux, subarvore, NULL);
    } else if (val >= no->key1){ // val esta no meio
       *rval = val;        // continua sendo promovido
       paux = no->right;
       no->right = NULL;
       no->nkey = 1;
       return criaNo(no->key2, 0, 1, subarvore, paux, NULL);
    } else {              // val esta a mais a esquerda
       *rval = no->key1;
       // primeiro cria o nó a direita
       paux = criaNo(no->key2, 0, 1, no->middle, no->right, NULL);
       no->key1 = val;   // em seguida arruma o nó a esquerda
       no->nkey = 1;
       no->right = NULL;
       no->middle = subarvore;
       return paux;
    }
}

No *busca(No *raiz, int chave){
    if(raiz==NULL){
        printf("Árvore vazia!\n");
        return NULL;
    }
    if(chave == raiz->key1){
        return raiz;
    }
    if((raiz->nkey == 2) && chave == raiz->key2){
        return raiz;
    }
    if(chave < raiz->key1){
        return busca(raiz->left, chave);
    }
    else if((raiz->nkey == 2)&& chave < raiz->key2){
        return busca(raiz->middle, chave);
    }
    else if((raiz->nkey == 2)&& chave > raiz->key2){
        return busca(raiz->right, chave);
    }
}

No *insere( No **no, int val, int *rval){
    No *paux, *paux2;
    int   vaux, promov;

    if (*no == NULL) {    // arvore vazia
       *no = (No *) malloc (sizeof(No));
       *no = criaNo(val, 0, 0, NULL, NULL, NULL);
             // cria no folha com um valor
       return NULL;       // nada a fazer depois
    }
    if (isLeaf(*no)){     // chegou a folha
       if ((*no)->nkey == 1){ // caso fácil
          adicionaChave(*no, val, NULL);
          return NULL;
       } else {
          paux = quebraNo(*no, val, &vaux, NULL);
          *rval = vaux;
          return paux;
       }
    } else {             // continua a procura
       if (val < (*no)->key1)
          paux = insere( &((*no)->left), val, &vaux);
       else if (((*no)->nkey == 1) || (val < (*no)->key2))
          paux = insere( &((*no)->middle), val, &vaux);
       else
          paux = insere( &((*no)->right), val, &vaux);
       if (paux == NULL) // nao promoveu
          return NULL;
       else
          if ((*no)->nkey == 1){
             adicionaChave(*no, vaux, paux);
             return NULL;
          } else {
             paux2 = quebraNo(*no, vaux, &promov, paux);
             *rval = promov;
             return paux2;
          }
    }
}

void imprimir(No *no){
    No* ajuda=no;
    if(no==NULL){
        printf("Arvore vazia!\n");
    }
    else if(no!=NULL){
        if(no->nkey==1){
            printf("%d, ", no->key1);
                if(no->left!=NULL){
                    printf("%d, ", no->left);
                    return imprimir(no->left);
                }
                else if(no->right!=NULL){
                    printf("%d, ", no->right);
                    return imprimir(no->right);
                }
        }

        if(no->nkey==2){
            printf("%d, ", no->key1);
            printf("%d, ", no->key2);
            if(no->left!=NULL){
                    do{
                        printf("%d, ", no->left);
                    }while (no->left==NULL);
            }
            if(no->middle!=NULL){
                    do{
                        printf("%d, ", no->middle);
                    }while (no->middle==NULL);
            }
            if(no->right!=NULL){
                    do{
                        printf("%d, ", no->right);
                    }while (no->right==NULL);
            }

        }
    }
}

int main(){
    int key1, key2;
    No* aux, *a, *b, *c;
    aux = (No*)malloc(sizeof(No));
    a=5;b=17;c=22;
    key1=10;key2=20;

    aux->key1 = key1;aux->key2 = key2;aux->nkey=2;
    aux->left = a;aux->middle = b;aux->right = c;

    imprimir(aux);

    return 0;
}

Como assim?

o que a de errado? A funcao busca é recursiva

kkk agora que fui entender que tu disse que nao esta errada. entao ta certa kkkkk ooo vida

Tambem acho que é na funcao. Mas nao sei o que posso fazer

@Flávio Pedroza 

É find

Mas ai é so um exemplo

12 minutos atrás, Flávio Pedroza disse:

0 é falso e qualquer coisa diferente de zero é verdadeiro.

Citação

Estava tentando usar isso para printar na tela se encontrou ou nao. Mas nao funcionou

Ela so funciona para um caso. Se eu mudar o valor que entra, por exemplo tirando o "valor" e colocando outra coisa que nao esteja na estrutura o algoritmo na funcao principal nao printa na tela que "Não achou"

Desse jeito:

No* res;
res = busca(aux, valor); 
    if(res==0 || res ==NULL){
        printf("Nao achou");
    }
    else printf("Achou");

hm

Como faço para printar na tela se encontrei ou nao...

Pessoal, como eu sei o que a funcao esta retornando, se é verdadeiro ou falso.

Em C nao tem booleano, e sim 0 e 1.

Ai na seguinte funcao é para me retornar se encontrou ou não o valor. porém não esta funcionando.

segue a funcao

no23 *find(no23 *raiz, int key) {
    if (raiz==NULL)
        return NULL;      // não encontrou
    if (key == raiz->lkey)
        return raiz;      // é a chave esquerda
    if ((raiz->nkeys == 2) && (key == raiz->rkey))
        return raiz;      // é a chave direita
    if (key < raiz->lkey)
        return find(raiz->left, key);
    else if (raiz->nkeys == 1)
        return find(raiz->center, key);
    else if (key < raiz->rkey)
        return find(raiz->center, key);
    else
        return find(raiz->right, key);
}

Ai eu tento fazer o seguinte

if(busca(aux, valor)!=NULL)

printf("Encontrado");

Mas não funciona.

0 é verdadeiro

e 1 é falso?

28 minutos atrás, Flávio Pedroza disse:

Infelizmente não.

estou a uma vida tentando achar livros e assuntos sobre arvores, em especial a 2-3, e nao acho nada....

@Flávio Pedroza  do tipo int

Mas eu tentei so como o "*" antes mas nao deu certo

A nao, acabei de notar aqui que ele não é ponteiro, mas sim uma estrutura tambem

Ai se eu fizer *no = paux, funciona. SO que eu nao sei o que estou atribuindo, se é tudo. Acredito que sim. É isso?

@Flávio Pedroza  voce sabe sobre arvores 2-3?

Olá, mundo.

Estava aqui pensando num problema que tenho a resolver, pois bem se trata de cast

Estava aparecendo que eu nao podia realizar a operacao de atribuicao pois de um lado tinha inteiro e do outro um ponteiro.

Logo, eu astuto pensei. Vou fazer um cast aqui, e fiz.

ficou assim

(*no)->key = (int) paux;

sendo o no uma estrutura, o key o inteiro dessa estrutura e o paux um ponteiro.

Esta errado isso? Pode dar problema?

Ja mudei de novo

To numa duvida cruel se a funcao adiciona é assim mesmo.

Pois sao tres parametros que eu passo, mas so utilizo dois.

No *CriaNovo(){
    No *aux;
    aux = malloc(sizeof(No));
    return aux;
}

Acho que o cria no deve ser assim

Boa tarde, pessoal. Como estão? (espero que bem) 

Estava eu a resolver um exercício de programação e me deparei com uma dificuldade enorme para criar uma função remove. 

Muito se dar pois nao sei o que devo remover primeiro, esquerda, direita, meio. Ou ate mesmo se removo os no.

Fora que ela tem que remover o numero desejado pelo usuario.

E ainda estou com uma dificuldade na função principal. 

#include <stdio.h>
#include <stdlib.h>



typedef struct _no23 {
   int  lkey,             // chave esquerda
        rkey,             // chave direita
        nkeys;            // n�mero de chaves
   struct _no23 *left,    // ponteiro ao filho esquerdo
                *center,  // ponteiro ao filho central
                *right;   // ponteiro ao filho direito
} no23;

no23 *criaNo(int ch1, int ch2, int nchaves, no23 *pl, no23 *pc, no23 *pr){
   no23 *n;
    typedef struct n{
        int ch1,
            ch2,
            nchaves;
        struct n  *p1,
                    *pc,
                    *pr;
    } no2;
    return n;
}

void adicionaChave(no23 *no, int ch, no23 *p){   /// EU QUE FIZ
    no->lkey = ch;
}
no23 **isLeaf(no23 *no){  /// EU QUE FIZ
    no->nkeys = 0;
    return 0;
}

no23 *quebraNo(no23 *no, int val, int *rval, no23 *subarvore){
    no23 *paux;

    if (val > no->rkey) {  // val esta mais a direita
       *rval = no->rkey;   // promove a antiga maior
       paux = no->right;
       no->right = NULL;   // elimina o terceiro filho
       no->nkeys = 1;      // atualiza o número de chaves
       return criaNo(val, 0, 1, paux, subarvore, NULL);
    } else if (val >= no->lkey){ // val esta no meio
       *rval = val;        // continua sendo promovido
       paux = no->right;
       no->right = NULL;
       no->nkeys = 1;
       return criaNo(no->rkey, 0, 1, subarvore, paux, NULL);
    } else {              // val esta a mais a esquerda
       *rval = no->lkey;
       // primeiro cria o nó a direita
       paux = criaNo(no->rkey, 0, 1, no->center, no->right, NULL);
       no->lkey = val;   // em seguida arruma o nó a esquerda
       no->nkeys = 1;
       no->right = NULL;
       no->center = subarvore;
       return paux;
    }
}

no23 *find(no23 *raiz, int key) {
    if (raiz==NULL)
        return NULL;      // n�o encontrou
    if (key == raiz->lkey)
        return raiz;      // � a chave esquerda
    if ((raiz->nkeys == 2) && (key == raiz->rkey))
        return raiz;      // � a chave direita
    if (key < raiz->lkey)
        return find(raiz->left, key);
    else if (raiz->nkeys == 1)
        return find(raiz->center, key);
    else if (key < raiz->rkey)
        return find(raiz->center, key);
    else
        return find(raiz->right, key);
}
/*
// cria um nó com ch1, ch2 e nchaves, assim como os três ponteiros
no23 *criaNo(int ch1, int ch2, int nchaves, no23 *pl, no23 *pc, no23 *pr);
// verifica se o nó em questão é folha, volta 1 se sim, e 0 caso contrario
int isLeaf(no23 *no);
// coloca uma nova chave ch e arvore p, em um nó com apenas uma chave
void adicionaChave(no23 *no, int ch, no23 *p);
// Quebra um nó em dois, sendo val e subarvore, os novos dados
no23 *quebraNo(no23 *no, int val, int *rval, no23 *subarvore);

*/
// insere val em no (se necessario retorna o novo no e um valor
// rval)
no23 *insere( no23 **no, int val, int *rval){
    no23 *paux, *paux2;
    int   vaux, promov;

    if (*no == NULL) {    // arvore vazia
       *no = (no23 *) malloc (sizeof(no23));
       *no = criaNo(val, 0, 0, NULL, NULL, NULL);
             // cria no folha com um valor
       return NULL;       // nada a fazer depois
    }
    if (isLeaf(*no)){     // chegou a folha
       if ((*no)->nkeys == 1){ // caso fácil
          adicionaChave(*no, val, NULL);
          return NULL;
       } else {
          paux = quebraNo(*no, val, &vaux, NULL);
          *rval = vaux;
          return paux;
       }
    } else {             // continua a procura
       if (val < (*no)->lkey)
          paux = insere( &((*no)->left), val, &vaux);
       else if (((*no)->nkeys == 1) || (val < (*no)->rkey))
          paux = insere( &((*no)->center), val, &vaux);
       else
          paux = insere( &((*no)->right), val, &vaux);
       if (paux == NULL) // nao promoveu
          return NULL;
       else
          if ((*no)->nkeys == 1){
             adicionaChave(*no, vaux, paux);
             return NULL;
          } else {
             paux2 = quebraNo(*no, vaux, &promov, paux);
             *rval = promov;
             return paux2;
          }
     }
}



int main(){
    no23 ** aux;

}