Checking if all possible combinations of any two array elements in an array contains 0-9 atleast once

static int winningLotteryTicket(String[] tickets,int n)
 // tickets = array of all strings

 {

Please don't put comments in between a function declaration and the function body (which starts with {).

The standard way to write this in Java is

// tickets = array of all strings
static int winningLotteryTicket(String[] tickets, int n) {

This is shorter and easier to read.

Some people prefer to put the { on a separate line. That's not standard in Java. But if you do do that, please put the { on the line immediately after the function declaration. Put comments either before the function declaration or inside the function body.

In Java, unlike C, you do not need to pass the length of the array separately. Instead of n, you can just use tickets.length. So

    for (int i = 0; i < tickets.length; i++) {
        for (int j = i + 1; j < tickets.length; j++) {

This also has the advantage of being clearer than n. I can immediately see that it is the length of the array that is the limitation. And this avoids bugs where n is passed as something other than the length of the array.

     if(i!=j)

This line is unnecessary. The way that the inner for loop is declared, j is always greater than i.

         b=check.contains(r);

This is inefficient. It does a linear time search for each digit. We can do a single linear time search that covers all the digits. Consider

public static final int RADIX = 10;

static boolean hasAllDigits(String ticketPair) {
    boolean[] found = new boolean[RADIX];
    for (char digit : ticketPair.toCharArray()) {
        found[digit - '0'] = true;
    }

    for (boolean digitFound : found) {
        if (!digitFound) {
            return false;
        }
    }

    return true;
}

So the original method could be just

static int winningLotteryTicket(String[] tickets) {
    int count = 0;

    // the i and j loop are to create all possible combinations
    for (int i = 0; i < tickets.length; i++) {
        for (int j = i + 1; j < tickets.length; j++) {
            if (hasAllDigits(tickets[i] + tickets[j])) {
                count++;
            }
        }
    }

    return count;
}

If this still isn't fast enough, consider storing the digits found in each string. E.g. instead of "129300455" store "0123459". Then you can just use merge logic to check if two strings contain all the digits.

Here's a few points to ponder:

For these online challenges, I've found that in many cases, processing the data as you read it from the stream, is more efficient. To that end I suggest passing the scanner to your function instead of a string array. This gives the added advantage of setting the scanner to read a text file while debugging, then set it back to standard in to submit.

By reducing each line to its unique digits you gain several advantages.

• Any set that has 10 items(all 10 digits) will match with every other set.
• Any pair that doesn't have a total of 10 or more items will never match.
• When checking a pair each one will not be more than 9 items.

All this combined might look something like this:

public static int FindPairs(Scanner in) {
    int retVal = 0;
    int n = in.nextInt();
    int goodSets = 0;
    List<List<Character>> data = new ArrayList<>();
    for (int i = 0; i < n; i++) {
        //reduce each string to its unique digits.
        List<Character> temp = in.next()
                .chars()
                .distinct()
                .mapToObj(x -> (char) x)
                .collect(Collectors.toList());
        //process complete sets.  add the rest. 
        if (temp.size() == 10) {
            goodSets++;
            retVal += n - goodSets;
        } else {
            data.add(temp);
        }
    }
    for (int i = 0; i < data.size(); i++) {
        for (int j = i + 1; j < data.size(); j++) {
            //check that the total count and the count of the merged unique digits is valid.
            if ((data.get(i).size() + data.get(j).size() >= 10) &&
                    Stream.of(data.get(i), data.get(j))
                            .flatMap(x -> x.stream())
                            .distinct()
                            .count() == 10) {
                retVal++;
            }
        }
    }
    return retVal;
}