C Converter para linguagem C

[trto]

Alguém poderia me ajudar a converter esse código para linguagem C?

 

#include <bits/stdc++.h>
#define D(x) cout << #x " = " << (x) << endl
#define endl '\n'

using namespace std;

const int MAXN = 100000 + 100 + 10 + 1;
namespace SuffixArray {
  int t, rank[MAXN], sa[MAXN], lcp[MAXN];

  bool compare(int i, int j){
    return rank[i + t] < rank[j + t];
  }

  void build(const string &s){
    int n = s.size();
    int bc[256];
    
    for (int i = 0; i < 256; ++i) bc = 0;
    for (int i = 0; i < n; ++i) ++bc[s];
    for (int i = 1; i < 256; ++i) bc += bc[i-1];
    for (int i = 0; i < n; ++i) sa[--bc[s]] = i;
    for (int i = 0; i < n; ++i) rank = bc[s];
    for (t = 1; t < n; t <<= 1){
      for (int i = 0, j = 1; j < n; i = j++){
        while (j < n && rank[sa[j]] == rank[sa]) j++;
        if (j - i == 1) continue;
        int *start = sa + i, *end = sa + j;
        sort(start, end, compare);
        int first = rank[*start + t], num = i, k;
        for(; start < end; rank[*start++] = num){
          k = rank[*start + t];
          if (k != first and (i > first or k >= j))
            first = k, num = start - sa;
        }
      }
    }
    
    int size = 0, i, j;
    for(i = 0; i < n; i++) if (rank > 0) {
      j = sa[rank - 1];
      while(s[i + size] == s[j + size]) ++size;
      lcp[rank] = size;
      if (size > 0) --size;
    }
    lcp[0] = 0;
  }
};

    using namespace SuffixArray;

    int number_of_repeated_substrings(int n) {
      int cnt = lcp[1];
      for (int i = 2; i < n; ++i) {
    cnt += max(0, lcp - lcp[i-1]);
    }
      return cnt;
}

    int main() {
      ios_base::sync_with_stdio(false);cin.tie(NULL);
      string line;
      while (cin >> line && line != "*") {
    line.push_back('\1');
    build(line);
    cout << number_of_repeated_substrings(line.size()) << endl;
  }
      return 0;
}

 

[devair1010]

@Denis Mioto    para converter uma linguagem para outra , é preciso substituir os comando de uma com os da outra , e alguns são bem fácies , como o cout , que se substitui pelo printf , o cin pelo scanf , etc . . .  ,  mas a linguagem   c++   é bem mais avançada do que a linguagem c , e assim alguns comandos dela são difíceis de ser convertidos e é preciso criar funções para isso , então seria melhor saber o que esse código faz e fazê - lo do zero na linguagem    c .  então diga , o que você espera desse código ? , quais as funcionalidades que você precisa que ele faça ? 

[arfneto]

Isso é praticamente um programa em C.

 

C++ é uma linguagem bem diferente e em muitos casos não há esperança de conversão simplesmente.

 

Qual a dificuldade que vê aí?  Tem algum problema objetivo?

 

 

[trto]

2 horas atrás, devair1010 disse:

@Denis Mioto    para converter uma linguagem para outra , é preciso substituir os comando de uma com os da outra , e alguns são bem fácies , como o cout , que substitui pelo printf , o cin pelo scanf , etc . . .  ,  mas a linguagem c++ é bem mais avançada do que a linguagem c , e assim alguns comandos dela são difíceis de ser convertidos e é preciso criar funções para isso , então seria melhor saber o que esse código faz e fazê - lo do zero na linguagem c++ .  então diga , o que você espera desse código ? , quais as funcionalidades que você precisa que ele faça ? 

Eu preciso entregar o programa 1377 do URI em C e não to conseguindo fazer e este postado não esta em C.

 

 

adicionado 0 minutos depois

33 minutos atrás, arfneto disse:

Isso é praticamente um programa em C.

 

C++ é uma linguagem bem diferente e em muitos casos não há esperança de conversão simplesmente.

 

Qual a dificuldade que vê aí?  Tem algum problema objetivo?

 

 

Eu preciso entregar o programa 1377 do URI em C e não to conseguindo fazer e este postado não esta em C.

[arfneto]

21 minutos atrás, Denis Mioto disse:

Eu preciso entregar o programa 1377 do URI em C e não to conseguindo fazer e este postado não esta em C

 

Talvez pudesse postar o código que fez ou perguntar algo objetivo.

 

Como eu disse, esse que postou é praticamente um programa em C já

adicionado 0 minutos depois

tem um botão aí na tela para formatar o código e que permite que fique mais seguro para alguém, que quer ajudar copiar seu código. Experimente.

adicionado 9 minutos depois

podia postar o que é URI, e um link para o tal problema. Seria razoável que você postasse o próprio problema.

 

Do modo como escreveu eu preciso:

• saber o que é URI (esse aqui é um forum sobre C e C# e C++). Hoje eu até sei o que é URI, uma escola do Sul do BR. E acho o site tem um forum... Graças a alguém aqui do forum que me explicou  [ @devair1010 ] 
  É bem provável que muitos entendam de C ou C++ mas não saibam o que é isso...
• aí eu devo sair do contexto do forum, ir até o tal site e achar  tal programa
• ler o enunciado
• voltar aqui e recortar o seu programa da tela
• copiar para um compilador e ver o que pode ser feito.

Você pode abreviar esse caminho de quem quer ajudar...

adicionado 11 minutos depois

Esse programa que postou não está bom --- Em C++ . Tem vários erros.

[trto]

8 minutos atrás, arfneto disse:

 

Talvez pudesse postar o código que fez ou perguntar algo objetivo.

 

Como eu disse, esse que postou é praticamente um programa em C já

adicionado 0 minutos depois

tem um botão aí na tela para formatar o código e que permite que fique mais seguro para alguém, que quer ajudar copiar seu código. Experimente.

adicionado 9 minutos depois

podia postar o que é URI, e um link para o tal problema. Seria razoável que você postasse o próprio problema.

 

Do modo como escreveu eu preciso:

• saber o que é URI (esse aqui é um forum sobre C e C# e C++). Hoje eu até sei o que é URI, uma escola do Sul do BR. E acho o site tem um forum... Graças a alguém aqui do forum que me explicou  [ @devair1010 ] 
  É bem provável que muitos entendam de C ou C++ mas não saibam o que é isso...
• aí eu devo sair do contexto do forum, ir até o tal site e achar  tal programa
• ler o enunciado
• voltar aqui e recortar o seu programa da tela
• copiar para um compilador e ver o que pode ser feito.

Você pode abreviar esse caminho de quem quer ajudar...

URI e uma plataforma de exercicios, https://www.urionlinejudge.com.br/judge/pt/problems/view/1377 este é o exercicio. 

[arfneto]

É disso que está falando? https://www.urionlinejudge.com.br/judge/pt/problems/view/1377

 

 

Podia ter postado isso junto...

#include <bits/stdc++.h>
#define D(x) cout << #x " = " << (x) << endl
#define endl '\n'

using namespace std;

const int MAXN = 100000 + 100 + 10 + 1;
namespace SuffixArray {
    int t, rank[MAXN], sa[MAXN], lcp[MAXN];

    bool compare(int i, int j) {
        return rank[i + t] < rank[j + t];
    }

    void build(const string& s) {
        int n = s.size();
        int bc[256];

        for (int i = 0; i < 256; ++i) bc = 0;
        for (int i = 0; i < n; ++i) ++bc[s];
        for (int i = 1; i < 256; ++i) bc += bc[i - 1];
        for (int i = 0; i < n; ++i) sa[--bc[s]] = i;
        for (int i = 0; i < n; ++i) rank = bc[s];
        for (t = 1; t < n; t <<= 1) {
            for (int i = 0, j = 1; j < n; i = j++) {
                while (j < n && rank[sa[j]] == rank[sa]) j++;
                if (j - i == 1) continue;
                int* start = sa + i, * end = sa + j;
                sort(start, end, compare);
                int first = rank[*start + t], num = i, k;
                for (; start < end; rank[*start++] = num) {
                    k = rank[*start + t];
                    if (k != first and (i > first or k >= j))
                        first = k, num = start - sa;
                }
            }
        }

        int size = 0, i, j;
        for (i = 0; i < n; i++) if (rank > 0) {
            j = sa[rank - 1];
            while (s[i + size] == s[j + size]) ++size;
            lcp[rank] = size;
            if (size > 0) --size;
        }
        lcp[0] = 0;
    }
};

using namespace SuffixArray;

int number_of_repeated_substrings(int n) {
    int cnt = lcp[1];
    for (int i = 2; i < n; ++i) {
        cnt += max(0, lcp - lcp[i - 1]);
    }
    return cnt;
}

int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL);
    string line;
    while (cin >> line && line != "*") {
        line.push_back('\1');
        build(line);
        cout << number_of_repeated_substrings(line.size()) << endl;
    }
    return 0;
}

Está certo de que isso em C++ funcionaria? Em que ambiente?

[trto]

Em 06/06/2020 às 17:15, arfneto disse:

Spoiler

É disso que está falando? https://www.urionlinejudge.com.br/judge/pt/problems/view/1377

 

 

Podia ter postado isso junto...

#include <bits/stdc++.h>
#define D(x) cout << #x " = " << (x) << endl
#define endl '\n'

using namespace std;

const int MAXN = 100000 + 100 + 10 + 1;
namespace SuffixArray {
    int t, rank[MAXN], sa[MAXN], lcp[MAXN];

    bool compare(int i, int j) {
        return rank[i + t] < rank[j + t];
    }

    void build(const string& s) {
        int n = s.size();
        int bc[256];

        for (int i = 0; i < 256; ++i) bc = 0;
        for (int i = 0; i < n; ++i) ++bc[s];
        for (int i = 1; i < 256; ++i) bc += bc[i - 1];
        for (int i = 0; i < n; ++i) sa[--bc[s]] = i;
        for (int i = 0; i < n; ++i) rank = bc[s];
        for (t = 1; t < n; t <<= 1) {
            for (int i = 0, j = 1; j < n; i = j++) {
                while (j < n && rank[sa[j]] == rank[sa]) j++;
                if (j - i == 1) continue;
                int* start = sa + i, * end = sa + j;
                sort(start, end, compare);
                int first = rank[*start + t], num = i, k;
                for (; start < end; rank[*start++] = num) {
                    k = rank[*start + t];
                    if (k != first and (i > first or k >= j))
                        first = k, num = start - sa;
                }
            }
        }

        int size = 0, i, j;
        for (i = 0; i < n; i++) if (rank > 0) {
            j = sa[rank - 1];
            while (s[i + size] == s[j + size]) ++size;
            lcp[rank] = size;
            if (size > 0) --size;
        }
        lcp[0] = 0;
    }
};

using namespace SuffixArray;

int number_of_repeated_substrings(int n) {
    int cnt = lcp[1];
    for (int i = 2; i < n; ++i) {
        cnt += max(0, lcp - lcp[i - 1]);
    }
    return cnt;
}

int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL);
    string line;
    while (cin >> line && line != "*") {
        line.push_back('\1');
        build(line);
        cout << number_of_repeated_substrings(line.size()) << endl;
    }
    return 0;
}

Está certo de que isso em C++ funcionaria? Em que ambiente?

 

Esta funcionando sim, no DEV C e no Coldblocks também esta funcionando, mais eu preciso subir ele no formato C e não consigo converter, você consegue me ajudar?

[arfneto]

11 minutos atrás, Denis Mioto disse:

Esta funcionando sim, no DEV C e no Coldblocks também esta funcionando, mais eu preciso subir ele no formato C e não consigo converter, você consegue me ajudar?

    void build(const string& s) {
        int n = s.size();
        int bc[256];

        for (int i = 0; i < 256; ++i) bc = 0;
        for (int i = 0; i < n; ++i) ++bc[s];
        for (int i = 1; i < 256; ++i) bc += bc[i - 1];
        for (int i = 0; i < n; ++i) sa[--bc[s]] = i;
        for (int i = 0; i < n; ++i) rank = bc[s];

Isso aí acima por exemplo não faz sentido. Em não tenho agora acesso a esses compiladores, talvez mais tarde. Mas não sei o que eles podem mudar...

 

Sem termos muito técnicos, bc = 0 não faz sentido.  bc [ s ] também não. C++ não tem esse mecanismo. s é uma referência a uma string, como um ponteiro. E string é uma classe, algo como uma struct

 

[trto]

1 minuto atrás, arfneto disse:

    void build(const string& s) {
        int n = s.size();
        int bc[256];

        for (int i = 0; i < 256; ++i) bc = 0;
        for (int i = 0; i < n; ++i) ++bc[s];
        for (int i = 1; i < 256; ++i) bc += bc[i - 1];
        for (int i = 0; i < n; ++i) sa[--bc[s]] = i;
        for (int i = 0; i < n; ++i) rank = bc[s];

Isso aí acima por exemplo não faz sentido. Em não tenho agora acesso a esses compiladores, talvez mais tarde. Mas não sei o que eles podem mudar...

 

Sem termos muito técnicos, bc = 0 não faz sentido.  bc [ s ] também não. C++ não tem esse mecanismo. s é uma referência a uma string, como um ponteiro. E string é uma classe, algo como uma struct

 

então, eu não estou conseguindo acertar, esse programa esta me dando as saidas esperadas mais nao funciona, precisa ser integral na linguagem C apenas e nao estou conseguindo desenvolver.

[arfneto]

5 minutos atrás, Denis Mioto disse:

então, eu não estou conseguindo acertar, esse programa esta me dando as saidas esperadas mais nao funciona, precisa ser integral na linguagem C apenas e nao estou conseguindo desenvolver

 

Esse programa, em C++, está errado. Sintaxe. No mínimo nos pontos em que te mostrei. Não vai gerar qualquer sequência.

 

 

[trto]

agora, arfneto disse:

 

Esse programa, em C++, está errado. Sintaxe. No mínimo nos pontos em que te mostrei. Não vai gerar qualquer sequência.

 

 

ok, vou tentando aqui, se conseguir me ajuda será bem vinda a ajuda, muito obrigado!

[arfneto]

2 minutos atrás, Denis Mioto disse:

ok, vou tentando aqui, se conseguir me ajuda será bem vinda a ajuda, muito obrigado!

 

Boa sorte.
Sugiro não contar com esse programa em C++. Talvez não esteja completo ou algo assim. Mas errado está.

Deu azar com esse problema em si. O enunciado é uma bobagem e tem até erros de concordância. 

De qualquer forma, o normal para isso é uma estrutura de dados chamada trie, uma espécie de árvore que você pode ir montando a partir das letras das palavras e fica tudo mais fácil.

Ou uma tabela mesmo, como o cara tentou escrever no programa que postou. Considere sempre o universo de 64 letras possíveis e a linha com no máximo 100.000 letras.

[trto]

@devair1010, bom dia, na verdade eu preciso entregar esse exercício do URI Judgi Online, https://www.urionlinejudge.com.br/judge/pt/problems/view/1377 escrito em .C e não estou conseguindo desenvolver, sera que você consegue me ajudar?

[arfneto]

Já fez algo? Pode postar? Qual a dificuldade? Entendeu a lógica em si? Sabe chegar a algum dos resultados apresentados no enunciado? Conhece C, funções, structs, essas coisas? alguma estrutura de dados?

 

Entendeu o que escrevi antes?

 

[devair1010]

@Denis Mioto     desculpe , mas esse exercício  , eu também não consegui fazer ainda . talvez huma semana .

  ahh , e uma dica , volte lá em cima no início dessa postagem , e edite o código que você postou , mas para isso copie o código que você tem ai no  Dev C++ ou no codeblocks , pois esse que está nesse tópico está cheio de erros  , pois os caracteres  [ i ]  , sumiram  do seu código , e para que o código não fique faltando nenhum caractere , use o botão  <>  que está desenhado lá na barra de ferramentas da janela de postar

e assim ele não terá muitos erros , mas mesmo assim não vai compilar , pois o

#include <bits/stdc++.h> 

não se encontra nesses compiladores , porém o uri aceita esse código com zero por cento de erro .

[arfneto]

38 minutos atrás, devair1010 disse:

não se encontra nesses compiladores , porém o uri aceita esse código com zero por cento de erro

 

As escolas usam esse URI como fonte de tarefas ou algo assim? Como é que alguém precisa entregar isso?

 

Não sei o que significa um serviço aceitar aquele código. Ou 0% de erro. Aquilo sequer compila e acho que nem funciona. E deve haver maneiras mais organizadas de escrever do que aqui com tipo 8 loops em 40 linhas. Menos organizadas também, mais vai dar um trabalho  

 

 

Isso é o que importa do enunciado, que é meio bobinho também, além de ter erros de português.

 

E isso aí sugere que precisa quebrar a linha e avaliar todas as possíveis sub-sequências e criar algo com elas que permita procurar as duplicatas. E entender que as duplicatas podem aparecer depois.

 

O programa postado --- que eu acho que não funciona --- usa um sort() no meio dos loops todos. Uma ideia discutível no mínimo. Se o próprio programa cria as sub- porque não inserir já na ordem?

 

E aí se pode usar qualquer coisa, um vetor de strings, um mapa, uma trie como eu sugeri, uma árvore, sei lá. 

 

Pensei nisso ontem e de fato parece que uma trie--- que é como um dicionário ou uma árvore onde cada nó tem uma letra, seria uma boa ideia porque primeiro de tudo você pode seguir as sequências letra a letra sem duplicar todas as palavras toda hora.

 

Depois vou postar algo sobre isso, se interessar para alguém. Entendam que uma árvore com 64 "filhos" para cada nó pode ser bem simples, já que são apenas 64 letras possíveis e aí poderia indexar direto a letra para a árvore...

[devair1010]

@arfneto    o que sei dessa uri é através desse site

http://www.fw.uri.br/site/pagina/escola-basica-uri

que ela é uma escola situada no Rio Grande do Sul ,  mas não sei se ela tem alguma coisa haver com esse uri online judge ,   que é tipo uma competição de programadores , onde cada código rende alguns pontos e quem  faz o maior número de pontos tem uma melhor classificação no rank  ,  e para enviar um código para teste nele , basta se registrar . 

[arfneto]

1 hora atrás, devair1010 disse:

é uma escola situada no Rio Grande do Sul ,  mas não sei se ela tem alguma coisa haver com esse uri online judge ,   que é tipo uma competição de programadores , onde cada código rende alguns pontos e quem  faz o maior número de pontos tem uma melhor classificação no rank  ,  e para enviar um código para teste nele , basta se registrar

 

Sim, você já tinha me dito e foi assim que eu conheci, Mas o autor diz e eu já tinha lido antes de outros, que tem "que entregar" e deu a impressão de ser algo de escola e não um desafio pessoal ou uma disputa por ranking

adicionado 57 minutos depois

E aí fiquei imaginando se escolas estão usando isso como parte das atividades do curso

 

"trie" e as sub-sequências no enunciado
 

 

Esses são os dois primeiros exemplos, e dá pra ver como deve ser rápido resolver assim, usando essas árvores. E usando cada letra da linha de entrada como índice da árvore a cada nível, como está no meu medíocre desenho.
 

São 64 possíveis "letras". E no byte cabem 256. Ia ser um porre ficar usando índices a toda hora a cada vez que fosse acessar no programa, Então uma tabela que passasse dos 256 para os 64 possíveis ia ser legal, porque assim podia usar direto a letra como índice da tabela, ex: indice['0'] = 2, indice['z'] = 63, usando os valores direto da tabela ASCII, primeiro o ponto, 44, depois a virgula, 46, os números de 48 a 57, as maiusc. a partir de 65 e as min. a partir de 97, passando para uma sequência simples de 0 a 63  e o programa fica sem contas. 

 

Agora digitar isso ou programar seria outro porre então um computador e um pouco de control-c control-v e já era. Para isso os computadores servem afinal..

 

Esse programa

#define _CRT_SECURE_NO_WARNINGS
#include "stdio.h"

int main(int argc, char** argv)
{
	FILE* saida = stdout;
	int disco = 0; // gerou arquivo?
	if (argc > 1)
	{
		saida = fopen(argv[1], "w");
		disco = 1;
	};
	int out = 0;
	fprintf( saida,  "\nconst char idx[256] =\n{\n\n");
	for (int i = 0; i < 46; i = i + 1)
	{	// 44 = . e o primeiro valido: idx = 0
		fprintf( saida, "%3d, ", 0);
		out += 1;
		if (out % 16 == 0) fprintf( saida, "\n");
	};
	fprintf( saida, "  1,   0,\n");// 46 = , idx = 1
	out += 2;
	// loop agora para 0 a 9, idx = 3..11
	int idx = 2;
	for (int i = '0'; i <= '9'; i += 1, idx += 1)
	{
		fprintf( saida, "%3d, ", idx);
		out += 1;
		if (out % 16 == 0) fprintf( saida, "\n");
	};
	// agora o intervalo entre '9'e 'A', 58..64
	for (int i = 58; i < 65; i += 1)
	{
		fprintf( saida, "%3d, ", 0);
		out += 1;
		if (out % 16 == 0) fprintf( saida, "\n");
	};
	// agora as letras de A a Z
	for (int i = 'A'; i <= 'Z'; i += 1, idx += 1)
	{
		fprintf( saida, "%3d, ", idx);
		out += 1;
		if (out % 16 == 0) fprintf( saida, "\n");
	};
	// agora o intervalo entre 'Z' e 'a', 91..96
	for (int i = 91; i <= 96; i += 1)
	{
		fprintf( saida, "%3d, ", 0);
		out += 1;
		if (out % 16 == 0) fprintf( saida, "\n");
	};
	// agora as letras de 'a' a 'z'
	for (int i = 'a'; i <= 'z'; i += 1, idx += 1)
	{
		fprintf( saida, "%3d, ", idx);
		out += 1;
		if (out % 16 == 0) fprintf( saida, "\n");
	};
	// agora o intervalo de 'z' ate o fim
	for (int i = 123; i < 255; i += 1)
	{
		fprintf( saida, "%3d, ", 0);
		out += 1;
		if (out % 16 == 0) fprintf( saida, "\n");
	};
	fprintf( saida, "  0\n\n}; // ARFNeto '20\n");
	if (disco)
	{
		fprintf(stderr, "\nGerado trecho de codigo em '%s'\n",
			argv[1]);
	};
	return 0;
};	// main()

Sim, o mesmo loop umas 6 vezes. Recortar e colar. Se chamar assim:

    gera trecho.h

por exemplo ele mostra

Gerado trecho de codigo em 'trecho.h'

E em "trecho.h" ele cria...

const char idx[256] =
{

  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   1,   0,
  2,   3,   4,   5,   6,   7,   8,   9,  10,  11,   0,   0,   0,   0,   0,   0, 
  0,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26, 
 27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,   0,   0,   0,   0,   0, 
  0,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52, 
 53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0

}; // ARFNeto '20

Bem conveniente. E basta usar o

#include "trecho.h"

no programa...

 

Sobre as strings:

 

A maior string que pode repetir dentro da linha tem metade do tamanho, ex:
 

coisacoisa

A menor tem duas letras apenas, claro. Isso quer dizer que uma função tipo strcmp() resolveria para as comparações, com um pequeno ajuste: não são strings, porque não tem null no final. E retorna 1 se tem ao menos uma repetida no resto da linha.

 

Mas se tiver uma função dessas, que deve ter umas 20 linhas, pode chamar com os possíveis comprimentos para a string interna, e se for repetida cadastrar na "memória" que resolveu usar, seja uma lista de strings, uma árvore, um mapa ou uma trie como eu disse.
 

E provavelmente só precisa usar a partir da primeira letra, porque como a partir da segunda seria igualzinho pode usar recursão e chamar a rotina de novo.
 

Ao final basta somar quantas strings estão lá e game over. Eu iria por esse caminho.

 

[arfneto]

Ainda pensando sobre esse programa

 

Como esse lance de uma matriz de referência dos letras na entrada para as 64 possíveis letras no enunciado, achei melhor mudar um pouco a lógica e usar 65 valores na saída. Assim 0 indica que o caracter não é válido nesse contexto e os valores d e 1 a 64 vão direto para a letra válida.
Assim

#define _CRT_SECURE_NO_WARNINGS
#include "stdio.h"

int main(int argc, char** argv)
{
	FILE* saida = stdout;
	int disco = 0; // gerou arquivo?
	if (argc > 1)
	{
		saida = fopen(argv[1], "w");
		disco = 1;
	};
	int out = 1;
	fprintf( saida,  "\nconst char idx[256] =\n{\n\n");
	for (int i = 0; i < 44; i = i + 1)
	{	// 44 = . e o primeiro valido: idx = 1
		fprintf( saida, "%3d, ", 0);
		if (out % 16 == 0) fprintf( saida, "\n");
		out += 1;
	};
	fprintf( saida, "  1,   0,   2,   0,\n"); 
	// 46 = , idx = 2 48 = '0', idx = 3
	out += 4;
	// loop agora para 0 a 9, idx = 3..11
	int idx = 3;
	for (int i = '0'; i <= '9'; i += 1, idx += 1)
	{
		fprintf( saida, "%3d, ", idx);
		if (out % 16 == 0) fprintf( saida, "\n");
		out += 1;
	};
	// agora o intervalo entre '9'e 'A', 58..64
	for (int i = 58; i < 65; i += 1)
	{
		fprintf( saida, "%3d, ", 0);
		if (out % 16 == 0) fprintf( saida, "\n");
		out += 1;
	};
	// agora as letras de A a Z
	for (int i = 'A'; i <= 'Z'; i += 1, idx += 1)
	{
		fprintf( saida, "%3d, ", idx);
		if (out % 16 == 0) fprintf( saida, "\n");
		out += 1;
	};
	// agora o intervalo entre 'Z' e 'a', 91..96
	for (int i = 91; i <= 96; i += 1)
	{
		fprintf( saida, "%3d, ", 0);
		if (out % 16 == 0) fprintf( saida, "\n");
		out += 1;
	};
	// agora as letras de 'a' a 'z'
	for (int i = 'a'; i <= 'z'; i += 1, idx += 1)
	{
		fprintf( saida, "%3d, ", idx);
		if (out % 16 == 0) fprintf( saida, "\n");
		out += 1;
	};
	// agora o intervalo de 'z' ate o fim
	for (int i = 123; i < 255; i += 1)
	{
		fprintf( saida, "%3d, ", 0);
		if (out % 16 == 0) fprintf( saida, "\n");
		out += 1;
	};
	fprintf( saida, "  0\n\n}; // ARFNeto '20\n");
	if (disco)
	{
		fprintf(stderr, "\nGerado trecho de codigo em '%s'\n",
			argv[1]);
	};
	return 0;
};	// main()

Rodando como 
 

    gera trecho.h

Cria

const char idx[256] =
{

  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   1,   0,   2,   0,
  3,   4,   5,   6,   7,   8,   9,  10,  11,  12,   0,   0,   0,   0,   0,   0, 
  0,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27, 
 28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,   0,   0,   0,   0,   0, 
  0,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52,  53, 
 54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0

}; // ARFNeto '20

Como usar isso?

Um programa simples serviria pra testar a equivalência de TODOS os possíveis valores, já usando o código gerado pelo programa
 

#include "stdio.h"
#include "trecho.h"
int main()
{
	int l = 0;
	printf("\n");
	for (int i = 0; i < 256; i += 1)
		if (idx[i] != 0) // tem representacao
		{	printf("  %2d:%3d %c", idx[i], i, i);
			if (l % 8 == 7) printf("\n");
			l += 1;
		};	// if()
	printf("\n");
};

Que mostra

   1: 44 ,   2: 46 .   3: 48 0   4: 49 1   5: 50 2   6: 51 3   7: 52 4   8: 53 5
   9: 54 6  10: 55 7  11: 56 8  12: 57 9  13: 65 A  14: 66 B  15: 67 C  16: 68 D
  17: 69 E  18: 70 F  19: 71 G  20: 72 H  21: 73 I  22: 74 J  23: 75 K  24: 76 L
  25: 77 M  26: 78 N  27: 79 O  28: 80 P  29: 81 Q  30: 82 R  31: 83 S  32: 84 T
  33: 85 U  34: 86 V  35: 87 W  36: 88 X  37: 89 Y  38: 90 Z  39: 97 a  40: 98 b
  41: 99 c  42:100 d  43:101 e  44:102 f  45:103 g  46:104 h  47:105 i  48:106 j
  49:107 k  50:108 l  51:109 m  52:110 n  53:111 o  54:112 p  55:113 q  56:114 r
  57:115 s  58:116 t  59:117 u  60:118 v  61:119 w  62:120 x  63:121 y  64:122 z

E isso confirma que está tudo certo: apenas as 64 letras aceitas tem um valor, sem colisão.
 

A busca por sub-sequências repetidas

int sub_duplicada(const char* linha, int  N)
{	// a seq de N caracteres no inicio da linha aparece de novo?
	const char* limite = linha + strlen(linha) - N; // ultima posicao possivel
	char* pos = (char*) linha + N;
	int dup = 0;
	while (pos <= limite)
	{
		if (memcmp(linha, pos, N) == 0)
			dup += 1; // esta aqui
		pos += 1;
	};	// for()
	return dup;
};	// sub_duplicada()

Essa função devolve o número de subsequências duplicadas dentro da linha, com comprimento N a partir do início. A partir daí pode usar recursão e ir seguindo para a direita até o fim da linha.

 

Mudança de planos

Conferindo o desenho que postei outro dia e a lógica desse negócio, parei com esse problema. Muitos desses enunciados tem esse preâmbulo de "sua missão é..." e tal, tentando dar um ar de seriedade ao exercício, e esse aqui é um bom exemplo. "Missão de file recovery". Mas como eu tinha dito antes, esse não tem muito sentido. E como se trata de algo "corrigido" mecanicamente:

• que tem que levar a certos resultados.
• E acho que os resultados não tem sentido
   

Deixei pra lá. Esse trecho do do enunciado foi o fim da linha pra mim
 

Citação

Por exemplo, se os dados forem 'ababcabb', as subsequências repetidos contíguas são 'a', 'b' e 'ab', mas nada que contenha 'c', nem 'ba' ou 'Bb' é. Portanto, temos 3 pedaços de bytes contíguos que precisam de verificação neste caso

Ah tá. Então 'a' é um pedaço de byte contíguo? e 'b' também. Uma "sequência que precisa de verificação". Como verificar um byte 'a'? 
 

Parei . Bobagem.

 

Postei os códigos porque tudo que eu disse ainda se aplica a esse tipo de problema. E esse lance da função de mapeamento aparece muitas vezes na prática. 

 

Então pode ser útil para quem quer ou precisa fazer algo assim. E para quem quiser insistir nesse tal programa em particular.

[Simon Viegas]

Olá... segue o que eu entendi do tópico:

 

Vamos alguns pontos:

 

1# 

Sobre a solicitação do chamado?

Em 06/06/2020 às 09:58, Denis Mioto disse:

Alguém poderia me ajudar a converter esse código para linguagem C?

 

Para simplificar: @Denis Mioto, não importa se foi você quem fez ou se achou o código em algum lugar. Qual a necessidade de traduzir um código? Isso não me faz muito sentido. Simplesmente crie um novo código e pronto.

 

O objetivo é VOCÊ criar um algoritmo que resolva um problema em C, e não "você colar lá um código que solucione-o". O objetivo não é fazer o site aceitar uma resposta, mas sim o meio para chegar a essa resposta. Se está sendo solicitado que seja implementado um código em C, vá lá e implemente.

 

 

 

2#
Sobre o enunciado do problema

Temos 2 bases iniciais:

1. é preciso primeiro entender o problema, para só depois tentar solucioná-lo.
2. o que vale é que está no enunciado, não necessariamente o contexto do "mundo real".

Para o [1]. @arfneto, você já sabe o que é para fazer? Se sim, comece a implementar um código para resolver o problema proposto. Se é para fazer em C, faça em C. Caso não saiba, veja ANTES a necessidade de entender o que é para ser feito!!! Vejam: o que eu quero dizer é que não deveria fazer sentido tentar fazer um código que ainda não se sabe para que ele vai servir!!! Piorou "traduzir um código qualquer* para servir como uma possível resposta".

 

Para o [2], se lá existe uma definição do problema... a definição do problema é a que ele definiu. Se existir eventualmente existir algum conflito, devem-se voltar para o [1]. O que pode incluir, por exemplo, discutir o problema em um fórum (como esse; ou um fórum do próprio site; ou entre colegas de curso etc). Vejam: a questão aqui NÃO é discutir para resolver o problema ainda!!! mas pura e simplesmente ANTES entender o problema em si...

 

***

 

Vou tentar entender o que o enunciado quer...

 

Citação

Enquanto você estava pensando em como resolver o problema, você de repente se lembrou de que o sistema de arquivos também manteve várias cópias de cada arquivo, portanto, apenas os pedaços de bytes contíguos que se repetem tem a chance de ser um arquivo. Além disso, para cada repetição dos mesmos bytes contíguos, apenas uma cópia precisa ser verificada. Por exemplo, se os dados forem 'ababcabb', as subsequências repetidos contíguas são 'a', 'b' e 'ab', mas nada que contenha 'c', nem 'ba' ou 'Bb' é. Portanto, temos 3 pedaços de bytes contíguos que precisam de verificação neste caso. Você precisa escrever um programa que calcule exatamente quantas sequências precisam de verificação, isto é o número de sequências diferentes de bytes contíguos que aparecem em pelo menos duas vezes nos dados.

 

Vejam o texto o negrito.. para mim não deveria importar se isso faz algum sentido técnico ou não.. o cerne não deveria ser a viabilidade, mas sim o requisito desejado. "Ele quer isso, vamos dar isso" [suponto que já sabemos que o enunciado está correto, como sugerido mais acima].

 

Então. Geralmente analisar a saída ajuda... vamos lá:

 

Citação

 

O que eu entendi que precisa ser feito é: informe quantas sub-strings distintas se repetem na string informada.

 

Vamos ver se se encaixa as saídas:

Para: ababcabb

1. "a" se repete;
2. "b" se repete;
3. "ab" se repete;

Logo, temos 3 sub-strings repetindo.

 

 

Para: mississippi

1. "i" se repete;
2. "s" se repete;
3. "p" se repete;
4. "is" se repete;
5. "ss" se repete;
6. "si" se repete;
7. "issi" se repete; "is" se repete;
8. "iss" se repete;
9. "ssi" se repete

Logo, temos 9 sub-strings repetindo.

 

 

Para: aaaaaaaaaaaaaaaaaaaaaaaaaa

1. "a"
2. "aa"
3. "aaa"
4. "aaaa"
5.  
6. .
7. .
8. .
9. .
10. .
11. .
12. .
13. .
14. .
15.  
16.  
17.  
18.  
19.  
20.  
21.  
22.  
23. "aaaaaaaaaaaaaaaaaaaaaaaa"
24. "aaaaaaaaaaaaaaaaaaaaaaaaa"
25. "aaaaaaaaaaaaaaaaaaaaaaaaaa"

Logo, temos 25 sub-strings repetindo.

 

 

Para: say.twice,say.twice

1. "s"
2. "a"
3. "y"
4. "."
5. "t"
6. "w"
7. "i"
8. "c"
9. "e"
10. "sa"
11. "ay"
12. "y."
13. ".t"
14. "tw"
15. "wi"
16. "ic"
17. "ce"
18. "say"
19. "ay."
20. "y.t"
21. ".tw"
22. "twi"
23. "wic"
24. "ice"
25. "say."
26. "ay.t"
27. "y.tw"
28. ".twi"
29. "twic"
30. "wice"
31. "say.t"
32. "ay.tw"
33. "y.twi"
34. ".twic"
35. "twice"
36. "say.tw"
37. "ay.twi"
38. "y.twic"
39. ".twice"
40. "say.twi"
41. "ay.twic"
42. "y.twice"
43. "say.twic"
44. "ay.twice"
45. "say.twice"

Logo, temos 45 sub-strings repetindo. 

 

 

PRONTO!

Esse entendimento do problema está correto? 

SE SIM, então só a partir de agora eu começaria a implementar algum algoritmo que consiga solucionar o problema; (Como citado mais acima: não me faz muito sentido 'traduzir' um outro código.)

SE NÃO, então nada de código por enquanto... teria que antes parar para entender melhor o problema.

 

[arfneto]

10 horas atrás, Simon Viegas disse:

Para o [1]. @arfneto, você já sabe o que é para fazer? Se sim, comece a implementar um código para resolver o problema proposto. Se é para fazer em C, faça em C. Caso não saiba, veja ANTES a necessidade de entender o que é para ser feito!!! Vejam: o que eu quero dizer é que não deveria fazer sentido tentar fazer um código que ainda não se sabe para que ele vai servir!!! Piorou "traduzir um código qualquer* para servir como uma possível resposta".

Não entendi o que você quer dizer  

[Simon Viegas]

14 horas atrás, arfneto disse:

Não entendi o que você quer dizer  

 

Estava me referindo a uma nova implementação para o @Denis Mioto, ou seja: ele deve primeiro entender o problema. Caso não tenha entendido ainda, não tem porque começar a tentar implementar. E outro ponto é sobre a "tradução de código". Se não entendeu ainda o problema, menos ainda adiantaria traduzir um código que eventualmente estaria correto. (Se não entendeu o problema e o código está correto, ou acertaria por sorte, ou copiou de outro lugar.)

 

 

Sobre esse recurso Trie... eu não tinha ouvido falar antes.. Mas, seguindo o que eu entendi do problema, uma arvore ficaria mais ou menos assim:

Para ababcabb:

 

Legenda:

1. As bolinhas verdes são as sub-strings que se repetem;
2. As bolinhas brancas são as que existem, mas não se repetem (precisam existir para ter uma referência que não precisa verificar).

O que o enunciado queria seria a quantidade de círculos verdes, ou seja: 3 repetições. O "a" se repete, o "ab" se repete e o "b" se repete.

 

Adendo:

Eu usei um recurso online para gerar a árvore. Mas poderia ser "A" primeira bola e "AB" na bola filha. (O site que representa apenas uma letra.)

 

 

Para mississipi :

OBS.: a imagem acima está errada, o "pp" não se repete. (houve um erro na hora de cria manualmente a árvore online!! mas a lógica é exatamente a mesma)

Total 9 [i, is, iss, issi, p, s, ss, si, ssi] Total 9 [i, is, iss, issi, p, pp, s, ss, ssi].

 

 

Para aaaaaaaaaaaaaaaaaaaaaaaaaa:

 

Total 25 repetições.

obs.: esse não terá ponto de parada pois não é verificado a posição 26 (não tem como toda string se repetir)

 

 

Para o 012345678,abcdefg.STUVWXYZ:

A árvore teria 26 bolas (uma para caada caractere) e todas seriam brancas. 

 

Por aí vai...

 

 

Ou seja: só aqui suponho que o nosso entendimento (@arfneto e meu) são distintos (ou sequer entendi o que você entendeu)... mas no final, o que importaria seria o que o @Denis Mioto entendeu, ou passará a entender, pois é ele que vai implementar o código em C.

 

adicionado 13 minutos depois

Para tentar demonstrar o que eu entendi, fiz um código que conta quantas substring estão repetindo:

Para ababcabb:

 

No caso, existem um total de 7 repetições... mas acontece que o enunciado do problema não quer "repetições repetidas". Logo:
 

 

Risquei as repetições repetidas... deu 3 repetições.

 

 

Para mississipi:

 

 

RESUMINDO:

Em 08/06/2020 às 13:58, Simon Viegas disse:

O que eu entendi que precisa ser feito é: informe quantas sub-strings distintas se repetem na string informada.

 

adicionado 23 minutos depois

Para say.twice,say.twice não tem repetições repetidas:

 

O resultado seria 45 mesmo.

 

ADENDO:

Eu, como curioso que sou, até tenho curiosidade para entender para que essa contagem serviria para recuperar dados, mas o que estou propondo é que é algo irrelevante para solução do problema. No caso, é preciso entender "o quê o enunciado quer que o programa conte", e não necessariamente "a serventia de determinada contagem para alguma coisa".

 

A proposta seria ficar apenas dentro do escopo da função, ou seja: só me importaria o valor de entrada e qualquer seria o valor de saída esperado.

 

 

[arfneto]

 

1 hora atrás, Simon Viegas disse:

Estava me referindo a uma nova implementação para o @Denis Mioto, ou seja: ele deve primeiro entender o problema. Caso não tenha entendido ainda, não tem porque começar a tentar implementar. E outro ponto é sobre a "tradução de código".

 

Pois é, mas está claramente dirigido a @arfneto este que escreve agora. E eu na verdade não gostei da sugestão de que eu estivesse "traduzindo um código qualquer". Mais as observações em vermelho, negrito e sublinhado, claramente endereçadas a mim e não ao autor do tópico. Eu poderia escrever isso em C++ ou C ou mais um certo número de outras linguagens. Não precisaria traduzir outros códigos. Eu só tentava explicar. Ajudar.

 

Citação

Se você @Simon Viegas pretendia dirigir isso ao autor do tópico não devia ter usado o MEU nome. E não entendi porque fez isso e daí a minha singela afirmação

• Eu já sei o que fazer. Mas o enunciado é uma bobagem e não tem pra quem reclamar. E resolvi abandonar. Mas deixei práticas e código que podem ser úteis para quem quiser insistir nisso
   
• E sei o que é trie e sugeri como uma possibilidade porque é mais simples de implementar e tem menos redundância porque não salva todas as possíveis milhares de strings. Apenas salva a árvore com as letras. Você pode ver isso como uma árvore onde cada nó tem exatos 64 descendentes nesse caso. Vou mostrar uma solução, afinal eu ia mesmo escrever e pode ser útil. Parece que não há exemplos disso online acessíveis
   
• E eu mostrei como usar um programa que gera um trecho de programa em C com a declaração do vetor que transforma a letra na entrada, das 256 possíveis em 65 para por na estrutura sem ter que ficar fazendo contas: 64 letras direto do código e um valor para os inválidos. O que minha avó chamava de "uma mão na roda". É uma prática comum em alguns círculos não é comum de ver num forum para iniciantes.
   
• E postei um roteiro de como implementar algo assim. 

 

Vou explicar melhor. ilustrando com sua própria opinião e seus posts recentes nesse tópico, o que está errado aqui, @Simon Viegas

 

Não, o entendimento não está correto
 

 

Veja o enunciado.

 

 É aí você escreveu isso: 

 

Vamos ver se se encaixa as saídas:

Para: ababcabb

"a" se repete;
"b" se repete;
"ab" se repete;
Logo, temos 3 sub-strings repetindo.

Para: mississippi

"i" se repete;
"s" se repete;
"p" se repete;
"is" se repete;
"ss" se repete;
"si" se repete;
"is" se repete;
"iss" se repete;
"ssi" se repete
Logo, temos 9 sub-strings repetindo.

 

 

Mas hoje já escreveu isso:

Só que: 

• as 9 que você listou ontem são diferentes das 9 de hoje.
• Nas 9 de ontem você incluiu duas vezes a sequência "is", contrariando o enunciado
• Nas 9 de hoje você incluiu a sequência '" issi" que sequer se repete.

E assim acho que vai entender porque eu disse o que eu disse. Esse enunciado é uma bobagem. 
 

23 horas atrás, Simon Viegas disse:

Então. Geralmente analisar a saída ajuda... vamos lá:

Pois é

 

23 horas atrás, Simon Viegas disse:

"Ele quer isso, vamos dar isso" [suponto que já sabemos que o enunciado está correto, como sugerido mais acima].

 

Pense nisso... Não está correto.

 

 

[Simon Viegas]

@arfneto, de antemão respeito deu feedback honesto... e espero não ter causado problemas...  e peço desculpa por qualquer mal entendido... 

 

Vamos lá:

 

1 hora atrás, arfneto disse:

Pois é, mas está claramente dirigido a @arfneto este que escreve agora. E eu na verdade não gostei da sugestão de que eu estivesse "traduzindo um código qualquer".

Creio que seja esperado que jamais teria a intenção de ofender ninguém, ainda mais você que sequer me deu motivos... Peço que abstraia e entenda apenas como mal uso de palavras minhas...

 

 

 

1 hora atrás, arfneto disse:

Mais as observações em vermelho, negrito e sublinhado, claramente endereçadas a mim e não ao autor do tópico. Eu poderia escrever isso em C++ ou C ou mais um certo número de outras linguagens. Não precisaria traduzir outros códigos. Eu só tentava explicar. Ajudar.

São relacionados às premissas anteriores... Veja: foi ele que abriu um tópico para traduzir um código... "qualquer" foi apenas, também, um mal uso... foi mal.

 

 

1 hora atrás, arfneto disse:

Eu já sei o que fazer. Mas o enunciado é uma bobagem e não tem pra quem reclamar. E resolvi abandonar. Mas deixei práticas e código que podem ser úteis para quem quiser insistir nisso

Reforçando a premissa: estou focando no autor. Além de nós, que estamos tentando ajudá-lo, é ele, principalmente, que deve ANTES entender o que o exercício quer responder.. É algo (que acho) que já costumo empregar a um tempo: "focar no entendimento do problema antes de implementar um código". (no caso do autor... seja ele criar um novo código, ele usar um código traduzido). (Adendo: o "qualquer" vem daí, pois tanto faz se foi ele mesmo quem o fez, seja se ele "achou pronto" em algum lugar.)

 

 

 

1 hora atrás, arfneto disse:

E sei o que é trie e sugeri como uma possibilidade porque é mais simples de implementar e tem menos redundância porque não salva todas as possíveis milhares de strings. Apenas salva a árvore com as letras. Você pode ver isso como uma árvore onde cada nó tem exatos 64 descendentes nesse caso. Vou mostrar uma solução, afinal eu ia mesmo escrever e pode ser útil. Parece que não há exemplos disso online acessíveis

Show!!! O meu comentário foi com tom de agradecimento por me apresentar algo útil (que eu não conhecia), e ao mesmo tempo de forma que foi suficiente para eu (tentar) utilizar o mesmo recurso para a minha demonstração de entendimento do problema. Vide:

 

2 horas atrás, Simon Viegas disse:

Sobre esse recurso Trie... eu não tinha ouvido falar antes.. Mas, seguindo o que eu entendi do problema, uma arvore ficaria mais ou menos assim:

A árvore que eu postei é Trie (pelo menos é isso que diz o site online que eu criei a árvore - https://www.cs.usfca.edu/~galles/visualization/Trie.html).

 

 

 

1 hora atrás, arfneto disse:

E eu mostrei como usar um programa que gera um trecho de programa em C com a declaração do vetor que transforma a letra na entrada, das 256 possíveis em 65 para por na estrutura sem ter que ficar fazendo contas: 64 letras direto do código e um valor para os inválidos. O que minha avó chamava de "uma mão na roda". É uma prática comum em alguns círculos não é comum de ver num forum para iniciantes.

1 hora atrás, arfneto disse:

E postei um roteiro de como implementar algo assim. 

 

A parte do teu código confesso que fiquei longe de entender ainda...(não sou um grande programador, e conheço ainda menos C). Eu tinha em mente antes chegarmos a um senso comum de qual é o entendimento correto do problema, para só depois, caso necessário, tirar algumas dúvidas com vocês.

Veja: no momento achava que ainda não tínhamos entendido o problema de forma igual:

 

2 horas atrás, Simon Viegas disse:

Ou seja: só [até] aqui suponho que o nosso entendimento (@arfneto e meu) são distintos (ou sequer entendi o que você entendeu)... mas no final, o que importaria seria o que o @Denis Mioto entendeu, ou passará a entender, pois é ele que vai implementar o código em C.

 

Ali citei você entre "()" para dizer que "nosso" era apenas eu e você, sem incluir o autor (que não sei o que ele entendeu) ou outros entendimentos.

 

 

 

VAMOS A QUESTÃO DO MEUS ALGORITMO

Sobre:

1 hora atrás, arfneto disse:

as 9 que você listou ontem são diferentes das 9 de hoje.

 

Foram erros digitação e erro de criação de árvore correspondente (como achava que a árvore estava certa, criei uma lista baseado nela). Eu fiz de cabeça! (o resultado dos código estão certos). Já corrigi parte das minhas postagem. Cito-os abaixo:

 

Em 08/06/2020 às 13:58, Simon Viegas disse:

Para: mississippi

1. "i" se repete;
2. "s" se repete;
3. "p" se repete;
4. "is" se repete;
5. "ss" se repete;
6. "si" se repete;
7. "issi" se repete; "is" se repete;
8. "iss" se repete;
9. "ssi" se repete

x

2 horas atrás, Simon Viegas disse:

OBS.: a imagem acima está errada, o "pp" não se repete. (houve um erro na hora de criar manualmente a árvore online!! mas a lógica é exatamente a mesma)

Total 9 [i, is, iss, issi, p, s, ss, si, ssi] Total 9 [i, is, iss, issi, p, pp, s, ss, ssi].

Pode de ser que ainda tenha erro kkkkkk. De qualquer forma peço que foque na lógica.
 

Ou seja: houve erros na demonstração da lógica, não na lógica em si. (Obs.: mesmo que eventualmente essa lógica não siva para o enunciado - eu ainda acho que sim. Apenas reforço que já existem pelo menos 2 entendimentos diferentes, o que no mínimo dar um ar de não ser um problema tão trivial assim... para menos para mim, é claro.)

 

 

 

1 hora atrás, arfneto disse:

Pense nisso... Não está correto.

 

Então... para mim o enunciado está correto... assim como acho que a lógica que estou usando responde a ela.

 

Sobre:

1 hora atrás, arfneto disse:

Veja o enunciado.

 

 

Justamente. Estou supostamente fazendo isso:
 

Em 08/06/2020 às 13:58, Simon Viegas disse:

O que eu entendi que precisa ser feito é: informe quantas sub-strings distintas se repetem na string informada.

 

Estou propondo que o enunciado pode ser resumido a isso... ou seja: não deveriam-se sequer importar se essa verificação faz algum sentido para essa história "Recuperador de Arquivos"... isso seria só um "enche linguiça" ("atrapalhar a abstração").