vector<int> rotateLeft(int d, vector<int> arr) {
    int n = arr.size();
    vector<int> result(n);
    for(int i = 0; i < n; i++){
        int newIndex = (i - d + n) % n;
        result[newIndex] = arr[i];
    }
    return result;
}

int* rotateLeft(int d, int arr_count, int* arr, int* result_count) {
    assert(result_count);
    *result_count = arr_count;
    
    //
    // Use extra memory to rotate an array
    // 1. copy into extra memory [0]..[d]
    // 2. then copy the rest of the array [d]..[end] into the [0] index
    // 3. then copy the extra memory bytes into rest of the main array
    //     starting from [d]
    //
    
    if (!arr_count || arr_count == 1 || !arr) return arr;

    int* extra = malloc(sizeof(int) * d);
    assert(extra);

    memcpy(extra, arr, d * sizeof(int));
    memcpy(arr, arr + d, sizeof(int) * (arr_count - d));
    memcpy(arr + arr_count - d, extra, d * sizeof(int));
    
    free(extra);
    return arr;
}

int* rotateLeft(int d, int arr_count, int* arr, int* result_count)

function rotateLeftIndex(index: number,numberOfRotations:number ,arr: number[]): number{

   let rotatedIndex = index - numberOfRotations;

   if(rotatedIndex < 0){
    rotatedIndex =  arr.length + rotatedIndex;// significa que deu a volta
   }
    return rotatedIndex;
}

function rotateLeft(d: number, arr: number[]): number[] {
    const hits = new Map<number,number>()    
   
    for(let i = 0; i < arr.length ; i++){
        const rotatedIndex = rotateLeftIndex(i,d,arr);

        hits.set(rotatedIndex,arr[rotatedIndex]);

        const storedValue = hits.get(i); 

        if(storedValue){
           arr[rotatedIndex] = storedValue;
           hits.delete(i);
           continue;
        }

        arr[rotatedIndex] = arr[i]; 

    }
   
    return arr
}