Escreva um programa que, dado um número n, traduza n números de telefones de 8 dígitos em números de telefones na forma numérica. Suponha que a entrada é sempre dada em caracteres maiúsculos.

Escreva um programa que, dado um número n, traduza n números de telefones de 8 dígitos
em números de telefones na forma numérica. Suponha que a entrada é sempre dada em caracteres maiúsculos.

Utilize a codificação padrão das teclas de um telefone:
2 = ABC 3 = DEF 4 = GHI  5 = JKL   6 = MNO  7 = PQRS 8 = TUV  9 = WXYZ

Entrada: A primeira linha contém um inteiro n que indica a quantidade de telefones a serem lidos,
seguida dos números de telefone.

Write a program that , given a number n , n translate 8-digit phone numbers in telephone numbers in numerical form . Suppose the input is always given in uppercase characters.

Use the default encoding of a phone keys:

= 2 ABC 3 DEF 4 = = = GHI 5 JKL 6 MNO 7 = = = PQRS 8 TUV 9 WXYZ =

Input : The first line contains an integer n indicating the number of phones to be read ,
Then the phone numbers

Solution For C Program :

/*Escreva um programa que, dado um número n, traduza n números de telefones de 8 dígitos
em números de telefones na forma numérica. Suponha que a entrada é sempre dada em caracteres maiúsculos.
Utilize a codificação padrão das teclas de um telefone:
2 = ABC 3 = DEF 4 = GHI  5 = JKL   6 = MNO  7 = PQRS 8 = TUV  9 = WXYZ
Entrada: A primeira linha contém um inteiro n que indica a quantidade de telefones a serem lidos,
seguida dos números de telefone*/

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


int main(){
    int n, traduzido[9];
    char telefone[100][100];
    int i;
    printf("Esse programa traduz números de palavras com 8 letras em números de telefone na forma numérica ");
    printf("\nDigite o numero de palavras que voce deseja digitar: ");
    scanf("%d", &n);
    int j;
 
    for(i=0;i<n;i++){
        printf("\nDigite sua %da palavra de 8 digitos: ", i+1);
        fflush(stdin);
        scanf("%s", telefone[i]);
    }
 
    for (i=0;i<n;i++){
        for (j=0; j<8; j++){
            if ((telefone[i][j] == 'a') || (telefone[i][j] == 'b') || (telefone[i][j] == 'c'))
                traduzido[j]=2;
            else if ((telefone [i][j] == 'd') || (telefone[i][j] == 'e') || (telefone[i][j] == 'f'))
                traduzido[j]=3;
            else if ((telefone [i][j] == 'g') || (telefone[i][j] == 'h') || (telefone[i][j] == 'i'))
                traduzido[j]=4;
            else if ((telefone [i][j] == 'j') || (telefone[i][j] == 'k') || (telefone[i][j] == 'l'))
                traduzido[j]=5;
            else if ((telefone [i][j] == 'm') || (telefone[i][j] == 'n') || (telefone[i][j] == 'o'))
                traduzido[j]=6;
            else if ((telefone [i][j] == 'p') || (telefone[i][j] == 'q') || (telefone[i][j] == 'r') || (telefone[i][j] == 's'))
                traduzido[j]=7;
            else if ((telefone [i][j] == 't') || (telefone[i][j] ==  'u') || (telefone[i][j] == 'v'))
                traduzido[j]=8;
            else if ((telefone [i][j] == 'x') || (telefone[i][j] == 'w') || (telefone[i][j] == 'y') || (telefone[i][j] == 'z'))
                traduzido[j]=9;
        }
    }

    for (i = 0;i < 8;i++){
        printf("%d\n", traduzido[i]);
    }
    return 0;
}

função thread que verifica os nós que estão inativas para o segundo temporizador

Como escrever uma função thread Programa de C que verifica os nós que estão inativas para o segundo temporizador ?

Solution For C Program :

// funçao de thread que verifica quais Nos estao inativos por timer_interv segundos
void *erase_nodes( void *ptr )
{
struct timespec t1;
struct timespec t2;
    struct timespec deltaT; // diferenca entre o timestamp atual e anterior
    std::list<nodes>::iterator it; // variavel para percorrer a lista
   
    while(1)
{
//usleep(10); // delay de mais ou menos 1 segundo, depende do processador

clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &t2);  // pega timestamp atual

//std::cout << "erase_nodes:" << timer_++ << endl;    
for (it = nodes_RTS.begin(); it != nodes_RTS.end(); it++) { // percorre a lista
   //pthread_mutex_lock(&lock2); // protege a variavel t1.tv_sec contra outras threads
   t1.tv_nsec = (*it).t1;          
   //pthread_mutex_unlock(&lock2); // libera a variavel

deltaT.tv_nsec = diff(t1, t2).tv_nsec; // armazena o delta dos timestamps

   if(deltaT.tv_nsec > timer_interv) // nenhum pacote foi enviado nos ultimos timer_interv segundos
   {
   std::cout << "No rm:" << (*it).num_node << endl;
   //std::cout << "deltaT:" << deltaT.tv_nsec << endl;
   it = nodes_RTS.erase(it); // remove Noh
   }
}
    }
}

// verifica se Noh ja existe e adiciona a lista nodes_RTS
void Mac802_11t::add_list_RTS(int node)
{
bool add = true;
struct timespec t1;
std::list<nodes>::iterator it; // variavel para percorrer a lista: it
list_rts = (struct nodes*)malloc(sizeof(struct nodes)); // variavel para guardar informaçoes sobre o Noh na lista

//percorre a lista
for (it = nodes_RTS.begin(); it != nodes_RTS.end(); it++)
{
if((*it).num_node == node) { // verifica se Noh ja existe na lista
add = false;
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &t1);
(*it).t1 = t1.tv_nsec; // guarda timestamp do Noh
break; // sai porque ja achou o noh procurado
}
}

if( add ) // o Noh ainda nao existe na lista ou foi removido
{
add = false;

clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &t1);
list_rts->t1 = t1.tv_nsec; // guarda timestamp do Noh
list_rts->num_node = node; // guarda o numero do Noh
nodes_RTS.push_back(*list_rts); // adiciona o Noh a lista

std::cout << "No " << list_rts->num_node <<
" adicionado" //<< endl;
<< " N:" << nodes_RTS.size() //<< endl;
<< " Fator atual: " << calc_factor() << endl;
}
free(list_rts); // libera variavel
}

Cria uma copia da imagem original rotacionada 90 graus sentido horario

Como escrever um programa em C para Cria uma cópia da imagem original girada em 90 graus no sentido horário em C linguagem de programação?

Este programa C para Cria uma cópia da imagem original girada em 90 graus no sentido horário.

1. /* Cria uma copia da imagem original rotacionada 90 graus sentido horario */
2. Imagem* rotacionar90(Imagem* original) {
3.     int i;
4.     int j;
5.     int w = original->w;
6.     int h = original->h;
7.  
8.     Imagem* nova = criar_imagem(h, w);
9.  
10.     for (i = 0; i < h; ++i) {
11.         for (j = 0; j < w; ++j) {
12.             nova->pixels[j][(h - 1) - i] = original->pixels[i][j];
13.         }
14.     }
15.  
16.     return nova;
17. }

C Programa para string revertida

Como escrever um programa em C para string revertida em C linguagem de programação?

Este Programa C é revertida um String.

Solution:

1. #include <stdio.h>
2.  
3. void tamanho_total(char string_main[25], int tamanho =0){
4.  
5.     int i;
6.  
7.     for(i=0; string_main[i] != '\0'; i++){ /*Tamanho da string inteira*/
8.             tamanho++;
9.     }
10. }
11.  
12. void tamanho_espaco(char string_main[25], int tamanho_palavra =0){
13.  
14.     int i;
15.  
16.     for(i=0; string_main[i] != 32 && string_main[i] != '\0'; i++){ /* descobrir o tamanho da string antes do espaço*/
17.         tamanho_palavra++;
18.     }
19. }
20.  
21. void inverte(char string_main[25], char aux[25], int tamanho, int tamanho_parte){
22.  
23.     int i, j, m=0;
24.     char c;
25.  
26.     while(m<=tamanho){
27.         for(i=0; i<= tamanho_parte && string_main[i] != 32 && string_main[i] != '\0'; i++){ /*inverter a string, por palavra*/
28.             c = string_main[i];
29.             aux[i] = string_main[tamanho_parte-1-i];
30.             aux[tamanho_parte-1-i] = c;
31.         }
32.         m++;
33.     }
34.     aux[i] = '\0';
35.  
36. }
37.  
38. int main(){
39.      int i, tamanho_string, tamanho_parte;
40.      char string[25], aux[25];
41.  
42.     printf("Digite a string: ");
43.     scanf("%[^\n]s", string);
44.     getchar();
45.  
46.     tamanho_total(string, tamanho_string);
47.     tamanho_espaco(string, tamanho_parte);
48.     inverte(string, aux, tamanho_string, tamanho_parte);
49.  
50.     printf("\nString invertida: %s\n", aux);
51.  
52.     return 0;
53. }

Este Programa C é revertida um String.

CONEXÃO COM C Programa DNN SERVIDOR

CONEXÃO COM C Programa DNN SERVIDOR

1. int id_gestor_config;
2.         int id_gestor_estat;
3.         int porto;
4. /*--------------- PEDIDOS
5. ----------------1. CONEXÃO COM O DNNSERVER.C */
6.  
7.         // Verificao do argumento
8.         if(argc <= 1) {
9.                 erro("Erro no argumento!\n");
10.         }
11.        
12.         // porto onde sao recebidos os pedidos
13.         porto = atoi(argv[1]);
14.  
15.         if(porto <= 0) {
16.                 erro("Porto invalido!\n");
17.         }
18.  
19.         struct sockaddr_in este, dnsserver;
20.  
21.         int fd_socket, len_socket = sizeof(dnsserver), len_recv;
22.         char buf[BUFLEN];
23.  
24.         if((fd_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1){
25.                 erro("criacao do socket\n");
26.         }
27.  
28.         este.sin_family = AF_INET;
29.         este.sin_port = htons(porto);
30.         este.sin_addr.s_addr = htonl(INADDR_ANY);
31.  
32.         int trueValue = 1;
33.         setsockopt(fd_socket, SOL_SOCKET, SO_REUSEADDR, &trueValue, sizeof(trueValue));
34.  
35.         if(bind(fd_socket,(struct sockaddr*)&este, sizeof(este)) == -1){
36.                 erro("bind\n");
37.         }
38.         while(1){
39.                 printf("A espera....\n");
40.                 if((len_recv = recvfrom(fd_socket, buf, BUFLEN, 0, (struct sockaddr*)&dnsserver, &len_socket)) == -1){
41.                         erro("recvfrom\n");
42.                 }
43.  
44.                 printf("--------> %s --- %d\n", inet_ntoa(dnsserver.sin_addr), ntohs(dnsserver.sin_port));
45.                 printf("conteudo: %s\n",buf);
46.  
47.         }
48.  
49.         close(fd_socket);

Desenvolva um algoritmo para ler uma expressão informada pelo usuário e gerar a sequência de bits que a representa através da técnica de compressão de dados de Huffman.

Desenvolva um algoritmo para ler uma expressão informada pelo usuário e gerar a sequência de bits que a representa através da técnica de compressão de dados de Huffman. Para tal, considere o seguinte:
        1. criar uma lista encadeada que armazena o caractere e sua frequência na expressão.
        2. Ordene a lista de forma crescente ou decrescente a partir da frequência do caractere.
        3. Crie os nós da árvore de Huffman a partir dos dados da lista.
        4. Gere a sequência de bits que representa a expressão e certifique-se que é correta utilizando o processo de descompactação.

1. /*
2.         Desenvolva um algoritmo para ler uma expressão informada pelo usuário e gerar a sequência de bits que a representa através da técnica de compressão de dados de Huffman. Para tal, considere o seguinte:
3.         1. criar uma lista encadeada que armazena o caractere e sua frequência na expressão.
4.         2. Ordene a lista de forma crescente ou decrescente a partir da frequência do caractere.
5.         3. Crie os nós da árvore de Huffman a partir dos dados da lista.
6.         4. Gere a sequência de bits que representa a expressão e certifique-se que é correta utilizando o processo de descompactação.
7. */
8.  
9. #include <stdio.h>
10. #include <stdlib.h>
11. #include <math.h>
12. #include <string.h>
13.  
14. //----------------------------------------------------------------------------
15. typedef struct arvore_huffman {
16.         struct arvore_huffman *esquerda, *direita;
17.         int frequencia;
18.         char c;
19. } *raiz;
20.  
21. struct arvore_huffman frase_completa[256] = { {0} }; // char 2ˆ8 -> valores sao 128*2 = 256
22. raiz total_fila[255];
23. raiz *fila_letras = total_fila - 1;
24. int num_raizes = 0;
25. int final_final_letras = 1;
26. char *codigo_fila_letras[128] = {0}; // codigo 0 ou 1 para cada fila_letras
27. char buffer[1024]; // Tipo Char => 1 byte = (8bits) --> 128*8 = 1024 b
28. //----------------------------------------------------------------------------
29.  
30. //----------------------------------------------------------------------------
31. raiz nova_raiz(int frequencia, char c, raiz esq, raiz dir){
32.         raiz n = frase_completa + num_raizes++;
33.         if (frequencia){
34.                 n->c = c;
35.                 n->frequencia = frequencia;
36.         }else {
37.                 n->esquerda = esq;
38.                 n->direita = dir;
39.                 n->frequencia = esq->frequencia + dir->frequencia;
40.         }
41.         return n;
42. }
43. //----------------------------------------------------------------------------
44.  
45. /* Na ordem decrescente para uma fila de fila_letrass */
46. void fila_letras_inserir(raiz n){
47.         int j, i = final_final_letras++;
48.         while ((j = i / 2)) {
49.                 if (fila_letras[j]->frequencia <= n->frequencia)
50.                         break;
51.                 fila_letras[i] = fila_letras[j];
52.                 i = j;
53.         }
54.         fila_letras[i] = n;
55. }
56. //----------------------------------------------------------------------------
57. raiz remover_fila_letras(){
58.         int i, l;
59.         raiz n = fila_letras[i = 1];
60.  
61.         if (final_final_letras < 2)
62.                 return 0;
63.         final_final_letras--;
64.         while ((l = i * 2) < final_final_letras) {
65.                 if (l + 1 < final_final_letras && fila_letras[l + 1]->frequencia < fila_letras[l]->frequencia) l++;
66.                 fila_letras[i] = fila_letras[l], i = l;
67.         }
68.         fila_letras[i] = fila_letras[final_final_letras];
69.         return n;
70. }
71. //----------------------------------------------------------------------------
72. /* caminhar pelos nos da arvore completando os valores com  0 e 1 */
73. void construir_peso(raiz n, char *s, int len){
74.         static char *saida = buffer;
75.         if (n->c) {
76.                 s[len] = 0;
77.                 strcpy(saida, s);
78.                 codigo_fila_letras[n->c] = saida;
79.                 saida += len + 1;
80.                 return;
81.         }
82.         s[len] = '0'; construir_peso(n->esquerda,  s, len + 1);
83.         s[len] = '1'; construir_peso(n->direita, s, len + 1);
84. }
85. //----------------------------------------------------------------------------
86. void construir_arvore(const char *s){
87.  
88.         int i, frequencia[128] = {0};
89.         char c[16];
90.  
91.         while (*s) // percorre todas as possicoes
92.                 frequencia[(int)*s++]++; // anda nas possicoes da string e atribui o indice da string pro vetor e soma mais 1
93.  
94.         for (i = 0; i < 128; i++){ // procura dentro do vetor
95.                 if (frequencia[i]) // As possicoes do vetor
96.                         fila_letras_inserir(nova_raiz(frequencia[i], i, 0, 0)); // insere somente nas possicoes q tem frequencia maior que 1
97.         }
98.         while (final_final_letras > 2)
99.                 fila_letras_inserir(nova_raiz(0, 0, remover_fila_letras(), remover_fila_letras()));
100.  
101.         construir_peso(fila_letras[1], c, 0);
102. }
103. //----------------------------------------------------------------------------
104.  
105. void comprimir(const char *s, char *saida){
106.         while (*s) {
107.                 strcpy(saida, codigo_fila_letras[*s]);
108.                 saida += strlen(codigo_fila_letras[*s++]);
109.         }
110. }
111. //----------------------------------------------------------------------------
112. void descomprimir(const char *s, raiz t){
113.         raiz n = t;
114.         while (*s) {
115.                 if (*s++ == '0')
116.                         n = n->esquerda;
117.                 else
118.                         n = n->direita;
119.                 if (n->c){
120.                         putchar(n->c);
121.                         n = t;
122.                 }
123.         }
124.         putchar('\n');
125. }
126. //----------------------------------------------------------------------------
127. int main(void){
128.         int i;
129.         const char *frase = "Mario Kart", buffer[1024];
130.  
131.         construir_arvore(frase);
132.         printf("\n Tabela de Pesos:\n ");
133.         for (i = 0; i < 128; i++)
134.                 if (codigo_fila_letras[i])
135.                         printf("'%c':%s\n", i, codigo_fila_letras[i]);
136.  
137.         comprimir(frase, buffer);
138.         printf("\n Frase Comprimida : %s  \n", buffer);
139.  
140.         printf(" Frase Descomprimida : ");
141.         descomprimir(buffer, fila_letras[1]);
142.         printf("\n");
143.         return 0;
144. }
145. //----------------------------------------------------------------------------