Pointers to string C

Ah, that should be if(*word == *s) you need to use the indirection operator. Also as hackss said, the flag = 0; must be outside the first for() loop.

Unrelated but probably replace scanf with fgets or use scanf with length specifier For example

 scanf("%99s",string1)

Things I can see wrong at first glance:

1. Your loop goes over MAX_STRING, it only needs to go over the length of s.
2. Your iteration should cover only the length of the string, but indexes start at 0 and not 1. for (i=0; i<=len; i++) is not correct.
3. You should also compare the contents of the pointer and not the pointers themselves. if(*word == *s)
4. The pointer advance logic is incorrect. Maybe treating the pointer as an array could simplify your logic.

Another unrelated point: A different algorithm is to hash the characters of string1 to a map, then check each character of the string2 and see if it is present in the map. If all characters are present then return 1 and when you encounter the first one that is not present then return 0. If you are only limited to using ASCII characters a hashing function is very easy. The longer your ASCII strings are the better the performance of the second approach.

Here is a one-liner solution, in keeping with Henry Spencer's Commandment 7 for C Programmers.

#include <string.h>

/*
 * Does l contain every character that appears in r?
 *
 * Note degenerate cases: true if r is an empty string, even if l is empty.
 */

int contains(const char *l, const char *r)
{
  return strspn(r, l) == strlen(r);
}

However, the problem statement is not about characters, but about letters. To solve the problem as literally given in the question, we must remove non-letters from the right string. For instance if r is the word error-prone, and l does not contain a hyphen, then the function returns 0, even if l contains every letter in r.

If we are allowed to modify the string r in place, then what we can do is replace every non-letter in the string with one of the letters that it does contain. (If it contains no letters, then we can just turn it into an empty string.)

void nuke_non_letters(char *r)
{
  static const char *alpha =
    "abcdefghijklmnopqrstuvwxyz"
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

  while (*r) {
    size_t letter_span = strspn(r, alpha);
    size_t non_letter_span = strcspn(r + letter_span, alpha);
    char replace = (letter_span != 0) ? *r : 0;
    memset(r + letter_span, replace, non_letter_span);
    r += letter_span + non_letter_span;
  }
}

This also brings up another flaw: letters can be upper and lower case. If the right string is A, and the left one contains only a lower-case a, then we have failure.

One way to fix it is to filter the characters of both strings through tolower or toupper.

A third problem is that a letter is more than just the 26 letters of the English alphabet. A modern program should work with wide characters and recognize all Unicode letters as such so that it works in any language.

By the time we deal with all that, we may well surpass the length of some of the other answers.

Extending the idea in Rajiv's answer, you might build the character map incrementally, as in containsLetters2() below.

The containsLetters1() function is a simple brute force implementation using the standard string functions. If there are N characters in the string (haystack) and M in the word (needle), it has a worst-case performance of O(N*M) when the characters of the word being looked for only appear at the very end of the searched string. The strchr(needle, needle[i]) >= &needle[i] test is an optimization if there are likely to be repeated characters in the needle; if there won't be any repeats, it is a pessimization (but it can be removed and the code still works fine).

The containsLetters2() function searches through the string (haystack) at most once and searches through the word (needle) at most once, for a worst case performance of O(N+M).

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

static int containsLetters1(char const *haystack, char const *needle)
{
    for (int i = 0; needle[i] != '\0'; i++)
    {
        if (strchr(needle, needle[i]) >= &needle[i] &&
            strchr(haystack, needle[i]) == 0)
            return 0;
    }
    return 1;
}

static int containsLetters2(char const *haystack, char const *needle)
{
    char map[256] = { 0 };
    size_t j = 0;

    for (int i = 0; needle[i] != '\0'; i++)
    {
        unsigned char c_needle = needle[i];
        if (map[c_needle] == 0)
        {
            /* We don't know whether needle[i] is in the haystack yet */
            unsigned char c_stack;
            do
            {
                c_stack = haystack[j++];
                if (c_stack == 0)
                    return 0;
                map[c_stack] = 1;
            } while (c_stack != c_needle);
        }
    }
    return 1;
}

int main(void)
{
    assert(containsLetters1("this_is_a_long_string","gagahats") == 1);
    assert(containsLetters1("this_is_a_longstring","gaz") == 0);
    assert(containsLetters1("hello","p")  == 0);

    assert(containsLetters2("this_is_a_long_string","gagahats") == 1);
    assert(containsLetters2("this_is_a_longstring","gaz") == 0);
    assert(containsLetters2("hello","p")  == 0);
}

Since you can see the entire scope of the testing, this is not anything like thoroughly tested, but I believe it should work fine, regardless of how many repeats there are in the needle.