#include <iostream>  //cout
#include <cstdlib>   //srand
#include <ctime>     //time
#include <tuple>     //tuple
#include <algorithm> //min_element, max_element
#include <windows.h>

using namespace std;

typedef tuple<size_t, int,size_t, int> result;

void createArray(int *tgt, size_t size)
{
    for(size_t i = 0; i < size; ++i) {
        tgt[i] = rand();
    }
}

result findMinMax(int *tgt,size_t size){
    size_t imin = 0, imax = 0;
    for(size_t i = 0; i < size; ++i) {
        if( tgt[imin] > tgt[i] ) {
            imin = i;
        }
        if( tgt[imax] < tgt[i] ) {
            imax = i;
        }
    }
    return result(imin,tgt[imin],imax,tgt[imax]);
}

result findMinMaxCached(int *tgt,size_t size){
    size_t imin = 0, imax = 0;
    int min = tgt[0],max = tgt[0];
    for(size_t i = 0; i < size; ++i) {
        if( min > tgt[i] ) {
            min = tgt[i];
            imin = i;
        }
        if( max < tgt[i] ) {
            max = tgt[i];
            imax = i;
        }
    }
    return result(imin,tgt[imin],imax,tgt[imax]);
}

result findMinMaxStd(int *tgt,size_t size){
    int *ptr_min = min_element(tgt,tgt+size);
    int *ptr_max = max_element(tgt,tgt+size);
    return result(ptr_min-tgt, *ptr_min, ptr_max-tgt, *ptr_max);
}

typedef result (*func)(int*,size_t);

void test(func f, int count, size_t size){
    LARGE_INTEGER  total_time;
    total_time.QuadPart = 0;
    for(int i = 0; i < count; ++i){
        int *tgt = new int[size];
        createArray(tgt, size);
        LARGE_INTEGER start;
        QueryPerformanceCounter (&start);
        (*f)(tgt,size);
        LARGE_INTEGER end;
        QueryPerformanceCounter (&end);
        total_time.QuadPart += end.QuadPart - start.QuadPart;
        delete tgt;
    }
    total_time.QuadPart /= count;
    LARGE_INTEGER Frequency;
    QueryPerformanceFrequency(&Frequency);
    cout<<((double)total_time.QuadPart/Frequency.QuadPart)<<endl;
}

int main()
{
    srand(time(0));
    tuple<const char *,func> functions[] =
        {
            make_tuple("findMinMaxStd",findMinMaxStd),
            make_tuple("findMinMaxCached",findMinMaxCached),
            make_tuple("findMinMax",findMinMax)
        };
    for(auto f: functions){
        cout << get<0>(f) <<endl;
        test( get<1>(f),5,10000000);
    }
}

def genArray(size):
    random.seed()
    return tuple(random.randint(-2000000000,2000000000) for i in range(size))

def callTimeit(func):
    print(func+':')
    funcname = func+'(genArray(10000000))'
    setup = 'from __main__ import genArray,'+func
    print(timeit.timeit(funcname, setup, time.process_time, 5)/5)

<?php
function findMinMax(&$arr)
{
    $imin = 0;
    $imax = 0;
    for( $i=0; $i < count($arr); $i++ ){
        if( $arr[$i] < $arr[$imin] ){
            $imin = $i;
        }
        if( $arr[$i] > $arr[$imax] ){
            $imax = $i;
        }
    }
    return [$imin, $arr[$imin], $imax, $arr[$imax]];
}

function findMinMaxCached(&$arr)
{
    $imin = 0;
    $imax = 0;
    $min = 0;
    $max = 0;
    for( $i=0; $i < count($arr); $i++ ){
        if( $arr[$i] < $min ){
            $imin = $i;
            $min = $arr[$i];
        }
        if( $arr[$i] > $max ){
            $imax = $i;
            $max = $arr[$i];
        }
    }
    return [$imin, $min, $imax, $max];
}

function findMinMaxStandard(&$arr)
{
    $min = min($arr);
    $max = max($arr);
    return [array_search($min,$arr),$min,array_search($max,$arr),$max];
}

function fillArray(&$arr,$size)
{
    for($i=0;$i<$size;++$i) {
        $arr[$i]=rand();
    }
    return $arr;
}

function test($func,$count,$size,&$arr)
{
    $time = 0;
    for($i = 0;$i<$count;++$i)
    {
        $arr = fillArray($arr,$size);
        $start = microtime(true);
        $func($arr);
        $time += microtime(true) - $start;
    }
    $time/=5;
    echo $time.PHP_EOL;
}

$funcs = ["findMinMax","findMinMaxCached","findMinMaxStandard"];
foreach($funcs as $func) {
    $arr = [];
    echo $func.PHP_EOL;
    test($func,5,10000000,$arr);
}