fork download
copy 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <malloc.h>
  4. #include <string.h>
  5.  
  6. typedef int bool;
  7. enum { false, true };
  8.  
  9. // elemento da lista
  10. typedef struct estr {
  11.     char letra;
  12.     struct estr *prox;
  13. } NO;
  14.  
  15. typedef struct {
  16.     NO *inicio;
  17. } LISTA;
  18.  
  19. void inicializarLista(LISTA *l) {
  20.     l->inicio = NULL;
  21. }
  22.  
  23. //início das funções de teste
  24.  
  25. void criarLista(LISTA *l, char plvr[]) {
  26.     NO *ult = NULL;
  27.     int i;
  28.  
  29.     for (i = 0; i < strlen(plvr); i++) {
  30.         NO *novo = (NO *) malloc(sizeof(NO));
  31.         novo->letra = plvr[i];
  32.         novo->prox = NULL;
  33.         if (ult) {
  34.             ult->prox = novo;
  35.         } else {
  36.             l->inicio = novo;
  37.         }
  38.         ult = novo;
  39.     }
  40. }
  41.  
  42. void imprimirLista(LISTA *l) {
  43.     NO *p = l->inicio;
  44.     while(p) {
  45.         printf("%c", p->letra);
  46.         p = p->prox;
  47.     }
  48. }
  49.  
  50. LISTA* clonarLista(LISTA* l){
  51.   LISTA* resp = malloc(sizeof(LISTA));
  52.  
  53.   NO *corrente = l->inicio;
  54.   NO *anterior = NULL; //utilizar um nó anterior para ligar os vários elementos
  55.  
  56.   while(corrente){ //agora com corrente em vez de l
  57.     NO *novo = (NO *) malloc(sizeof(NO));
  58.     novo->letra = corrente->letra;
  59.     novo->prox = NULL;
  60.  
  61.     if (anterior == NULL){ //se é o primeiro fica no inicio da nova lista
  62.         resp->inicio = novo;
  63.     }
  64.     else { //se não é o primeiro liga o anterior a este pelo prox
  65.         anterior->prox = corrente;
  66.     }
  67.  
  68.     anterior = novo;
  69.     corrente = corrente->prox;
  70.   }
  71.  
  72.   return resp;
  73. }
  74.  
  75.  
  76.  
  77. void inverter(LISTA* resp){
  78.  
  79.     NO* atual = resp->inicio;
  80.  
  81.     /*redefinir a lista para começar vazia, sendo que o ponteiro atual ainda
  82.     aponta para os seus elementos*/
  83.     resp->inicio = NULL;
  84.  
  85.     while (atual->prox != NULL){ //enquanto houver nós
  86.         NO* corrente = atual; //guardar nó corrente
  87.         atual = atual->prox; //avançar nó atual
  88.  
  89.  
  90.         corrente->prox = resp->inicio; //fazer o prox do corrente ser o 1 da lista invertida
  91.         resp->inicio = corrente; //o inicio passa a ser este ultimo nó
  92.     }
  93. }
  94.  
  95. //fim das funções de teste
  96.  
  97. void inverterNvs(NO* elemento, NO* anteriorAoElemento, NO* fim) {
  98.     if (elemento != fim) {
  99.         inverterNvs(elemento->prox, elemento, fim);
  100.     }
  101.     elemento->prox = anteriorAoElemento;
  102. }
  103.  
  104.  
  105. bool verificaSequencia(NO* dado) {
  106.     if (dado->letra != 'a' && dado->letra != 'e' && dado->letra != 'i' && dado->letra != 'o' && dado->letra != 'u'){
  107.         return true;
  108.     }
  109.     else{
  110.         return false;
  111.     }
  112. }
  113.  
  114. void decodificar(LISTA* resp) {
  115.     NO* pNv = NULL; // Primeira não-vogal encontrada.
  116.     NO* ultNv = NULL; // Última não-vogal encontrada.
  117.  
  118.     NO* atual = resp->inicio; // Ponteiro para percorrer a lista.
  119.  
  120.     NO* anterior = NULL;
  121.  
  122.     /* Laço para percorrer toda lista. */
  123.     while (atual != NULL) {
  124.  
  125.  
  126.         /* Enquanto atual apontar para uma não-vogal. */
  127.         if (verificaSequencia(atual)) {
  128.             /* Salva o primeiro caso encontrado de não-vogal. */
  129.             pNv = atual;
  130.  
  131.  
  132.             /* Procura na lista o último caso de não-vogal. */
  133.             while (atual->prox != NULL && verificaSequencia(atual->prox)) {
  134.                 atual = atual->prox;
  135.             }
  136.  
  137.             /* Quando a próxima letra for uma vogal, então foi atingido o fim da sequência de não-vogais. */
  138.             ultNv = atual;
  139.  
  140.             /* Se existir uma sequência de não-vogais, ou seja, pNv e ultNv não apontarem para o mesmo elemento, então a troca de posições deve ser efetuada. */
  141.             if (pNv != ultNv) {
  142.                 /* Chama uma função recursiva para efetuar a troca de posições sem precisar criar uma nova lista. */
  143.  
  144.                 NO* proximoOriginal = ultNv->prox;
  145.  
  146.                 inverterNvs(pNv->prox, pNv, ultNv);
  147.  
  148.                 pNv->prox = proximoOriginal;
  149.  
  150.                 if (anterior == NULL){
  151.                     resp->inicio = ultNv;
  152.                 }
  153.                 else {
  154.                     anterior->prox = ultNv;
  155.                 }
  156.  
  157.                 atual = pNv;
  158.             }
  159.         }
  160.  
  161.         /* Move para o próximo elemento. */
  162.         anterior = atual;
  163.         atual = atual->prox;
  164.     }
  165. }
  166.  
  167.  
  168. int main() {
  169.     LISTA l;
  170.     inicializarLista(&l);
  171.     //A partir de um vetor de char uma lista foi gerada para testes
  172.     char palavra[] = "monstros legais"; //Resultado esperado: "mortsnol segais"
  173.     criarLista(&l, palavra);
  174.  
  175.     LISTA* resp = clonarLista(&l); //obter o clonado
  176.     //inverter(resp); //inverter o clonado
  177.     //imprimirLista(resp); //imprimir o clonado
  178.  
  179.     decodificar(resp);
  180.     imprimirLista(resp);
  181.  
  182.  
  183.  
  184.     return 0;
  185. }
  186.  
Success #stdin #stdout 0s 10320KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
mortsnol segais
https://ideone.com/1lwTi5
language:
C (gcc 8.3)
created:
7 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!