El = type {idx:: int, val:: int}.
PairT = type(X) {X, X}.

Pair = type PairT(int).
PairEl = type PairT(El).

min = function(x:: int, y:: int):: int 
{
    if (x < y):: int { x } else { y }
}

max = function(x:: int, y:: int):: int 
{
    if (x > y):: int { x } else { y }
}

minEl = function(e1:: El, e2:: El):: El
{
  if (e1["val"] < e2["val"]):: El {e1} else {e2}
}

maxEl = function(e1:: El, e2:: El):: El
{
  if (e1["val"] > e2["val"]):: El {e1} else {e2}
}

minElIdx = function(x:: El, y:: El):: El 
{
  if (x["idx"] < y["idx"]):: El {x} else {y}
}

maxElIdx = function(x:: El, y:: El):: El 
{
  if (x["idx"] > y["idx"]):: El {x} else {y}
}

minLstEl = function(x:: El, y:: El):: El 
{
  if (x["val"] <= y["val"]):: El {x} else {y}
}

maxLstEl = function(x:: El, y:: El):: El 
{
  if (x["val"] >= y["val"]):: El {x} else {y}
}

OptionalVal = type {flag:: bool, val:: int}.
OptionalEl = type {el:: El, exists:: bool}.

getOptionalEl = function(elActual:: OptionalEl, elDefault::El):: El
{
  if (elActual["exists"])::El {elActual["el"]} else {elDefault}
}

inRange = function(val::int, range::Pair):: bool
{
  val >= range[0] and val <= range[1]
}

fn-minmax1 = function:: {min:: int, max:: int} 
{
  arr = {25, 37, 12, 6, 5, 19, 3, 20}:: [int].
  
  loop fold(arr->el:: int, {1000, 0}->state):: {min:: int, max:: int} 
  {
    {
      min(el, state["min"]), 
      max(el, state["max"])
    }:: {min:: int, max:: int}
  }
}

fn-minmax2 = function:: int 
{
  arr = {
    {1, 72}, {3, 8}, {2, 5}, {3, 4}, {11, 1}, {6, 5}, {9, 2}
  } :: [{int, int}].
  
  loop fold(arr->rect:: {int, int}, 1000->squareMin):: int 
  {
    square = rect[0] * rect[1]:: int.
    
    min(square, squareMin)
  }
}

fn-minmax3 = function:: int
{
  arr = {
    {1, 72}, {3, 8}, {2, 5}, {3, 4}, {11, 1}, {6, 5}, {9, 2}
  } :: [{int, int}].
  
  loop fold(arr->rect:: {int, int}, 0->perMax):: int 
  {
    per = 2 * (rect[0] + rect[1]):: int.
    max(per, perMax)
  }
}

fn-minmax4 = function:: int
{
  arr = {25, 37, 12, 6, 5, 19, 3, 20}:: [int].
  minInit = {0, 25}:: El.
  result = loop fold(arr->el:: int, {0, minInit}->state):: {idx:: int, minEl:: El} 
  {
    elCur = {state["idx"], el}:: El.
    idxNext = state["idx"] + 1:: int.
    
    {idxNext, minEl(elCur, state["minEl"])}:: {idx:: int, minEl:: El} 
  }.
  
  result["minEl", "idx"]
}

fn-minmax5 = function:: El 
{
  input = {
    {1, 72}, {3, 8}, {2, 5}, {3, 4}, {11, 1}, {6, 5}, {9, 2}
  } :: [{int, int}].
  
  resultInit = {0, 0}:: El.
  result = loop fold(input->el:: Pair, {0, resultInit}->acc):: {idx:: int, max:: El}
  {
    density = el[0] / el[1] :: int.
    idxNext = acc["idx"] + 1:: int.
    elCur = {acc["idx"], density}:: El.
    
    {idxNext, maxEl(elCur, acc["max"])}:: {idx:: int, max:: El}
  }.
  
  result["max"]
}

fn-minmax6 = function:: Pair 
{
  arr = {25, 37, 1, 1, 6, 5, 19, 3, 37, 20}:: [int].
  
  init = {0, {{1000, 1000}, {0, 0}}}:: {int, PairEl}.
  
  result = loop fold(arr->val:: int, init->acc):: {int, PairEl}
  {
    el = {acc[0], val}:: El.
    
    idx = acc[0]+1 :: int. 
    min = minEl(el, acc[1, 0]) :: El.
    max = maxLstEl(el, acc[1, 1]):: El.
    
    {idx, ({min, max}:: PairEl)}:: {int, PairEl}
  }.
  
  {result[1][0]["idx"], result[1][1]["idx"]}
}

fn-minmax7 = function:: Pair 
{
  arr = {25, 37, 1, 1, 6, 5, 19, 3, 37, 20}:: [int].
  
  init = {0, {{0, 0}, {1000, 1000}}}:: {int, PairEl}.
  
  result = loop fold(arr->val:: int, init->acc):: {int, PairEl}
  {
    el = {acc[0], val}:: El.
    
    idx = acc[0]+1 :: int. 
    max = maxEl(el, acc[1, 0]) :: El.
    min = minLstEl(el, acc[1, 1]):: El.
    
    {idx, ({max, min}:: PairEl)}:: {int, PairEl}
  }.
  
  {result[1][0]["idx"], result[1][1]["idx"]}
}

fn-minmax8 = function:: Pair
{
  input = {25, 37, 1, 1, 6, 5, 19, 3, 37, 20}:: [int].
  init = {0, {{1000, 1000}, {1000, 1000}}}:: {int, PairEl}.
  
  result = loop fold(input->val:: int, init->acc):: {int, PairEl}
  {
    el = {acc[0], val}:: El.
    idx = acc[0]+1 :: int. 
    minF = minEl(el, acc[1, 0]) :: El.
    minL = minLstEl(el, acc[1, 1]):: El.
    
    {idx, {minF, minL}}:: {int, PairEl}
  }.
  
  {result[1, 0, "idx"], result[1, 1, "idx"]}
}

fn-minmax9 = function:: Pair
{
  input = {25, 37, 1, 1, 6, 5, 19, 3, 37, 20}:: [int].
  init = {0, {{0, 0}, {0, 0}}}:: {int, PairEl}.
  
  result = loop fold(input->val:: int, init->acc):: {int, PairEl}
  {
    el = {acc[0], val}:: El.
    idx = acc[0]+1 :: int. 
    maxF = maxEl(el, acc[1, 0]) :: El.
    maxL = maxLstEl(el, acc[1, 1]):: El.
    
    {idx, {maxF, maxL}}:: {int, PairEl}
  }.
  
  {result[1, 0, "idx"], result[1, 1, "idx"]}
}

fn-minmax10 = function:: int
{
  input = {25, 37, 1, 1, 6, 5, 19, 3, 37, 20}:: [int].
  init = {0, {{1000, 1000}, {0, 0}}}:: {int, PairEl}.
  
  result = loop fold(input->val:: int, init->acc):: {int, PairEl}
  {
    el = {acc[0], val}:: El.
    idx = acc[0]+1 :: int. 
    minF = minEl(el, acc[1, 0]) :: El.
    maxF = maxEl(el, acc[1, 1]):: El.
    
    {idx, {minF, maxF}}:: {int, PairEl}
  }.
  
  (minElIdx(result[1, 0], result[1, 1])::El)["idx"]
}

fn-minmax11 = function:: int 
{
  input = {25, 37, 1, 1, 6, 5, 19, 3, 37, 20}:: [int].
  
  ctxInit = {0, {{1000, 1000}, {0, 0}}}:: {int, PairEl}.
  result = loop fold(input-> val:: int, ctxInit->ctx):: {int, PairEl}
  {
    elCur = {ctx[0], val}:: El.
    
    elMinL = minLstEl(elCur, ctx[1, 0]):: El.
    elMaxL = maxLstEl(elCur, ctx[1, 1]):: El.
    
    {ctx[0]+1, {elMinL, elMaxL}}:: {int, PairEl}
  }.
  
  (maxElIdx(result[1, 0], result[1, 1])::El)["idx"]
}

fn-minmax12 = function:: int 
{
  input = {-8, 16, 3, -5, 2, -11, -905, -54}:: [int].
  
  result = loop fold(input->val:: int, {1000, false} -> state):: {minPstv:: int, flagPstvFound:: bool} 
  {
    if (val > 0):: int { {min(val, state["minPstv"]), true}:: {minPstv:: int, flagPstvFound:: bool} } else { state }
  }.
  
  if (result["flagPstvFound"])::int {result["minPstv"]} else { 0 }
}



fn-minmax13 = function::int 
{
  input = {-8, 16, 3, -5, 2, -11, -905, -54}:: [int].
  
  result = loop fold(input->x:: int, {false, -1000} -> state):: OptionalVal
  {
    if (x % 2 == 1):: OptionalVal {{true, max(x, state["val"])}:: OptionalVal } else { state }
  }.
  
  result["val"]
}

fn-minmax14 = function:: El
{
  input = { -8, 16, 3, -5, 2, -11, -905, -54 }:: [int].
  threshold = 2:: int.
  
  result = loop fold (input -> x:: int, {0, {el = { 0, 1000 }, exists = false }} -> result):: {int , OptionalEl}
  {
    xEl = {result[0], x}:: El.
    
    if(x > threshold):: {int , OptionalEl}  
    { 
      { result[0] + 1,  
        { el = minEl(xEl, result[1, "el"]), exists = true } 
      }:: {int , OptionalEl} } 
    else 
    { 
      result : {[0]= result[0] + 1} 
    }
  }.
  
  if (result[1, "exists"]):: El { result[1, "el"] } else { {0, 0}:: El }
}

State15 = type {idx:: int, max:: OptionalEl}.
fn-minmax15 = function:: El
{
  input = { -8, 16, 3, -5, 2, -11, -905, -54 }:: [int].
  range = {2, 17}:: Pair.
  
  result = loop fold(input->val::int, {0, {el = {0, 0}, exists = false}}->state):: State15
  {
    el = {state["idx"], val}:: El.
    stateNew = state : {idx = state["idx"] + 1}:: State15.
    
    if (inRange(val, range)):: State15
    {
      stateNew : {max = ({maxEl(el, state["max", "el"]), true}:: OptionalEl)}
    } 
    else
    {
      stateNew
    }
  }.
  
  getOptionalEl(result["max"], {0, 0}::El)
}

State19 = type {min:: int, length:: int}.
fn-minmax19 = function:: int
{
  input = { 18, 16, 2, 5, 2, 11, 905, 2 }:: [int].
  
  result = loop fold(input->x:: int, {1000, 0}->state)::State19
  {
    if(x < state["min"]):: State19 { {x, 1}:: State19 }
    else 
    {
      if (x == state["min"])::State19 { state: { length=state["length"] + 1 } }
      else { state }
    }
  }.
  
  result["length"]
}

State20 = type {
  min:: int, 
  lenMin:: int,
  max:: int,
  lenMax:: int
}.

fn-minmax20 = function:: int 
{
  input = { 18, 16, 2, 5, 2, 11, 905, 2 }:: [int].
  
  result = loop fold(input->x:: int, {1000, 0, 0, 0}->state)::State20
  {
    stateA = if(x < state["min"]):: State20 { state : {min = x, lenMin = 1} }
      else 
      {
        if (x == state["min"])::State20 { state: { lenMin = state["lenMin"] + 1 } }
        else { state }
      }.
      
    if(x > stateA["max"]):: State20 { stateA : {max = x, lenMax = 1} }
      else 
      {
        if (x == state["max"])::State20 { stateA: { lenMax = stateA["lenMax"] + 1 } }
        else { stateA }
      }
  }.
  
  result["lenMin"] + result["lenMax"]
}

State21 = type {sum:: int, size:: int}.
fn-minmax21 = function:: int 
{
  input = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}:: [int].

  minmax = loop fold(input->x:: int, {1000, 0} ->minmax):: Pair
  {
    minmaxA = if (x < minmax[0])::Pair { minmax: {[0]=x} } else {minmax}.
    if (x > minmax[1])::Pair {minmaxA : {[1] = x}} else {minmaxA}
  }.
  
  result = loop fold(input->x:: int, {0, 0}->result):: State21
  {
    if (x != minmax[0], x!= minmax[1]):: State21
    { {
      sum = result["sum"] + x,
      size = result["size"] + 1
    }:: State21} else {result}
  }.
  
  result["sum"] / result["size"]
}

min2 = function (val:: int, min:: Pair):: Pair
{
  if (val < min[0]):: Pair { {val, min[0]}::Pair }
  else 
  {
    if(val < min[1]):: Pair { {min[0], val}::Pair }
    else { min }
  }
}

fn-minmax22 = function:: Pair
{
  input = {-5, 18, 63, -29, 11, 17, 96, 28, -14}:: [int].
  
  loop fold(input->x:: int, {1000, 1000}->min):: Pair
  {
    min2(x, min):: Pair
  }
}

Triple = type {int, int, int}.

max3 = function(x:: int, max:: Triple):: Triple
{
  if (x > max[0])::Triple { {x, max[0], max[1]}:: Triple }
  else 
  {
    if (x > max[1]):: Triple {{max[0], x, max[1]}::Triple}
    else
    {
      if (x > max[2]):: Triple { max: {[2]=x} }
      else { max }
    }
  }
}

Tuple4 = type {int, int, int, int}.

fn-minmax23 = function:: Tuple4
{
  input = {-5, 18, 63, -29, 11, 17, 96, 28, -14}:: [int].
  
  result = loop fold(input->x:: int, {-1000, -1000, -1000}->max):: Triple
  {
    max3(x, max):: Triple
  }.
  
  {result[0], result[1], result[2], 0}
}