ps2

#include <stdio.h>
#include <math.h>

/**Úloha 1: Lift a Car**/
float lift_a_car(const int stick_length, const int human_weight, const int car_weight){
    float posun = (float) stick_length * (float) human_weight / ((float) human_weight + (float) car_weight);//vzorec
    posun = round(posun*100)/100;//zaokruhlujem na 2 des miesta
    return  posun;//vrátim hodnotu radius nie je to void
}

///* TEN ISTÝ PRINCÍP AKO V PRVEJ ULOHE *//

/**Úloha 2: Unit Price for Toilet Paper**/
float unit_price(const float pack_prize,const int rolls_count,const int pieces_count){
    float one_kej = (float) pack_prize / ((float) rolls_count * (float)pieces_count) * 100;
    one_kej = round(one_kej*100)/100; //funkcia round zaokruhli číslo na 2 desatinne ale treba spravit m.o
    return one_kej;
}
/**Úloha 3: Collatz Conjecture**/
int collatz(const int number){
    int final_number; //vytvoríme novú premennú typu int
    final_number = number; //do premennej priradíme číslo kt. zadáme pri volani funkcie
    int operacie = 1;
    while (final_number > 1){ //dokial číslo bude väčšie ako jedna tak rob -->
        if (final_number % 2 == 0) { //ak po celociselnom delení bude zvysok nula -->
            final_number = final_number / 2; //číslo videl 2jkou
            operacie += 1; //vypíš číslo
        } else { //for odd numbers // ak čislo nebude mať zvyšok tak -->
            final_number = final_number * 3 + 1; //číslo vynásob 3 a pridaj 1
            operacie += 1; //vypíš číslo --- ^
        }
    }
    return operacie;
}

/**Úloha 4: Find Opposite Number**/
int opposite_number(const int n, const int number){
    int sused = n/2+number;
    if (sused<n){
        return sused;
    }else if(sused>n){
        sused=sused-n;
        return sused;
    }else{
        sused=0;
        return sused;
    } /**vzorec z geometrie ak beriem kruh ako taký a čísla na ňom takže k susedovi sa dostanem
 * cez polovicu tzv. leteckou čiarou takže potrebujem prejsť vždy polovicu, musim
 * byt v kruhu zorientovaný musim vediet do kt strany potrebujem rotovať**/


}

/**Úloha 5: Count Numbers in Array**/
void counter(const int input_array[], const int array_size, int result_array[2]){
    int delitelne = 0; //vytvorim premennu typu int pre delitelne pozicie
    int nedelitelne = 0; //vytvorim premennu typu int pre nedelitelne pozicie
    for (int index = 0 ; index < array_size ; index ++){ //cyklus bude prechádzať čísla v poli
        if (index % 2 == 0){ //ak bude párne tak -->
            delitelne += input_array[index]; //pridaj čislo do delitelne
        } else{ //inak
            nedelitelne += input_array[index]; //pridaj číslo do nedelitelných
        }
        //po ukončeni cyklu pridaj výsledne čísla do pola kt. má len dve miesta
        result_array[0] = delitelne;
        result_array[1] = nedelitelne;
    }
}

/**Úloha 7.1: Min**/
int array_min(const int input_array[],const int array_size){ //funkcia min a max funguju na rovnakom principe otočim <>
    int minimal = input_array[0];// vytvorím premennu typu int a vložim do nej prvé číslo z pola
    if(input_array==NULL){
        return -1;
    }
    for (int i = 0; i < array_size; ++i) {//v cykle toto číslo porovnávam z ostanými číslami v poli
        if (input_array[i] < minimal){//ak by číslo v poli bolo menšie ako moje tak sa to dané čislo
            minimal = input_array[i];//priradí do premmenej minimal
        }

    }
    return minimal;//na konci musim vrátit hodnotu kedze to nie je void

}

//*TO ISTE AKO HLADANIE MINIMA LEN OPAČNE ZNAMIENKO <

/**Úloha 7.2: Max**/
int array_max(const int input_array[],const int array_size){
    int maximal = input_array[0];
    if(input_array==NULL){
        return -1;
    }
    for (int i = 0; i < array_size; ++i) {
            if (input_array[i] > maximal) {
                maximal = input_array[i];
            }

        }

    return maximal;
}

/**Úloha 8: Special Counter **/
unsigned long special_counter(const int input_aray[],const int array_size){ //funkcia požaduje 2 parametre
    int parne = 0; //vytvoril som premenu <-- kde budem ukladať čísla na parnej pozicii
    int neparne = 0;//vytvoril som premenu <-- kde budem ukladať čísla na neparnej pozicii
    int sum = 0;//vytvoril som premenu <-- kde sčítam parne a neparne

    for (int i = 0; i < array_size; ++i) { //cyklus prejde pole s číslami
        if (i % 2 == 0){ //ak pozícia je párna tak pridaj číslo do premmennej int
            parne += input_aray[i]; //pridávaj
        } else{
            neparne += pow((int) input_aray[i],2);//č. na np. musíme umocniť z knižnice math použijeme pow
        }//pow som našiel v dokumentácii danej knižnice
        sum = parne + neparne; //do premennej sum sčítam párne a nepárne
    }
    return sum; //vrátim hodnotu sum kedže to nie je void
}

/**Úloha 9: Special Numbers **/
int special_numbers(const int input_array[],const int array_size, int result_array[]){
    int pivot = 0; //zvolím si prvé číslo v retazci tak že priradím mu akoby index 0
    int posun_v_poli = 0; //nastavím si posun pre pole v ktorom budem ukladat specialne cisla
    //zacnem cyklus do while
    do{
        if (input_array == NULL){//pre prípad žeby arena chcela dať prázdny retazec
            break;
        } else{
            int sum = 0; //premenná kde budem sčítavať všetky čísla od pivota napravo
            int pivot_sum = pivot + 1; //premenna kt. umozni posun a sčitanie čísel od pivota napravo
            while (pivot_sum < array_size){//posuvaj sa doprava až kým nedojdeš na koniec retazca cisel v poli input_array
                sum += input_array[pivot_sum]; //číslo na danej pozicii pripočítaj do sum
                pivot_sum += 1;//posun sa o jedno čislo doprava v poli a nasledne ---^
            }
            if(input_array[pivot] <= sum){//ak pivot < od súčtu všetkých čísel tak sa pivot posunie o 1 doprava
                pivot += 1;//posun o 1 v pravo
            }else{
                result_array[posun_v_poli]=input_array[pivot];//ak bolo č. > tak sa priradi do result_array
                pivot += 1;//posunieme pivot o 1 vpravo
                posun_v_poli += 1;//posunieme sa vo výslednom poli čisel
            }
        }
    }while (pivot<array_size);
    int s_numbers = posun_v_poli; //vysledné číslo je v result_array na pozicii posun v poli
    return s_numbers;
}

unsigned long long sum_squared (const int line){
    unsigned long int pascal_array[line+1];//+1 preto lebo nezačína /_\ 0
    unsigned long int i = 0;// unsigned preto lebo budeme narabat z velkymi čislami
    pascal_array[i] = 1;//nastavím si číslo 1 akoby za vrchol trojuholnika a od neho budem pirdavat riadky
    while (i <= line){
        i += 1;//posun v riadku
        pascal_array[i] = pascal_array[i-1]*(line-i+1) / i;//vytváranie nových čísel do riadku
    }
    unsigned long int umocnene_cislo = 0;
    unsigned long int sum = 0;
    unsigned long int j = 0;

    while(j <= line){
        umocnene_cislo = pow(pascal_array[j],2);//umocnujem dané čislo v riadku z kniznice math
        sum += umocnene_cislo;//umocnene cislo pridám do suctu
        j += 1;//posun sa v riadku do prava
    }
    return sum;
}



int main(){
    /** LIFT CAR    **/

//    printf("Lift car example 1 : %.4f \n" ,lift_a_car(2, 80, 1400));
//    printf("Lift car example 2 : %.4f \n" ,lift_a_car(4, 90, 1650));
//    printf("<___________________________>\n");


    /** UNIT PRICE    **/

//    printf("Unit price example 1 : %.4f\n", unit_price(4.79, 16, 150));
//    printf("Unit price example 2 : %.4f\n", unit_price(5.63, 20, 200));
//    printf("<___________________________>\n");

    /** COLLATZ CONJECTURE    **/
//
//    printf("%d\n", collatz(20));
//    printf("<___________________________>\n");
//    printf("%d\n", collatz(20));

    /** OPPOSITE NUMBER
    printf("<___________________________>\n");
    printf("%d\n", opposite_number(10, 2));
    printf("%d\n", opposite_number(12, 9));
    **/

    /** Count Numbers in Array
    printf("<___________________________>\n");
    int input_array[] = {1,2,3,4,5};
    int result_array[2];
    counter(input_array, 5, result_array);
    printf("%d %d\n", result_array[0], result_array[1]);
    **/

    /** Pascal's Triangle **/

    /**Min-and-Max Price**/
    //int input_array[] = {1,2,3,4,5};

    //printf("%d\n", array_min(input_array, 5));
    //printf("%d\n", array_max(input_array, 5));

    //printf("%d\n", array_max(NULL, 5));
    // prints: -1

    //int input_array[] = {11,12,13,14,15};
    //printf("%lu\n", special_counter(input_array, 5));

    int input_array[] = {16,17,4,3,5,2};
    int result_array[6];
    int count = special_numbers(input_array, 6, result_array);
    for(int i = 0; i < count; i++){
        printf("%d ", result_array[i]);
    }
    printf("\n");

    return 0;

}