Vector get only no repeating elements - c++

Question

I want to write a function which will return amount of no repeating digits. So far I have written a function which is iterating through char and collecting to vector all number, but the problem comes when I have to get from vector only non repeating digits.
My code:
int norepeat(char *word){
int i = 0;
int size = 0;
vector<int> tab;
while (word[i] != '\0'){
if (word[i] >= '0' && word[i] <= '9') {
int num = word[i];
tab.push_back(num);
sort(tab.begin(),tab.end());
unique(tab.begin(),tab.end());
size = tab.size();
}
++i;
}
return size;
}
EDIT:
Several examples how should it work:
norepeat("de32ge2sa3ds1") => 1
norepeat("defegtdsg") => 0
norepeat("12341234") => 0
norepeat("1yle2le49") => 4

Answer 1

Create a map of digits -> digit count.
Then iterate through the map and count the number of digits that have a count of 1.
int norepeat(char *word){
int i = 0;
std::map<char, int> m;
while (word[i] != '\0'){
if ( isdigit(word[i] )
m[word[i]]++;
++i;
}
int count = 0;
for ( auto& p : m )
{
if ( p.second == 1 )
++count;
}
return count;
}
When working with a compiler that does not support C++11, the for loop can be changed to:
std::map<char, int>::iterator iter = m.begin();
std::map<char, int>::iterator end = m.end();
for ( ; iter != end; ++iter )
{
if ( iter->second == 1 )
++count;
}

Answer 2

Nice thing of C++ is the ability to mix Plain-Old-Data pointers and libc functions and algorithms from the C++ standard template library: (note: uses some C++11 features)
#include <vector>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <vector>
#include <ctype.h>
using namespace std;
size_t norepeat(const char* word) {
vector<char> digits;
vector<char>::iterator uniq;
// Filter the digits
copy_if(word, word+strlen(word), back_inserter(digits), ::isdigit);
// get the unique ones
sort(digits.begin(), digits.end());
uniq = unique(digits.begin(), digits.end());
// return amount
size_t uniques = std::distance(digits.begin(), uniq);
size_t duplicates = std::distance(uniq, digits.end());
return uniques - duplicates;
}
int main( void ) {
cout << norepeat("hello 123 world 124") << endl;
cout << norepeat("hello world") << endl;
return 0;
}
Outputs:
2
0
EDIT
Just for laughs: wrote a counting-output-iterator-class; it counts occurrences of values copied into it into a map of value -> unsigned int. Combined with the count_if algorithm (with C++ lambdas) the norepeat function itself is only three statements: a variable declaration, filtering the digits and return the result of the counting:
#include <map>
#include <vector>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <ctype.h>
using namespace std;
template <typename T>
struct counter : public iterator<output_iterator_tag, T> {
typedef map<T, unsigned int> counter_type;
counter(counter_type* ptr) : mapptr( ptr ) {}
// decorate with dereference and assignment
counter<T>& operator=( const T& t ) {
mapptr->operator[]( t )++;
return *this;
}
counter<T>& operator++() { return *this; }
counter<T>& operator*() { return *this; }
counter_type* mapptr;
};
size_t norepeat(const char* word) {
typename counter<char>::counter_type countert;
// Filter the digits
copy_if(word, word+strlen(word), counter<char>(&countert), ::isdigit);
// Count the ones that have a value of one
return count_if(countert.begin(), countert.end(),
[](const counter<char>::counter_type::value_type& kv) {
return kv.second==1; } );
}
int main( void ) {
cout << norepeat("hello 123 world 124") << endl;
cout << norepeat("hello world") << endl;
return 0;
}

Answer 3

Since my last answer was based on a misreading of the question, How about this?
int norepeat(const char *word){
int i = 0;
int size = 0;
int arr[10] = {0}; // there are only 10 unique possibilities,
// so we'll mark them when found
while (word[i] != '\0')
{
if (std::isdigit(word[i]))
{
int num = word[i] - '0'; // get numeric value of digit to use as index
arr[num]++; // count the number of times we've seen this digit
}
++i;
}
for (i = 0; i < 10; i++)
{
if (arr[i] == 1) // count all element seen only once
{
size++;
}
}
return size;
}
This gag is really limited because it will only work for decimal digits, but with a slight modification it could do upper or lower case characters. With a std::map... The possibilities are limitless! I'll add that for completeness in a second.
EDIT
The map version.
int norepeat(const char *word){
int i = 0;
int size = 0;
std::map<char, int> counts;
while (word[i] != '\0')
{
if (std::isdigit(word[i])) // could use any or no filtering logic here
{
counts[word[i]]++;
}
++i;
}
for (auto &count: counts)
{
if (count.second == 1) // count all element seen only once
{
size++;
}
}
return size;
}

Answer 4

int norepeat(char *word){
int i = 0;
int size = 0;
vector<int> tab;
while (word[i] != '\0'){
if (word[i] >= '0' && word[i] <= '9') {
int num = word[i];
tab.push_back(num);
}
++i;
}
size = std::distance( unique(tab.begin(),tab.end()), tab.end() );
return size;
}