}

int contains_value ( int valor , int * arr , int comprimento ) {
    retornando buscaX ( arr , length , value ) ! = - 1 ;
}

anular preencheComValorX ( int * vet , int tam , int x ) {
    para ( int i = 0 ; i < tam ; i ++ ) {
        vet [ i ] = x ;
    }
}

void preencheComValoresDigitados ( int * vet , int tam ) {
    para ( int i = 0 ; i < tam ; i ++ ) {
        printf ( "um número inteiro de inteiro:" ) ;
        scanf ( "% d" , & vet [ i ] ) ;
    }
}

void preencheComValoresDigitadosEntreAeB ( int * vet , int tam , int a , int b ) {
    para ( int i = 0 ; i < tam ; ) {
        entrada int ;
        printf ( "um número inteiro entre% de% d:" , a , b ) ;
        scanf ( "% d" , e de entrada ) ;

        if ( entrada > a && entrada < b || entrada < a && entrada > b ) {
            i ++;
        }
        mais {
            printf ( "O valor digitado é inválido. \ n " ) ;
        }
    }
}

int somaElementos ( int vet , int tam ) {
    int sum = 0 ;

    para ( int i = 0 ; i < tam ; i ++ ) {
        soma + = vet [ i ] ;
    }
    soma de retorno ;
}

void somaVetores ( int vetA , int vetB , int vetC , int tam ) {
    para ( int i = 0 ; i < tam ; i ++ ) {
        vetC [ i ] = vetA [ i ] + vetB [ i ] ;
    }
}

void multiplicaVetores ( int vetA [ ] , int vetB , int vetC , int tam ) {
    para ( int i = 0 ; i < tam ; i ++ ) {
        vetC [ i ] = vetA [ i ] * vetB [ i ] ;
    }
}

int intersecao ( int veta , int vetB , int VETC , int tama , int Tamb , int TAMC ) {
    int indexC = 0 ;
    para ( int a = 0 ; a < tamA ; a ++ ) {
        if (!contains_value(vetA[a], vetC, indexC)) {
            for (int b = 0; b < tamB; b++) {
                if (vetA[a] == vetB[b]) {
                    vetC[indexC++] = vetA[a];
                    break;
                }
            }
        }
    }
    return indexC;
}

int uniao(int vetA, int vetB, int vetC, int tamA, int tamB, int tamC) {
    int indexC = 0;
    for (int i = 0; i < tamA; i++) {
        if (!contains_value(vetA[i], vetC, indexC)) {
            vetC[indexC++] = vetA[i];
        }
    }
    for (int i = 0; i < tamB; i++) {
        if (!contains_value(vetB[i], vetC, indexC)) {
            vetC[indexC++] = vetB[i];
        }
    }
    return indexC;
}

int diferencaEntreAeB(int vetA, int vetB, int vetC, int tamA, int tamB, int tamC) {
    int indexC = 0;
    for (int i = 0; i < tamA; i++) {
        if (!contains_value(vetA[i], vetC, indexC) && !contains_value(vetA[i], vetB, tamB))
            vetC[indexC++] = vetA[i];
    }
    for (int i = 0; i < tamB; i++) {
        if (!contains_value(vetB[i], vetC, indexC) && !contains_value(vetB[i], vetA, tamA))
            vetC[indexC++] = vetB[i];
    }
    return indexC;
}

void multiplicaPorEscalar(int vet, int tam, int esc) {
    for (int i = 0; i < tam; i++) {
        vet[i] *= esc;
    }
}

int buscaMaiorElemento(int vet, int tam) {
    int greatest = vet[0];
    int greatestsIndex = 0;

    for (int i = 1; i < tam; i++) {
        if (vet[i] > greatest) {
            greatest = vet[i];
            greatestsIndex = i;
        }
    }
    return greatestsIndex;
}

int buscaMenorElemento(int vet, int tam) {
    int smallest = vet[0];
    int smallestsIndex = 0;

    for (int i = 1; i < tam; i++) {
        if (vet[i] < smallest) {
            smallest = vet[i];
            smallestsIndex = i;
        }
    }
    return smallestsIndex;
}

int buscaMaiorElementoEntreAeB(int vet, int tam, int a, int b) {
    int interval_length = b - a + 1;
    if (a < 0 || b < 0 || interval_length > tam || interval_length < 0)
        return -1;

    return buscaMaiorElemento(&vet[a], interval_length) + a;
}

int buscaMenorElementoEntreAeB(int vet, int tam, int a, int b) {
    int interval_length = b - a + 1;
    if (a < 0 || b < 0 || interval_length > tam || interval_length < 0)
        return -1;

    return buscaMenorElemento(&vet[a], interval_length) + a;
}

int buscaXEntreAeB(int vet, int tam, int x, int a, int b) {
    int interval_length = b - a + 1;
    if (a < 0 || b < 0 || interval_length > tam || interval_length < 0)
        return -1;

    int index = buscaX(&vet[a], interval_length, x);
    if (index != -1)
        return index + a;
    else
        return -1;
}

void troca(int vet, int a, int b) {
    vet[a] += vet[b];
    vet[b] = vet[a]-vet[b];
    vet[a] =ve[a]-vet[b];
}

void copiaValoresDeAparaB(int vetA, int tamA, int vetB, int tamB) {
    int count = (tamA < tamB) ? tamA : tamB;
    for (int i = 0; i < count; i++) {
        vetB[i] = vetA[i];
    }
}

void insereX(int vet, int tam, int tamMax, int x, int pos) {
    if (tamMax <= tam)
        return;

    for (int i = tam; i > pos; i--) {
        troca(vet, i, i - 1);
    }
    vet[pos] = x;
}

void insereXEmVetorOrdenado(int vet, int tam, int tamMax, int x) {
    int index = 0;
    while (index < tam) {
        if (vet[index] > x) {
            insereX(vet, tam, tamMax, x, index);
            return;
        }
        index++;
    }
    insereX(vet, tam, tamMax, x, tam);
}

void removeElemDaPosicao(int vet, int pos,int tam) {
  for(int i=pos;i<tam-1;i++){
     troca(Vet,i,i+ 1)
}

void transpoe(int vet, int tam) {
    for (int i = 0; i < tam / 2; i++) {
        troca(vet, i, (tam - 1) - i);
    }
}

int ordenado(int vet, int tam) {
    if (tam == 1)
        return 1;

    for (int i = 0; i < tam - 1; i++) {
        if (vet[i] > vet[i + 1])
            return 0;
    }
    return 1;
}