arfneto

Não entendi o que você quer dizer

Bom que funcionou! Essas estruturas são pensadas como abstratas. Se você declarar do jeito simples como te falei, criar uma pilha seria algo assim Pilha* cria_pilha(int capacidade) { Pilha* pi = (Pilha*)malloc(sizeof(Pilha)); pi->capacidade = capacidade; pi->emUso = 0; pi->p == NULL; return pi; }; // cria_pilha() E você poderia usar do jeito fácil: #define _CRT_SECURE_NO_WARNINGS #include "stdio.h" #include "stdlib.h" #include "header.h" int main() { Pilha* p1 = cria_pilha(200); Pilha pratos = *cria_pilha(30); if (pilha_vazia(p1)) printf("pilha 1 vazia\n"); if (pilha_vazia(&pratos)) printf("pilha 'pratos' vazia\n"); return 0; }; // main() Pilha* cria_pilha(int capacidade) { Pilha* pi = (Pilha*)malloc(sizeof(Pilha)); pi->capacidade = capacidade; pi->emUso = 0; pi->p = NULL; return pi; }; // cria_pilha() int pilha_vazia(Pilha* p) { return p->emUso == 0; }; // pilha_vazia() Quando você cria a pilha já declara o tamanho e ela já é criada vazia. E pode declarar logo um vetor delas se precisar pilha 1 vazia pilha 'pratos' vazia

entendeu como pode ser mais simples?

Se você me disser algo objetivo posso te ajudar. Vou te mostrar um exemplo mais tarde

voce entendeu que precisa mudar um pouco a definicao da pilha? Onde esta o enunciado?

Mas qual foi o problema? Não sei se entendi a razão de você escrever assim os dados Em especial : int recupera_tamanho_pilha(Pilha* pi) { if(pi == NULL) return 0; int tamanho = 0; struct elemento* item = *pi; while(item != NULL) { tamanho++; item = item->prox; } return tamanho; } Mas se foi você que escreveu a pilha toda inserção e remoção ocorre através de suas rotinas Porque precisa que uma função que percorre a pilha para recuperar o tamanho? Se usou push() porque não pop() e top(0 ou peek() que são os nomes consagrados para essas funções? O primeiro caso empilha 'prato'que é um char de 50, alocando um a um? O segundo empilha float alocando um vetor de float? O que está tentando fazer? Veja essa possível declaração: struct prato { char cor[50]; }; struct elemento { struct prato* item; struct elemento* prox; }; typedef struct elemento Elemento; struct pilha { int capacidade; int emUso; Elemento* p; }; typedef struct pilha Pilha; Esse é o normal. Notas: Em geral você não define typedef só do ponteiro. Se vai usar só um define só o da estrutura Declare capacidade e tamanho DENTRO de cada pilha, assim você pode ter várias pilhas de várias coisas dentro do mesmo programa. E fica TUDO mais fácil A pilha tem um endereço para um elemento. Só isso. Um elemento em geral é um ponteiro para char, ou void. porque assim ao mudar de conteúdo você não precisa nem compilar a parte do programa que mexe com a pilha. Por isso essas estruturas são ditas abstratas. ADT. essas estruturas tem métodos consagrados. Não precisa inventar nada. Basta ver as pilhas em outras linguagens ou na literatura. E as filas, árvores, mapas, árvores, tries e tal. Tudo igual. Tem um enunciado objetivo? Um problema objectivo que fez você desistir?

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 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.

você não disse onde está o erro. Sobre a ordem basta mudar a comparação. Em geral se usa uma função de comparação, como o próprio qsort() da biblioteca, e assim fica independente.

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.

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...

Você tem um livro sobre C? Qual? Como aprende os comandos, os conceitos? Que pretende escrevendo struct p? Você entende inglês? Se não entende, pode conseguir um compilador que gere mensagens em português? Lá diz que o tipo para o parâmetro 2 está incompleto aí vai lá e lê struct p... Mas que p#$$a de struct? Qual seria o nome da struct? E no parâmetro anterior você escreveu struct* Pilha pilha. Como acha que em um caso precisa do tipo e no outro não, na mesma linha? E essa não é a função que nem usa no programa? Porque não apagou isso? Você escreveu o programa todo ou foi copiando de lugares? Poste o programa todo e a lista de erros toda e não esses trechos de imagens. Ajude os outros a ajudarem você.

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?

while(fscanf(pnt_fich,"%[\n]",nome) != EOF Há uma certa diferença aí, @devair1010 : Você sumiu com o '^' Esse especificador para scanf(), "%[ ]" é uma lista de caracteres. E se o primeiro for um ^ indica a negativa da lista. E é assim desde os tempos em que scanf() ficava no /usr/bin da máquina do K. Thompson no final dos 60 --- acho que foi ele que escreveu a primeira versão. É uma parte de uma expressão regular. Então %[cdef] aceita apenas cdef e %[^cdef] aceita qualquer coisa exceto cdef Veja com atenção esse exemplo de saída do programa que está abaixo string: 'ssdsdaaagffgf23234b344cc' especificador '%[^abcd]%[ad]' sscanf() retornou 2 a: 'ss' b: 'd' string: 'ssdsdaaagffgf23234b344cc' especificador '%[^abcd]d%[^f]' sscanf() retornou 2 a: 'ss' b: 'sdaaag' Cada scanf() usa a mesma entrada e tenta ler 'a' e 'b' no primeiro caso aceita aceita tudo exceto abcd então consome ss e para no d depois aceita apenas ad mas vem um d logo a seguir então consegue ler a e b e retorna 2 no segundo caso a coisa mudou: ele aceita tudo exceto abcd então para no d depois vem o d sozinho e scanf() pula o d. O 'd' sózinho lá é ativo!!! depois vem o [ ^f] e scanf() consome tudo até o f Assim também fica mais um exemplo do porque eu sempre aviso para ler o retorno de scanf(). E não para comparar com EOF como está no programa do autor, mas sim com a quantia de especificadores, como os dois aqui no exemplo. Porque é muito possível que scanf() só leia alguns. Ou nenhum. Ou mesmo retorne algo <0 que será o EOF. Então entenda que não testar é ingenuidade, mas testar por EOF apenas não acrescenta muito... scanf() não foi feita para ler valores do teclado. Foi escrita para ler entrada formatada. Por isso tem esse nome. Por isso tem esse comportamento. Eu sempre explico isso em todo lugar. Evite usar isso para ler do teclado. É muito difícil de controlar. Leia uma linha ou uma letra, via fgetc() ou fgets() e terá uma vida mais tranquila. O teste #define _CRT_SECURE_NO_WARNINGS #include "stdio.h" #include "stdlib.h" int main() { const char* exemplo = "ssdsdaaagffgf23234b344cc"; const char* formato1 = "%[^abcd]%[ad]"; const char* formato2 = "%[^abcd]d%[^f]"; int n = 0; char a[30]; char b[30]; char buffer[80]; printf("\nstring: '%s'\nespecificador '%s'\n\n", exemplo, formato1); n = sscanf(exemplo, formato1, a, b); printf("sscanf() retornou %d\n", n); if (n > 0) printf("\ta: '%s'\n", a); if (n > 1) printf("\ta: '%s'\n", b); printf("\nstring: '%s'\nespecificador '%s'\n\n", exemplo, formato2); n = sscanf(exemplo, formato2, a, b); printf("sscanf() retornou %d\n", n); if (n > 0) printf("\ta: '%s'\n", a); if (n > 1) printf("\ta: '%s'\n", b); return 0; }; // main()

Essas coisas não combinam, como diz a mensagem. float* é um ponteiro para float, então ou você declara float plpreco ou escreve plpreco = &Livros.preco; Porque declarou um único livro?

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.

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

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

É 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?

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.

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?

Seu programa não está nada bom. Tire isso de seu programa. Isso é --- sério --- dos anos 80 --- e não é possível que precise de algo que tenha aí e não tenha na linguagem, porque mesmo nos 80 não era assim importante. Eu usava... Se está aprendendo, se acostume a imediatamente imprimir o que leu, para se sentir seguro do que está havendo. A menos que saiba usar o debugger, claro. Pra que perguntou o nome do arquivo para abrir outro a partir de um literal, o nome FIXO? Não, não retorne zero. Tudo menos zero. Você está perdendo a oportunidade óbvia de saber que seu programa saiu por aí. Todos os programas retornam zero. Retorne -523 por exemplo e saberá que não conseguiu abrir o arquivo quando for o caso @devair1010 te disse: não use scanf(). Essas funções não foram escritas para isso. Você pode usar, mas é bobagem. Faça o simples e use fgets(). Você não precisa disso. Se usa isso para parar o programa porque só roda o programa dentro do IDE --- sim, IDE é masculino e não feminino --- tem dois problemas: não devia fazer isso porque o ambiente de teste dentro do IDE não é o mesmo da execução normal do programa e não vai saber se ele de fato funciona e ele pode falhar num sistema de teste automatizado ou no computador do professor Seu IDE por certo tem um comando óbvio para não fechar a janela ao programa terminar. Uma configuração só para todos os seus programas

Como eu disse, está faltando o 1 lá no enunciado. Isso é a resposta. Mas não é o programa. Sem contar com a leitura de imagens, o que podemos fazer? Arrumar uma notação para entrar com os vértices, que vai ser algo como os pares ordenados, e aí criar a matriz de adjacência, imprimir e calcular talvez o grau dos vértices a pedido do usuário. Ou listar todos logo. Com a matriz pronta tem um monte de problemas que se pode resolver, tipo se existe caminho entre dois pontos, quantos, o mais curto e tal.

Pois é... Ou vale o que você escreveu antes ou vale o que escreveu agora. Se valesse o que escreveu ao criar o tópico era de se esperar algo assim: "Os X primeiros primos na sequencia de Fibonacci são: ... " ou no singular se o cara digitou N = 1: "O primeiro primo na sequencia de Fibonacci e 2" Por outro lado: Não retornar nada quando não tem nada é algo curioso.... Essa sua nova interpretação do enunciado provavelmente está errada. Desistiu das duas funções que estava escrevendo? Nem Fibonacci() nem primo(). E mudou o enunciado...

Está certo de que funciona? aqui para 8 retornou 2,3,5 e 13. E para 2 não retornou nada

Postei algo assim hoje por coincidência nesse mesmo forum Sugiro ler esse tópico Mas veja esse trecho de declaração E esse trecho de uso Como sempre sugiro aqui, recomendo não escrever um menu antes. Não perder tempo com essas coisas que não levam a nada. Concentre-se NOS DADOS e na representação dos livros, as estruturas, vetores, sei lá. Veja acima como é trivial usar Control-C e control-V e declarar uma meia dúzia de livros e testar todas as funções do programa. Só ao final escreva um menu. Faça com que a última função do menu seja ler a opção do usuário e retorne a tal opção no return da função menu(). Se possível leia o menu do disco. É trivial e aí você não perde tempo: Usa o editor de texto, o próprio IDE e edita o menu lá. Nunca vai dar erro. Ao ler valores mostre em seguida para ficar seguro do que está havendo. Depois você comenta ou apaga os comandos. Ler e gravar arquivos de texto --- streams --- é trivial em C