static int[] getRecord(int[] s)
{
    int highest, lowest;
    highest = lowest = s[0];
    
    int[] result = new int[2];
    
    for (int s_i = 1; s_i < s.length; s_i++)
    {
        if (s[s_i] > highest)
        {
            highest = s[s_i];
            ++result[0];
        }
        else if (s[s_i] < lowest)
        {
            lowest = s[s_i];
            ++result[1];
        }
    }
    
    return result;
}

#define HOWMANYRESULTS 2

int* getRecord(int s_size, int* s, int *result_size) {
    // set best and worst to first game
    int worst = s[0];
    int best = s[0];
    // let main know how many results you'll print
    *result_size = HOWMANYRESULTS;
    // allocate heap space for the results and initialize to 0
    int *result = malloc(sizeof(int) * *result_size);
    result[0] = 0;
    result[1] = 0;

    // start loop from the second game
    for (int i = 1; i < s_size; i++) {
        if (s[i] > best) {
            // increase counter for best and reset best
            result[0]++;
            best = s[i];
        }
        if (s[i] < worst) {
            // increase counter for worst and reset worst
            result[1]++;
            worst = s[i];
        }
    }
    // return the address of the results on heap to main
    return result;
}

    // how many things will be printed
    int result_size;
    // call helper function, expect implementer to return
    // an int pointer (to the results) and set result_size
    int* result = getRecord(n, s, &result_size);
    for(int i = 0; i < result_size; i++) {
        // when i = 0 this evaluates to 0 which is same as
        // false and we don't print a space
        if (i) {
            printf(" ");
        }
        // on every round through the loop print another result
        printf("%d", result[i]);
    }

def getRecord(scores):
    ls = hs = s[0];
    lc = hc = 0;
    
    for score in scores:
        if(score > hs):
            hs = score;
            hc += 1;
        
        if(score < ls):
            ls = score;
            lc += 1;
            
    return [hc, lc]

let hiBreak = 0;
let lowBreak = 0;

score.reduce((agg, cur)=> {
	if(cur > agg[0]) {
		++hiBreak;
		agg[0] = cur;
	}
	else if(cur < agg[1]){
		++lowBreak;
		agg[1] = cur;
	}

	return agg;        
},[score[0], score[0]])

return [hiBreak, lowBreak];

vector<int> breakingRecords(vector<int> score) {
    int min=score[0];
    int max=score[0];
    vector<int> myreturn = {0,0};
    for(int i=1;i<score.size();i++){
        if(score[i]>max){
            myreturn[0]+=1;
            max = score[i];
        }
        else if(score[i]<min){
            myreturn[1]+=1;
            min = score[i];
        }
    }
    return myreturn;
}

def breakingRecords(lst):
    highest = len(set([max(lst[:(num+1)]) for num, i in enumerate(lst) if lst.index(max(lst[:(num+1)])) != 0]))
    lowest = len(set([min(lst[:(num+1)]) for num, i in enumerate(lst) if lst.index(min(lst[:(num+1)])) != 0]))

    return highest, lowest

var res = score.foldLeft((0,0),(score(0),score(0))){
          case (acc, c) => c match {
            case c if c > acc._2._1 =>  ((acc._1._1+1,acc._1._2),(c,acc._2._2))
            case c if c < acc._2._2 =>  ((acc._1._1, acc._1._2+1),(acc._2._1,c))
            case _=> acc
          }
        }
        println(s"${res._1._1} ${res._1._2}")