For a small array such as your it's no use trying to find another algorithm, and if the values are not in a specific pattern a simple loop is the only way to do it anyway.

However, if you have a very large array (we're talking several million entries), then you can split the work into threads. Each separate thread handles a smaller portion of the whole data set.

It looks like you're trying to do too much in the PlaceShips function. This is a matter of style, but I might first write a PlaceOneShipHorizontally() and a PlaceOneShipVertically() function.

For example,

void PlaceOneShipHorizontally(int board[], int ox, int oy, int character, int size) {
  for (int x = ox; x < (size+ox); x++) {
    board[x][oy] = character;
  }
}

Then, edit the PlaceShips() function to use the above functions once you determine what the user wants to do.

#include <stdio.h>
#include <stdlib.h>

#define DATA_SIZE 6

int inputNumberWithRangeCheck(const char *msg, const char *errMsg, int rangeStart, int rangeEnd){
    char inputLine[256];
    int n;

    for(;;){
        printf("%s", msg);
        fgets(inputLine, sizeof(inputLine), stdin);
        if(sscanf(inputLine, "%d", &n) != 1 || n < rangeStart || n > rangeEnd)
            fprintf(stderr, "%s", errMsg);
        else
            return n;
    }
}

int inputNumber(void){
    return inputNumberWithRangeCheck(
        "\nPlease enter the winning ticket number!(#'s must be between 1-49): ",
        "Invalid Input.\n",
        1,49);
}

int *inputArray(int *array, size_t size){
    int i;
    for(i=0;i<size;++i){
        printf("\nInput for No.%d\n", i+1);
        array[i] = inputNumber();
    }
    return array;
}

int **duplicateCheck(int *array, size_t size){
    int **check, count;
    int i, j;

    check = malloc(size*sizeof(int*));
    if(!check){
        perror("memory allocate\n");
        exit(-1);
    }
    //There is no need to sort the case of a small amount of data
    //(Cost of this loop because about bubble sort)
    for(count=i=0;i<size -1;++i){
        for(j=i+1;j<size;++j){
            if(array[i] == array[j]){
                check[count++] = &array[i];
                break;
            }
        }
    }
    check[count] = NULL;
    if(count)
        return check;
    else {
        free(check);
        return NULL;
    }
}

int main(void){
    int winningNumbers[DATA_SIZE];
    int **duplication;
    int i, j;

    inputArray(winningNumbers, DATA_SIZE);

    while(NULL!=(duplication = duplicateCheck(winningNumbers, DATA_SIZE))){
        for(i=0;i<DATA_SIZE;++i){
            if(duplication[i]){
                printf("\nyour input numbers : ");
                for(j=0;j<DATA_SIZE;++j)
                    printf("%d ", winningNumbers[j]);
                fprintf(stderr, "\nThere is duplicate. Please re-enter.\n");
                *duplication[i] = inputNumber();
            } else
                break;
        }
        free(duplication);
    }
    for(i=0;i<DATA_SIZE;++i)
        printf("%d ", winningNumbers[i]);
    printf("\n");
    return 0;
}

btw, you have a memory corruption vulnerability in your code. in init_array you are using strcpy(array.name, array);, when name is only 20 bytes long. and name is user controled. you should use strncpy(array.name, array, sizeof(array.name); instead.

As others have said, arrays allocated like that are static, and can not be resized. You have to use pointers (allocating the array with malloc or calloc) to have a resizable array, and then you can use realloc. You must use free to get rid of it (else you'll leak memory). In C99, your array size can be calculated at runtime when its allocated (in C89, its size had to be calculated at compile time), but can't be changed after allocation. In C++, you should use std::vector. I suspect Objective-C has something like C++'s vector.

But if you want to copy data between one array and another in C, use memcpy:

/* void *memcpy(void *dest, const void *src, size_t n)
   note that the arrays must not overlap; use memmove if they do */
memcpy(&struct1, &struct2, sizeof(struct1));

That'll only copy the first ten elements, of course, since struct1 is only ten elements long. You could copy the last ten (for example) by changing &struct2 to struct2+10 or &(struct2[10]). In C, of course, not running off the end of the array is your responsibility: memcpy does not check.

You can also you the obvious for loop, but memcpy will often be faster (and should never be slower). This is because the compiler can take advantage of every trick it knows (e.g., it may know how to copy your data 16 bytes at a time, even if each element is only 1 byte wide)

First advice is to try to debug your program if it does not work.

for (i = 0; i<80; i++) {
        if (output[i] == replace[i])
            output[i] = toBeReplacedBy[i];
    }

There are two problems in this loop.

The first is that are iterating until i is 80. Let's look what happens when i becomes 3. output[3] in case of abcdefabc is d, but what is replace[3]? Your replacement array had only 3 letters, so you have to go back in the replacement array once you finish with one occurrence of it in the original string.

The second is that you check letter by letter.

Say you original array, which you named output somehow was abkdefabc, first three letters do not match your replacement string, but you will check the first two letters they will match with the replacement's first two letters and you will incorrectly change them.

So you need to first check that the whole replacement string is there and only then replace.