删除数组中重复数字的问题

Question

我有一个函数可以对数组元素进行排序，然后根据用户输入的顺序找到最小的数字。它在很多情况下都有效，但我遇到了包含重复数字的数组的问题。

我的功能：

int lowestPrice(int array[], int size, int order){


    int tempArray[size];

    for (size_t i = 0; i < size; i++)
        tempArray[i] = array[i];

    for (size_t i = 0; i < size; i++)

        for (size_t j = i + 1; j < size; j++)

            if (tempArray[j] < tempArray[i]) {
                int tmp = tempArray[i];
                tempArray[i] = tempArray[j];
                tempArray[j] = tmp;
            }

    int j = 0;


    for (size_t i = 0; i < size - 1; i++){

        if(tempArray[i] != tempArray[i+1])
        {
            tempArray[j] = tempArray[i];
            j++;
        } tempArray[j] = tempArray[i+1];


    }


    if(order > size  || order < 0){
        return -1;
    }
    else{
        order--;
        return tempArray[order];
    }
}

main和oracle函数：

void oracle(int no, int array[], int size, int order,int expected, int actual){
    printf("Test %d:\n\t\tPrices: {",no);
    for (int i = 0; i < size; i++) {
        printf(" %d ",array[i]);
    }
    printf("}\n\t\tOrder: %d",order);
    printf("\n\t\tExpected result: %d",expected);
    printf("\n\t\tYour function result: %d",actual);
    printf("\n\t\tStatus: %s\n",expected==actual?"passed":"failed");
}

int main(){
    // oracles
    int tests = 0;
    int testA1[] = { 25000, 20000, 29499, 10000, 20000, 29000, 25000, 20000 , 25000 , 10000 };
    int order1 = 3;
    int res1 = 25000;
    int resA = lowestPrice(testA1,sizeof(testA1)/sizeof(int),order1);
    oracle(1,testA1,sizeof(testA1)/sizeof(int),order1,res1,resA);
    if(res1==resA) tests++;

    int testA2[] = { 25000, 20000, 29499, 10000, 20000, 29000, 25000, 20000 , 25000 , 10000 };
    int order2 = 5;
    int res2 = 29499;
    resA = lowestPrice(testA2,sizeof(testA2)/sizeof(int),order2);
    oracle(2,testA2,sizeof(testA2)/sizeof(int),order2,res2,resA);
    if(res2==resA) tests++;

    int testA3[] = { 25000, 20000, 29499, 10000, 20000, 29000, 25000, 20000 , 25000 , 10000 };
    int order3 = 4;
    int res3 = 29000;
    resA = lowestPrice(testA3,sizeof(testA3)/sizeof(int),order3);
    oracle(3,testA3,sizeof(testA3)/sizeof(int),order3,res3,resA);
    if(res3==resA) tests++;

    int testA4[] = { 25000, 20000, 29499, 10000, 20000, 29000, 25000, 20000 , 25000 , 10000 };
    int order4 = 7;
    int res4 = -1;
    resA = lowestPrice(testA4,sizeof(testA4)/sizeof(int),order4);
    oracle(4,testA4,sizeof(testA4)/sizeof(int),order4,res4,resA);
    if(res4==resA) tests++;

    int testA5[] = {25000, 20000};
    int order5 = 2;
    int res5 = 25000;
    resA = lowestPrice(testA5,sizeof(testA5)/sizeof(int),order5);
    oracle(5,testA5,sizeof(testA5)/sizeof(int),order5,res5,resA);
    if(res5==resA) tests++;

    int testA6[] = {25000, 20000};
    int order6 = 3;
    int res6 = -1;
    resA = lowestPrice(testA6,sizeof(testA6)/sizeof(int),order6);
    oracle(6,testA6,sizeof(testA6)/sizeof(int),order6,res6,resA);
    if(res6==resA) tests++;

    int testA7[] = {20000};
    int order7 = 1;
    int res7 = 20000;
    resA = lowestPrice(testA7,sizeof(testA7)/sizeof(int),order7);
    oracle(7,testA7,sizeof(testA7)/sizeof(int),order7,res7,resA);
    if(res7==resA) tests++;

    int testA8[] = {10000, 20000, 25000, 29499};
    int order8 = 2;
    int res8 = 20000;
    resA = lowestPrice(testA8,sizeof(testA8)/sizeof(int),order8);
    oracle(8,testA8,sizeof(testA8)/sizeof(int),order8,res8,resA);
    if(res8==resA) tests++;

    int testA9[] = {10000, 20000, 25000, 29499};
    int order9 = -5;
    int res9 = -1;
    resA = lowestPrice(testA9,sizeof(testA9)/sizeof(int),order9);
    oracle(9,testA9,sizeof(testA9)/sizeof(int),order9,res9,resA);
    if(res9==resA) tests++;
    if(tests!=9)
        printf("\nYour implementation failed %d test(s).\n\n",(9-tests));
    else printf("Your implementation passed all tests. Excellent work.\n\n");
    return 0;
}

在测试3中：

int testA3[] = { 25000, 20000, 29499, 10000, 20000, 29000, 25000, 20000 , 25000 , 10000 };
int order3 = 4;
int res3 = 29000;
resA = lowestPrice(testA3,sizeof(testA3)/sizeof(int),order3);
oracle(3,testA3,sizeof(testA3)/sizeof(int),order3,res3,resA);
if(res3==resA) tests++;

输出是：

Prices: { 25000  20000  29499  10000  20000  29000  25000  20000  25000  10000 }
                Order: 4
                Expected result: 29000
                Your function result: 29000
                Status: passed

但在 test4 中：

 int testA4[] = { 25000, 20000, 29499, 10000, 20000, 29000, 25000, 20000 , 25000 , 10000 };
    int order4 = 7;
    int res4 = -1;
    resA = lowestPrice(testA4,sizeof(testA4)/sizeof(int),order4);
    oracle(4,testA4,sizeof(testA4)/sizeof(int),order4,res4,resA);
    if(res4==resA) tests++;

输出是：

  Prices: { 25000  20000  29499  10000  20000  29000  25000  20000  25000  10000 }
                Order: 7
                Expected result: -1
                Your function result: 25000
                Status: failed

我试图说明问题，但我不知道为什么它不起作用。

Answer 1

看起来问题要求您忽略重复项。也就是说，在失败的测试用例中，7（订单）大于您拥有的唯一价格的数量，因此预期答案是 -1。 删除重复是一个标准问题，你可以在这里看到一个方法： https://www.geeksforgeeks.org/remove-duplicates-sorted-array/