[SOLVED] C programming help

Question

Hello everyone,
Hopefully this is the appropiate spot to post this, I need help with a C programming HW problem. I need to create a program that that finds how many repeated characters in a string. For example the word "missing" has 2 repeating characters and the word "hisssss" has 1 repeating character. In my code posted below, the word "missing" returns 4 repeated characters so I assume my approach was wrong. I also have another similar problem that I need to do, but if i can figure this one out, I can do the next one. If anyone can point me in the right direction I'll greatly appreciate it.
Thanks.
Also, I need to use the function prototype I used in the code.
#include <stdio.h>
#include <string.h>
#define MAX 64
int repeat(char *ptr) {
int length, i, j, count = 0;
char comp[MAX];
length = strlen(ptr);
for (i = 0; i < length; i++)
for (j = 0; j < length; j++) {
if (i != j && ptr[i] == ptr[j])
count++;
} //for
return count;
} //repeat
int main () {
char word[MAX];
char character = ' ';
int total;
printf("word: ");
scanf("%s", word);
total = repeat(word);
printf ("repeated letters: %d", total);
} //main
Last edited by NYFinest (2011-07-08 02:35:10)

Answer 1

tavianator wrote:
listdata wrote:True, but I like my approach better because: (1) it works for arbitrarily dense sets of symbols, and (2) does not needlessly waste space. The advantage of your approach is that you use almost no CPU cycles to calculate the UUID. So for very large input strings, it will be very, very fast (although at the cost of more memory use depending on set density). I was just noting how your approach used more memory, which is not an insignificant point.
1) What do you mean by dense?
2) Both use O(1) space, mine just happens to use slightly more.  For unicode characters obviously my way would be a huge waste, but you could use a hash table or trie or something to keep the space proportional to the number of distinct characters found.
Also, the first U in UUID stands for "universal," which is certainly not true of any of the hashing methods listed here.  UID would make sense though.
This discussion is getting a little too hairy for me, so just to clear up any misunderstandings, here's my (slightly modified) full solution:
* Return unique number for a given character, based on the history buffer. If
* not found in the history, then add the character to the history and return
* its index.
int get_idx(char *history, char *c) {
int i;
for (i = 0; i < MAX; i++) {
if (history[i] == *c)
return i;
if (history[i] == '\0') {
history[i] = *c;
return i;
* History buffer is full, which should never happen as long as both the
* string where *c comes from and the buffer is both MAX big.
assert(0);
* Only use 1 for-loop, and only call get_idx() once per iteration. Drawback:
* get_idx() modifies the history[] array!
int count_reps(char *str) {
int i, idx, reps;
char history[MAX] = {'\0'};
int rep_chars[MAX] = {0};
for (i = 0, reps = 0; str[i] != '\0'; i++) {
idx = get_idx(history, &str[i]);
rep_chars[idx]++;
if (rep_chars[idx] == 2)
reps++;
return reps;
The get_idx() function used to just return 1 or -1 depending on whether the character was found in the hash already, but now it just modifies the history buffer to cut down on the logic. It's still far less impressive than Cdh's solution, though...
Regarding point (1): My approach requires another copy of the string; it's difference from your approach is that it always only requires the same memory space as the original string. Your approach's memory use grows with the number of symbols/characters in the string type's set. That's what I meant by "arbitrary density"...
Point (2): As you can probably see now, my solution can be very slow and certainly is not O(n)...