Page Menu
Home
Xreate
Search
Configure Global Search
Log In
Docs
Questions
Repository
Issues
Patches
Internal API
Files
F4822611
minmax.xreate
No One
Temporary
Actions
View File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Mon, Aug 24, 5:17 PM
Size
9 KB
Mime Type
text/plain
Expires
Wed, Aug 26, 5:17 PM (1 d, 3 h)
Engine
blob
Format
Raw Data
Handle
286795
Attached To
rXR Xreate
minmax.xreate
View Options
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}
}
Event Timeline
Log In to Comment