Test whether all characters of the first string also appear in the second

Question

I’m trying to do that function with the help of the functions strcmp() and strncmp() and I’m not having much success.

Let’s say I have the string char s[] = "abc" and another string char v[] = "cdeabf" , the output would give 0 (true value) because the characters [a, b and c] belong to v. Otherwise it would give -1 (false value).

If there is a predefined function that helps me, what would it be? And if you could do this function without the help of predefined functions, how would you do it?

Answer 1

As referred to by @mgibsonbr, the C convention is 0 for false, not zero for true.

Using this convention, I would simply:

...
return (strspn(s,aceitar) == strlen(s));

Edit: Summary explanation: according to the manual, chapter of functions on strings:

$ man string.h 
....
size_t strspn(const char *s, const char *accept);
   Calculate the length of the starting segment in the string s that consists 
   entirely of bytes in accept.

we have a function strspn (See details here) that can help:

if all the characters of the initial string are in the list of characters to accept, the function strspn(s,aceitar) return string length s (=all).

For our question, just compare the number of accepted characters with strlen(s)

---

Thanks to @mgibsonbr for helping with the explanation

Answer 2

There’s nothing ready but(see below) it is not difficult to create a function that does this. If I understood what you want, it would be this:

#include <stdio.h>

int contem(char s1[], char s2[]) {
    for (int i = 0; s2[i]; i++) {
        int j;
        for (j = 0; s1[j]; j++) if(s2[i] == s1[j]) break;
        if (s1[j] == '\0') return 0;
    }
    return 1;
}

int main() {
    char s[] = "abc";
    char v[] = "cdeabf";
     if (contem(v, s)) printf("'%s' contém todos os caracteres presentes em '%s'", v, s);
     else printf("'%s' não contém todos os caracteres presentes em '%s'", v, s);
}

Behold working in the ideone. And in the repl it.. Also put on the Github for future reference.

Here is the solution for those who want to do it in the hand. But there is a way to achieve the same result according to Jjoao’s answer. The function strspn returns the size of string being compared if all characters are present in the other string. So it is easy to identify what is asked in the question. Using ready function would look like this:

#include <stdio.h>
#include <string.h>

int main() {
    char s[] = "abc";
    char v[] = "cdeabf";
    printf("'%s' %scontém todos os caracteres presentes em '%s'", v, (strspn(s, v) == strlen(s)) ? "" : "não ", s);
}

Behold working in the ideone. And in the repl it.. Also put on the Github for future reference.

Answer 3

How to compare characters is easy (just use the equal operator - ==), my suggestion is to simply scroll through each character of one and the other string to see if they are equal:

// No cabeçalho:

#define VERDADEIRO 0
#define FALSO -1

// Na sua função:

int ts = strlen(s); // Tamanho da primeira string
int tv = strlen(v): // Tamanho da segunda string
for ( int i = 0 ; i < ts ; i++ ) { // Para cada caractere da primeira string
    char cs = ts[i]; // Esse caractere precisa aparecer em v
    int apareceu = FALSO; // No começo, não apareceu (pois ainda não começamos a buscar)
    for ( int t = 0 ; t < tv ; t++ ) { // Para cada caractere da segunda string
        char cv = tv[t]; // Esse caractere será comparado a cs
        if ( cs == cv ) { // Apareceu!
            apareceu = VERDADEIRO;
            break; // Para de testar a segunda string, pois já achou o caractere
        }
    }
    if ( apareceu == FALSO ) // Se continua FALSO, é porque não apareceu
        return FALSO;
}
return VERDADEIRO; // Se passou por todos os caracteres da primeira string e nenhum
                   // deles retornou FALSO, então é porque todos aparecem na segunda

Obs.: I defined VERDADEIRO as 0 and FALSO as -1, as set out in the question, but this is a rather unusual way of representing these values; one usually uses 0 as false and anything other than 0 as true. Unless you have a good reason to deviate from this convention, I suggest you do not.

Answer 4

Updating

Follow another alternative way without use the function strchr:

int testarString(char *fonte, char encontrar[]){
    int i, ret = 0, tamanho = strlen(encontrar);
    while (*fonte){
        for (i = 0; i < tamanho; i++)
            ret += ((*fonte == encontrar[i]) ? 1: 0);
        *fonte++;
    }
    return ((ret == tamanho) ? 0: 1);
}

Functional example in Ideone.

---

An alternative that can be used is the function strchr, this function returns the pointer of the first occurrence of a character, it receives two parameters, the first is the string to be covered, and the second, the character to be found.

The idea is to go through the characters of string to be found, in the case of the variable s, and check if there’s a match on string to be checked, in this case, the variable v.

This can be implemented as follows:

int testarString(char fonte[], char encontrar[]){
    int i = 0;
    while (i <= strlen(encontrar)){
        if (strchr(fonte, encontrar[i]) == 0)
            return 1;
        i++;
    }
    return 0;
}

Functional example in Ideone.

Answer 5

A more efficient solution to this problem involves sorting the strings before starting to compare them. In pseudo code;

ss = sort(s) // "acb" vira "abc"
sv = sort(v) // "cdeabf" vira "abcdef"

//invariante: Os caracteres de ss[0,i) estão contidos em sv[0,j)
i = j = 0
while i < len(ss) do
    while j < len(sv) and ss[i] != sv[j] do
        j += 1
    done
    if j < len(sv) then
        i += 1  // achei um par para ss[i]
    else
        return NAO // ss[i] não tem par em v
    end
done

return SIM

Most other answers feature quadratic algorithms, which take a time proportional to the size of one string mumltyped by the size of the other. The algorithm I presented consists of a sort step that takes time O(n log n) (or O(n) if you use a life Radix-Sort) followed by a comparison step O(n) that only passes the strings.