LibAcc: 0.6099=86/141, ProjAcc: 1.0000=0/0, Missing: 334
Module: algorithms/misc/rod-cutting/rod-cutting.spec
function 𝓟1{$Lambda41} (): (𝓟2: [miss]𝓛[ty]10033{Void})
{
function 𝓟3{$Lambda42} (): (𝓟4: [miss]𝓛[ty]10033{Void})
{
const 𝓟5{prices}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟6{bestPrices}: [miss]𝓛[ty]8670{Array} = 𝓟665{topDownCutRod}(𝓟5{prices},𝓛8745{Number}).bestPrices;
𝓛10036{expect}(𝓟6{bestPrices}.access(𝓛8745{Number})).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟6{bestPrices}.access(𝓛8745{Number})).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟6{bestPrices}.access(𝓛8745{Number})).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟6{bestPrices}.access(𝓛8745{Number})).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟6{bestPrices}.access(𝓛8745{Number})).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟3{$Lambda42})
function 𝓟7{$Lambda43} (): (𝓟8: [miss]𝓛[ty]10033{Void})
{
const 𝓟9{prices}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
𝓛10036{expect}(𝓟665{topDownCutRod}(𝓟9{prices},𝓛8745{Number}).bestPrices.access(𝓛8745{Number})).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟7{$Lambda43})
}
𝓛10037{describe}(𝓛8743{String},𝓟1{$Lambda41})
function 𝓟10{$Lambda44} (): (𝓟11: [miss]𝓛[ty]10033{Void})
{
function 𝓟12{$Lambda45} (): (𝓟13: [miss]𝓛[ty]10033{Void})
{
const 𝓟14{prices}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟15{bestPrices}: [miss]𝓛[ty]8670{Array} = 𝓟684{bottomUpCutRod}(𝓟14{prices},𝓛8745{Number}).bestPrices;
𝓛10036{expect}(𝓟15{bestPrices}.access(𝓛8745{Number})).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟15{bestPrices}.access(𝓛8745{Number})).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟15{bestPrices}.access(𝓛8745{Number})).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟15{bestPrices}.access(𝓛8745{Number})).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟15{bestPrices}.access(𝓛8745{Number})).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟12{$Lambda45})
function 𝓟16{$Lambda46} (): (𝓟17: [miss]𝓛[ty]10033{Void})
{
const 𝓟18{prices}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
𝓛10036{expect}(𝓟684{bottomUpCutRod}(𝓟18{prices},𝓛8745{Number}).bestPrices.access(𝓛8745{Number})).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟16{$Lambda46})
}
𝓛10037{describe}(𝓛8743{String},𝓟10{$Lambda44})
function 𝓟19{$Lambda47} (): (𝓟20: [miss]𝓛[ty]10033{Void})
{
function 𝓟21{$Lambda48} (): (𝓟22: [miss]𝓛[ty]10033{Void})
{
const 𝓟23{prices}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟24{bestCuts}: [miss]𝓛[ty]8670{Array} = 𝓟698{cutRod}(𝓟23{prices},𝓛8745{Number});
𝓛10036{expect}(𝓟24{bestCuts}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number}))
}
𝓛10038{it}(𝓛8743{String},𝓟21{$Lambda48})
function 𝓟25{$Lambda49} (): (𝓟26: [miss]𝓛[ty]10033{Void})
{
const 𝓟27{prices}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟28{bottomUp}: [miss]𝓛[ty]8670{Array} = 𝓟698{cutRod}(𝓟27{prices},𝓛8745{Number},𝓛8743{String});
const 𝓟29{topDown}: [miss]𝓛[ty]8670{Array} = 𝓟698{cutRod}(𝓟27{prices},𝓛8745{Number},𝓛8743{String});
𝓛10036{expect}(𝓟28{bottomUp}).toEqual(𝓟29{topDown})
}
𝓛10038{it}(𝓛8743{String},𝓟25{$Lambda49})
}
𝓛10037{describe}(𝓛8743{String},𝓟19{$Lambda47})
Module: algorithms/sort/selection-sort/selection-sort
function 𝓟30{selectionSort} (𝓟31{input}: 𝓛[ty]8670{Array}): (𝓟32: 𝓛[ty]8670{Array})
{
function 𝓟33{$Lambda120} (𝓟34{pivotIndex}): (𝓟35: [miss]𝓛[ty]10033{Void})
{
let 𝓟36{min}: [miss]𝓛[ty]8655{Number} = 𝓟31{input}.access(𝓟34{pivotIndex});
let 𝓟37{minIndex}: [miss]𝓛[ty]8655{Number} = 𝓟34{pivotIndex};
{
let 𝓟38{i}: [miss]𝓛[ty]8655{Number} = 𝓛12641{PlusToken}(𝓟34{pivotIndex},𝓛8745{Number});
while (𝓛1{<UNKNOWN>}(𝓟38{i},𝓟31{input}.length))
{
{
if (𝓛1{<UNKNOWN>}(𝓟31{input}.access(𝓟38{i}),𝓟36{min}))
{
𝓟36{min} ⟵ 𝓟31{input}.access(𝓟38{i});
𝓟37{minIndex} ⟵ 𝓟38{i};
}
}
𝓛12556{POST_PlusPlusToken}(𝓟38{i})
}
}
𝓟183{swap}(𝓟31{input},𝓟37{minIndex},𝓟34{pivotIndex})
}
𝓟167{range}(𝓛8745{Number},𝓛12616{MinusToken}(𝓟31{input}.length,𝓛8745{Number})).forEach(𝓟33{$Lambda120})
return 𝓟32 = 𝓟31{input}
}
Module: algorithms/misc/change-making/change-making
function 𝓟39{changeMaking} (𝓟40{coins}: 𝓛[ty]8670{Array},𝓟41{amount}: 𝓛[ty]8655{Number}): (𝓟42: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}))
{
const 𝓟43{results}: 𝓛[ty]8670{Array} = 𝓛8757{Array}.CONSTRUCTOR(𝓛12641{PlusToken}(𝓟41{amount},𝓛8745{Number}));
𝓟43{results}.fill(𝓛12616{MinusToken}(𝓛8706{Infinity}))
𝓟43{results}.access(𝓛8745{Number}) ⟵ 𝓛8745{Number};
function 𝓟44{$Lambda7} (𝓟45{coin}): (𝓟46: [miss]𝓛[ty]8655{Number})
{
return 𝓟46 = 𝓛1{<UNKNOWN>}(𝓟43{results}.access(𝓟45{coin}),𝓛8745{Number})
}
𝓟40{coins}.forEach(𝓟44{$Lambda7})
return 𝓟42 = 𝓟47{minCoins}(𝓟40{coins},𝓟43{results},𝓟41{amount})
}
function 𝓟47{minCoins} (𝓟48{coins}: 𝓛[ty]8670{Array},𝓟49{results}: 𝓛[ty]8670{Array},𝓟50{amount}: 𝓛[ty]8655{Number}): (𝓟51: 𝓛[ty]8655{Number})
{
if (𝓛12596{GreaterThanEqualsToken}(𝓟49{results}.access(𝓟50{amount}),𝓛8745{Number}))
{
return 𝓟51 = 𝓟49{results}.access(𝓟50{amount})
}
let 𝓟52{result}: 𝓛[ty]8655{Number} = 𝓛8706{Infinity};
function 𝓟53{$Lambda8} (𝓟54{coin}): (𝓟55: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟55 = 𝓛12582{LessThanEqualsToken}(𝓟54{coin},𝓟50{amount})
}
function 𝓟56{$Lambda9} (𝓟57{coin}): (𝓟58: [miss]𝓛[ty]10033{Void})
{
𝓟52{result} ⟵ 𝓛8746{Math}.min(𝓟52{result},𝓛12641{PlusToken}(𝓛8745{Number},𝓟47{minCoins}(𝓟48{coins},𝓟49{results},𝓛12616{MinusToken}(𝓟50{amount},𝓟57{coin}))));
}
𝓟48{coins}.filter(𝓟53{$Lambda8}).forEach(𝓟56{$Lambda9})
𝓟49{results}.access(𝓟50{amount}) ⟵ 𝓟52{result};
return 𝓟51 = 𝓟52{result}
}
Module: algorithms/search/binary-search-tree/binary-search-tree
type 𝓟[ty]59{Node} = {parent: 𝓟[ty]59{Node}, key: 𝓛[ty]8655{Number}, left: 𝓟[ty]59{Node}, right: 𝓟[ty]59{Node}}
type 𝓟[ty]60{Tree} = {root: 𝓟[ty]59{Node}}
function 𝓟61{createNode} (𝓟62{key}: 𝓛[ty]8655{Number},𝓟63{left}: [OOV]𝓟[ty]59{Node},𝓟64{right}: [OOV]𝓟[ty]59{Node}): (𝓟65: [OOV]𝓟[ty]59{Node})
{
const 𝓟66{node}: [miss]𝓛[ty]8642{Object} = {key: 𝓟62{key},left: 𝓟63{left},right: 𝓟64{right},parent: 𝓛12643{undefined}};
if (𝓟63{left})
{
𝓟63{left}.parent ⟵ 𝓟66{node};
}
if (𝓟64{right})
{
𝓟64{right}.parent ⟵ 𝓟66{node};
}
return 𝓟65 = 𝓟66{node}
}
function 𝓟67{inOrderWalk} (𝓟68{node}: [OOV]𝓟[ty]59{Node}): (𝓟69: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓟68{node}))
{
}
𝓟67{inOrderWalk}(𝓟68{node}.left)
𝓛1{<UNKNOWN>}(𝓟68{node})
𝓟67{inOrderWalk}(𝓟68{node}.right)
}
function 𝓟70{search} (𝓟71{node}: [OOV]𝓟[ty]59{Node},𝓟72{key}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟73: [OOV]𝓟[ty]59{Node})
{
if (𝓛12569{ExclamationToken}(𝓟71{node}))
{
return 𝓟73 = 𝓛12643{undefined}
}
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟71{node}.key,𝓟72{key}))
{
return 𝓟73 = 𝓟71{node}
}
else
{
if (𝓛1{<UNKNOWN>}(𝓟71{node}.key,𝓟72{key}))
{
return 𝓟73 = 𝓟70{search}(𝓟71{node}.right,𝓟72{key})
}
else
{
return 𝓟73 = 𝓟70{search}(𝓟71{node}.left,𝓟72{key})
}
}
}
function 𝓟74{minimum} (𝓟75{node}: [OOV]𝓟[ty]59{Node}): (𝓟76: [OOV]𝓟[ty]59{Node})
{
let 𝓟77{leftMost}: [OOV]𝓟[ty]59{Node} = 𝓟75{node};
while (𝓛12592{AmpersandAmpersandToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓟77{leftMost},𝓛12643{undefined}),𝓛12612{ExclamationEqualsEqualsToken}(𝓟77{leftMost}.left,𝓛12643{undefined})))
{
𝓟77{leftMost} ⟵ 𝓟77{leftMost}.left;
}
return 𝓟76 = 𝓟77{leftMost}
}
function 𝓟78{maximum} (𝓟79{node}: [OOV]𝓟[ty]59{Node}): (𝓟80: [OOV]𝓟[ty]59{Node})
{
let 𝓟81{rightMost}: [OOV]𝓟[ty]59{Node} = 𝓟79{node};
while (𝓛12592{AmpersandAmpersandToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓟81{rightMost},𝓛12643{undefined}),𝓛12612{ExclamationEqualsEqualsToken}(𝓟81{rightMost}.right,𝓛12643{undefined})))
{
𝓟81{rightMost} ⟵ 𝓟81{rightMost}.right;
}
return 𝓟80 = 𝓟81{rightMost}
}
function 𝓟82{successor} (𝓟83{node}: [OOV]𝓟[ty]59{Node}): (𝓟84: [OOV]𝓟[ty]59{Node})
{
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟83{node}.right,𝓛12643{undefined}))
{
return 𝓟84 = 𝓟74{minimum}(𝓟83{node}.right)
}
let 𝓟85{parent}: [OOV]𝓟[ty]59{Node} = 𝓟83{node}.parent;
let 𝓟86{current}: [OOV]𝓟[ty]59{Node} = 𝓟83{node};
while (𝓛12592{AmpersandAmpersandToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓟85{parent},𝓛12643{undefined}),𝓛12559{EqualsEqualsEqualsToken}(𝓟85{parent}.right,𝓟86{current})))
{
𝓟86{current} ⟵ 𝓟85{parent};
𝓟85{parent} ⟵ 𝓟85{parent}.parent;
}
return 𝓟84 = 𝓟85{parent}
}
function 𝓟87{predecessor} (𝓟88{node}: [OOV]𝓟[ty]59{Node}): (𝓟89: [OOV]𝓟[ty]59{Node})
{
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟88{node}.left,𝓛12643{undefined}))
{
return 𝓟89 = 𝓟88{node}.left
}
let 𝓟90{parent}: [OOV]𝓟[ty]59{Node} = 𝓟88{node}.parent;
let 𝓟91{current}: [OOV]𝓟[ty]59{Node} = 𝓟88{node};
while (𝓛12592{AmpersandAmpersandToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓟90{parent},𝓛12643{undefined}),𝓛12559{EqualsEqualsEqualsToken}(𝓟90{parent}.left,𝓟91{current})))
{
𝓟91{current} ⟵ 𝓟90{parent};
𝓟90{parent} ⟵ 𝓟90{parent}.parent;
}
return 𝓟89 = 𝓟90{parent}
}
function 𝓟92{insert} (𝓟93{tree}: [OOV]𝓟[ty]60{Tree},𝓟94{leaf}: [OOV]𝓟[ty]59{Node}): (𝓟95: [miss]𝓛[ty]10033{Void})
{
let 𝓟96{parent}: [OOV]𝓟[ty]59{Node} = 𝓛12643{undefined};
let 𝓟97{current}: [OOV]𝓟[ty]59{Node} = 𝓟93{tree}.root;
while (𝓛12612{ExclamationEqualsEqualsToken}(𝓟97{current},𝓛12643{undefined}))
{
𝓟96{parent} ⟵ 𝓟97{current};
if (𝓛12596{GreaterThanEqualsToken}(𝓟94{leaf}.key,𝓟97{current}.key))
{
𝓟97{current} ⟵ 𝓟97{current}.right;
}
else
{
𝓟97{current} ⟵ 𝓟97{current}.left;
}
}
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟96{parent},𝓛12643{undefined}))
{
𝓟93{tree}.root ⟵ 𝓟94{leaf};
}
else
{
if (𝓛12596{GreaterThanEqualsToken}(𝓟94{leaf}.key,𝓟96{parent}.key))
{
𝓟96{parent}.right ⟵ 𝓟94{leaf};
}
else
{
𝓟96{parent}.left ⟵ 𝓟94{leaf};
}
}
𝓟94{leaf}.parent ⟵ 𝓟96{parent};
}
function 𝓟98{transplant} (𝓟99{tree}: [OOV]𝓟[ty]60{Tree},𝓟100{oldNode}: [OOV]𝓟[ty]59{Node},𝓟101{newNode}: [OOV]𝓟[ty]59{Node}): (𝓟102: [miss]𝓛[ty]10033{Void})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟100{oldNode}.parent,𝓛12643{undefined}))
{
𝓟99{tree}.root ⟵ 𝓟101{newNode};
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟100{oldNode}.parent.left,𝓟100{oldNode}))
{
𝓟100{oldNode}.parent.left ⟵ 𝓟101{newNode};
}
else
{
𝓟100{oldNode}.parent.right ⟵ 𝓟101{newNode};
}
}
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟101{newNode},𝓛12643{undefined}))
{
𝓟101{newNode}.parent ⟵ 𝓟100{oldNode}.parent;
}
}
function 𝓟103{remove} (𝓟104{tree}: [OOV]𝓟[ty]60{Tree},𝓟105{removed}: [OOV]𝓟[ty]59{Node}): (𝓟106: [miss]𝓛[ty]10033{Void})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟105{removed}.left,𝓛12643{undefined}))
{
𝓟98{transplant}(𝓟104{tree},𝓟105{removed},𝓟105{removed}.right)
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟105{removed}.right,𝓛12643{undefined}))
{
𝓟98{transplant}(𝓟104{tree},𝓟105{removed},𝓟105{removed}.left)
}
else
{
const 𝓟107{minRight}: [OOV]𝓟[ty]59{Node} = 𝓟74{minimum}(𝓟105{removed}.right);
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟107{minRight}.parent,𝓟105{removed}))
{
𝓟98{transplant}(𝓟104{tree},𝓟107{minRight},𝓟107{minRight}.right)
𝓟107{minRight}.right ⟵ 𝓟105{removed}.right;
𝓟107{minRight}.right.parent ⟵ 𝓟107{minRight};
}
𝓟98{transplant}(𝓟104{tree},𝓟105{removed},𝓟107{minRight})
𝓟107{minRight}.left ⟵ 𝓟105{removed}.left;
𝓟107{minRight}.left.parent ⟵ 𝓟107{minRight};
}
}
}
Module: algorithms/misc/activity-selection/activity-selection
type 𝓟[ty]108{Activity} = {start: 𝓛[ty]8655{Number}, finish: 𝓛[ty]8655{Number}}
function 𝓟109{activitySelector} (𝓟110{activities}: 𝓛[ty]8670{Array}): (𝓟111: 𝓛[ty]8670{Array})
{
const 𝓟112{selected}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓟110{activities}.access(𝓛8745{Number}));
let 𝓟113{lastActivity}: [OOV]𝓟[ty]108{Activity} = 𝓟110{activities}.access(𝓛8745{Number});
function 𝓟114{$Lambda2} (𝓟115{index}): (𝓟116: [miss]𝓛[ty]10033{Void})
{
const 𝓟117{currentActivity}: [OOV]any = 𝓟110{activities}.access(𝓟115{index});
if (𝓛12596{GreaterThanEqualsToken}(𝓟117{currentActivity}.start,𝓟113{lastActivity}.finish))
{
𝓟112{selected}.push(𝓟117{currentActivity})
𝓟113{lastActivity} ⟵ 𝓟117{currentActivity};
}
}
𝓟167{range}(𝓛8745{Number},𝓛12616{MinusToken}(𝓟110{activities}.length,𝓛8745{Number})).forEach(𝓟114{$Lambda2})
return 𝓟111 = 𝓟112{selected}
}
Module: algorithms/search/binary-search/binary-search.spec
function 𝓟118{$Lambda53} (): (𝓟119: [miss]𝓛[ty]10033{Void})
{
function 𝓟120{$Lambda54} (): (𝓟121: [miss]𝓛[ty]10033{Void})
{
const 𝓟122{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟123{right}: [miss]𝓛[ty]8655{Number} = 𝓟438{binarySearch}(𝓟122{input},𝓛8745{Number},𝓛8745{Number},𝓛12616{MinusToken}(𝓟122{input}.length,𝓛8745{Number}));
const 𝓟124{left}: [miss]𝓛[ty]8655{Number} = 𝓟438{binarySearch}(𝓟122{input},𝓛8745{Number},𝓛8745{Number},𝓛12616{MinusToken}(𝓟122{input}.length,𝓛8745{Number}));
𝓛10036{expect}(𝓟123{right}).toEqual(𝓛8745{Number})
𝓛10036{expect}(𝓟124{left}).toEqual(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟120{$Lambda54})
function 𝓟125{$Lambda55} (): (𝓟126: [miss]𝓛[ty]10033{Void})
{
const 𝓟127{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟128{right}: [miss]𝓛[ty]8655{Number} = 𝓟438{binarySearch}(𝓟127{input},𝓛8745{Number},𝓛8745{Number},𝓛12616{MinusToken}(𝓟127{input}.length,𝓛8745{Number}));
const 𝓟129{left}: [miss]𝓛[ty]8655{Number} = 𝓟438{binarySearch}(𝓟127{input},𝓛8745{Number},𝓛8745{Number},𝓛12616{MinusToken}(𝓟127{input}.length,𝓛8745{Number}));
𝓛10036{expect}(𝓟128{right}).toEqual(𝓛8745{Number})
𝓛10036{expect}(𝓟129{left}).toEqual(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟125{$Lambda55})
function 𝓟130{$Lambda56} (): (𝓟131: [miss]𝓛[ty]10033{Void})
{
const 𝓟132{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟133{right}: [miss]𝓛[ty]8655{Number} = 𝓟438{binarySearch}(𝓟132{input},𝓛8745{Number},𝓛8745{Number},𝓛12616{MinusToken}(𝓟132{input}.length,𝓛8745{Number}));
const 𝓟134{left}: [miss]𝓛[ty]8655{Number} = 𝓟438{binarySearch}(𝓟132{input},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛8745{Number},𝓛12616{MinusToken}(𝓟132{input}.length,𝓛8745{Number}));
𝓛10036{expect}(𝓟133{right}).toEqual(𝓛12643{undefined})
𝓛10036{expect}(𝓟134{left}).toEqual(𝓛12643{undefined})
}
𝓛10038{it}(𝓛8743{String},𝓟130{$Lambda56})
}
𝓛10037{describe}(𝓛8743{String},𝓟118{$Lambda53})
Module: algorithms/sort/quick-sort/quick-sort
function 𝓟135{partition} (𝓟136{input}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}),𝓟137{left}: 𝓛[ty]8655{Number},𝓟138{right}: 𝓛[ty]8655{Number},𝓟139{randomized}: 𝓛[ty]8666{Boolean}): (𝓟140: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}))
{
if (𝓟139{randomized})
{
𝓟183{swap}(𝓟136{input},𝓟706{random}(𝓟137{left},𝓟138{right}),𝓟138{right})
}
const 𝓟141{pivot}: [miss]𝓛[ty]8655{Number} = 𝓟136{input}.access(𝓟138{right});
let 𝓟142{minEdge}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓟137{left},𝓛8745{Number});
function 𝓟143{$Lambda117} (𝓟144{current}): (𝓟145: [miss]𝓛[ty]10033{Void})
{
if (𝓛12582{LessThanEqualsToken}(𝓟136{input}.access(𝓟144{current}),𝓟141{pivot}))
{
𝓛12564{FirstCompoundAssignment}(𝓟142{minEdge},𝓛8745{Number})
𝓟183{swap}(𝓟136{input},𝓟142{minEdge},𝓟144{current})
}
}
𝓟167{range}(𝓟137{left},𝓛12616{MinusToken}(𝓟138{right},𝓛8745{Number})).forEach(𝓟143{$Lambda117})
𝓟183{swap}(𝓟136{input},𝓛12641{PlusToken}(𝓟142{minEdge},𝓛8745{Number}),𝓟138{right})
return 𝓟140 = 𝓛12641{PlusToken}(𝓟142{minEdge},𝓛8745{Number})
}
function 𝓟146{quickSort} (𝓟147{input}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}),𝓟148{start},𝓟149{end},𝓟150{randomized}): (𝓟151: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}))
{
if (𝓛12596{GreaterThanEqualsToken}(𝓟148{start},𝓟149{end}))
{
return 𝓟151 = 𝓟147{input}
}
const 𝓟152{mid}: [miss]𝓛[ty]8655{Number} = 𝓟135{partition}(𝓟147{input},𝓟148{start},𝓟149{end},𝓟150{randomized});
𝓟146{quickSort}(𝓟147{input},𝓟148{start},𝓛12616{MinusToken}(𝓟152{mid},𝓛8745{Number}))
𝓟146{quickSort}(𝓟147{input},𝓛12641{PlusToken}(𝓟152{mid},𝓛8745{Number}),𝓟149{end})
return 𝓟151 = 𝓟147{input}
}
Module: algorithms/utils
type 𝓟[ty]153{Node} = {left: 𝓟[ty]153{Node}, right: 𝓟[ty]153{Node}}
function 𝓟154{fill} (𝓟155{array}: 𝓛[ty]8670{Array},𝓟156{valueFn}: 𝓛[ty]8696{Function}): (𝓟157: 𝓛[ty]8670{Array})
{
{
let 𝓟158{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟158{i},𝓟155{array}.length))
{
𝓟155{array}.access(𝓟158{i}) ⟵ 𝓟156{valueFn}(𝓟158{i});
𝓛12556{POST_PlusPlusToken}(𝓟158{i})
}
}
return 𝓟157 = 𝓟155{array}
}
function 𝓟159{increaseOfPrevious} (𝓟160{array}: 𝓛[ty]8670{Array},𝓟161{index}: 𝓛[ty]8655{Number}): (𝓟162: [miss]𝓛[ty]10033{Void})
{
𝓛12564{FirstCompoundAssignment}(𝓟160{array}.access(𝓟161{index}),𝓟160{array}.access(𝓛12616{MinusToken}(𝓟161{index},𝓛8745{Number})))
}
function 𝓟163{moveRight} (𝓟164{input},𝓟165{index}): (𝓟166: [miss]𝓛[ty]10033{Void})
{
𝓟164{input}.access(𝓛12641{PlusToken}(𝓟165{index},𝓛8745{Number})) ⟵ 𝓟164{input}.access(𝓟165{index});
}
function 𝓟167{range} (𝓟168{from}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8655{Number}),𝓟169{to}: 𝓛[ty]8655{Number}): (𝓟170: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}))
{
return 𝓟170 = 𝓟707{baseRange}(𝓟168{from},𝓛12641{PlusToken}(𝓟169{to},𝓛8745{Number}))
}
function 𝓟171{reverseRange} (𝓟172{from}: 𝓛[ty]8655{Number},𝓟173{to}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8655{Number})): (𝓟174: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}))
{
return 𝓟174 = 𝓟708{baseRangeRight}(𝓟173{to},𝓛12641{PlusToken}(𝓟172{from},𝓛8745{Number}))
}
function 𝓟175{toSerializableTree} (𝓟176{root}: [OOV]𝓟[ty]153{Node},𝓟177{nodeConverter}: 𝓛[ty]8696{Function}): (𝓟178: [OOV]𝓟[ty]153{Node})
{
if (𝓛12569{ExclamationToken}(𝓟176{root}))
{
}
𝓟175{toSerializableTree}(𝓟176{root}.left,𝓟177{nodeConverter})
𝓛8741{Object}.assign(𝓟176{root},𝓟177{nodeConverter}(𝓟176{root}))
𝓟175{toSerializableTree}(𝓟176{root}.right,𝓟177{nodeConverter})
return 𝓟178 = 𝓟176{root}
}
function 𝓟179{setHead} (𝓟180{input}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}),𝓟181{value}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟182: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}))
{
𝓟180{input}.access(𝓛8745{Number}) ⟵ 𝓟181{value};
return 𝓟182 = 𝓟180{input}
}
function 𝓟183{swap} (𝓟184{input}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}),𝓟185{from}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟186{to}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟187: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}))
{
const 𝓟188{temp}: [miss]𝓛[ty]8655{Number} = 𝓟184{input}.access(𝓟185{from});
𝓟184{input}.access(𝓟185{from}) ⟵ 𝓟184{input}.access(𝓟186{to});
𝓟184{input}.access(𝓟186{to}) ⟵ 𝓟188{temp};
return 𝓟187 = 𝓟184{input}
}
Module: algorithms/misc/inversions-count/inversions-count
function 𝓟189{merge} (𝓟190{input}: 𝓛[ty]8670{Array},𝓟191{start}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟192{mid}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8655{Number}),𝓟193{end}: 𝓛[ty]8655{Number}): (𝓟194: 𝓛[ty]8655{Number})
{
const 𝓟195{left}: [miss]𝓛[ty]8670{Array} = 𝓟190{input}.slice(𝓟191{start},𝓟192{mid});
const 𝓟196{right}: [miss]𝓛[ty]8670{Array} = 𝓟190{input}.slice(𝓟192{mid},𝓟193{end});
𝓟195{left}.access(𝓟195{left}.length) ⟵ 𝓛12616{MinusToken}(𝓛8706{Infinity}) as any;
𝓟196{right}.access(𝓟196{right}.length) ⟵ 𝓛12616{MinusToken}(𝓛8706{Infinity}) as any;
let 𝓟197{inversionCount}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
function 𝓟198{$Lambda18} (𝓟199{index}): (𝓟200: [miss]𝓛[ty]10033{Void})
{
if (𝓛12595{GreaterThanToken}(𝓟709{head}(𝓟195{left}),𝓟709{head}(𝓟196{right})))
{
𝓛12564{FirstCompoundAssignment}(𝓟197{inversionCount},𝓛12616{MinusToken}(𝓟196{right}.length,𝓛8745{Number}))
𝓟190{input}.access(𝓟199{index}) ⟵ 𝓟195{left}.shift();
}
else
{
𝓟190{input}.access(𝓟199{index}) ⟵ 𝓟196{right}.shift();
}
}
𝓟167{range}(𝓟191{start},𝓛12616{MinusToken}(𝓟193{end},𝓛8745{Number})).forEach(𝓟198{$Lambda18})
return 𝓟194 = 𝓟197{inversionCount}
}
function 𝓟201{countInversions} (𝓟202{input}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}),𝓟203{start}: 𝓛[ty]8655{Number},𝓟204{end}: 𝓛[ty]8655{Number}): (𝓟205: 𝓛[ty]8655{Number})
{
if (𝓛12582{LessThanEqualsToken}(𝓛12616{MinusToken}(𝓟204{end},𝓟203{start}),𝓛8745{Number}))
{
return 𝓟205 = 𝓛8745{Number}
}
const 𝓟206{mid}: [miss]𝓛[ty]8655{Number} = 𝓛8746{Math}.floor(𝓛12573{SlashToken}(𝓛12641{PlusToken}(𝓟203{start},𝓟204{end}),𝓛8745{Number}));
const 𝓟207{leftCount}: [miss]𝓛[ty]8655{Number} = 𝓟201{countInversions}(𝓟202{input},𝓟203{start},𝓟206{mid});
const 𝓟208{rightCount}: [miss]𝓛[ty]8655{Number} = 𝓟201{countInversions}(𝓟202{input},𝓟206{mid},𝓟204{end});
return 𝓟205 = 𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓟207{leftCount},𝓟208{rightCount}),𝓟189{merge}(𝓟202{input},𝓟203{start},𝓟206{mid},𝓟204{end}))
}
Module: algorithms/sort/insertion-sort/insertion-sort.spec
function 𝓟209{$Lambda96} (): (𝓟210: [miss]𝓛[ty]10033{Void})
{
function 𝓟211{$Lambda97} (): (𝓟212: [miss]𝓛[ty]10033{Void})
{
const 𝓟213{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟214{result}: [miss]𝓛[ty]8670{Array} = 𝓟564{insertionSort}(𝓟213{input});
𝓛10036{expect}(𝓟214{result}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number}))
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟211{$Lambda97})
}
𝓛10037{describe}(𝓛8743{String},𝓟209{$Lambda96})
Module: algorithms/search/binary-search-tree/binary-search-tree.spec
function 𝓟215{createBST} (): (𝓟216: [OOV]𝓟[ty]59{Node})
{
return 𝓟216 = 𝓟61{createNode}(𝓛8745{Number},𝓟61{createNode}(𝓛8745{Number},𝓟61{createNode}(𝓛8745{Number},𝓟61{createNode}(𝓛8745{Number}),𝓟61{createNode}(𝓛8745{Number})),𝓟61{createNode}(𝓛8745{Number},𝓛12643{undefined},𝓟61{createNode}(𝓛8745{Number},𝓟61{createNode}(𝓛8745{Number})))),𝓟61{createNode}(𝓛8745{Number},𝓟61{createNode}(𝓛8745{Number}),𝓟61{createNode}(𝓛8745{Number})))
}
function 𝓟217{$Lambda57} (): (𝓟218: [miss]𝓛[ty]10033{Void})
{
function 𝓟219{$Lambda58} (): (𝓟220: [miss]𝓛[ty]10033{Void})
{
𝓛10036{expect}(𝓟215{createBST}()).toMatchSnapshot(𝓛8743{String})
}
𝓛10038{it}(𝓛8743{String},𝓟219{$Lambda58})
}
𝓛10037{describe}(𝓛8743{String},𝓟217{$Lambda57})
function 𝓟221{$Lambda59} (): (𝓟222: [miss]𝓛[ty]10033{Void})
{
function 𝓟223{$Lambda60} (): (𝓟224: [miss]𝓛[ty]10033{Void})
{
const 𝓟225{tree}: [OOV]𝓟[ty]59{Node} = 𝓟215{createBST}();
const 𝓟226{node}: [OOV]𝓟[ty]59{Node} = 𝓟70{search}(𝓟225{tree},𝓛8745{Number});
𝓛10036{expect}(𝓟226{node}.key).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟226{node}.left.key).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟226{node}.right.key).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟223{$Lambda60})
}
𝓛10037{describe}(𝓛8743{String},𝓟221{$Lambda59})
function 𝓟227{$Lambda61} (): (𝓟228: [miss]𝓛[ty]10033{Void})
{
function 𝓟229{$Lambda62} (): (𝓟230: [miss]𝓛[ty]10033{Void})
{
const 𝓟231{tree}: [OOV]𝓟[ty]59{Node} = 𝓟215{createBST}();
const 𝓟232{minimumNode}: [OOV]𝓟[ty]59{Node} = 𝓟74{minimum}(𝓟231{tree});
𝓛10036{expect}(𝓟232{minimumNode}.key).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟229{$Lambda62})
}
𝓛10037{describe}(𝓛8743{String},𝓟227{$Lambda61})
function 𝓟233{$Lambda63} (): (𝓟234: [miss]𝓛[ty]10033{Void})
{
function 𝓟235{$Lambda64} (): (𝓟236: [miss]𝓛[ty]10033{Void})
{
const 𝓟237{tree}: [OOV]𝓟[ty]59{Node} = 𝓟215{createBST}();
const 𝓟238{maximumNode}: [OOV]𝓟[ty]59{Node} = 𝓟78{maximum}(𝓟237{tree});
𝓛10036{expect}(𝓟238{maximumNode}.key).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟235{$Lambda64})
}
𝓛10037{describe}(𝓛8743{String},𝓟233{$Lambda63})
function 𝓟239{$Lambda65} (): (𝓟240: [miss]𝓛[ty]10033{Void})
{
function 𝓟241{$Lambda66} (): (𝓟242: [miss]𝓛[ty]10033{Void})
{
const 𝓟243{tree}: [OOV]𝓟[ty]59{Node} = 𝓟215{createBST}();
const 𝓟244{successorNode}: [OOV]𝓟[ty]59{Node} = 𝓟82{successor}(𝓟243{tree});
𝓛10036{expect}(𝓟244{successorNode}.key).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟241{$Lambda66})
function 𝓟245{$Lambda67} (): (𝓟246: [miss]𝓛[ty]10033{Void})
{
const 𝓟247{tree}: [OOV]𝓟[ty]59{Node} = 𝓟215{createBST}();
const 𝓟248{node13}: [OOV]𝓟[ty]59{Node} = 𝓟70{search}(𝓟247{tree},𝓛8745{Number});
const 𝓟249{successorNode}: [OOV]𝓟[ty]59{Node} = 𝓟82{successor}(𝓟248{node13});
𝓛10036{expect}(𝓟249{successorNode}.key).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟245{$Lambda67})
}
𝓛10037{describe}(𝓛8743{String},𝓟239{$Lambda65})
function 𝓟250{$Lambda68} (): (𝓟251: [miss]𝓛[ty]10033{Void})
{
function 𝓟252{$Lambda69} (): (𝓟253: [miss]𝓛[ty]10033{Void})
{
const 𝓟254{tree}: [OOV]𝓟[ty]59{Node} = 𝓟215{createBST}();
const 𝓟255{predecessorNode}: [OOV]𝓟[ty]59{Node} = 𝓟87{predecessor}(𝓟254{tree});
𝓛10036{expect}(𝓟255{predecessorNode}.key).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟252{$Lambda69})
function 𝓟256{$Lambda70} (): (𝓟257: [miss]𝓛[ty]10033{Void})
{
const 𝓟258{tree}: [OOV]𝓟[ty]59{Node} = 𝓟215{createBST}();
const 𝓟259{node9}: [OOV]𝓟[ty]59{Node} = 𝓟70{search}(𝓟258{tree},𝓛8745{Number});
const 𝓟260{predecessorNode}: [OOV]𝓟[ty]59{Node} = 𝓟87{predecessor}(𝓟259{node9});
𝓛10036{expect}(𝓟260{predecessorNode}.key).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟256{$Lambda70})
}
𝓛10037{describe}(𝓛8743{String},𝓟250{$Lambda68})
function 𝓟261{$Lambda71} (): (𝓟262: [miss]𝓛[ty]10033{Void})
{
function 𝓟263{$Lambda72} (): (𝓟264: [miss]𝓛[ty]10033{Void})
{
const 𝓟265{tree}: [OOV]𝓟[ty]60{Tree} = {root: 𝓟61{createNode}(𝓛8745{Number})};
const 𝓟266{leaf}: [OOV]𝓟[ty]59{Node} = 𝓟61{createNode}(𝓛8745{Number});
𝓟92{insert}(𝓟265{tree},𝓟266{leaf})
𝓛10036{expect}(𝓟265{tree}.root.left.key).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟266{leaf}.parent).toEqual(𝓟265{tree}.root)
}
𝓛10038{it}(𝓛8743{String},𝓟263{$Lambda72})
function 𝓟267{$Lambda73} (): (𝓟268: [miss]𝓛[ty]10033{Void})
{
const 𝓟269{tree}: [OOV]𝓟[ty]60{Tree} = {root: 𝓛12643{undefined}};
const 𝓟270{leaf}: [OOV]𝓟[ty]59{Node} = 𝓟61{createNode}(𝓛8745{Number});
𝓟92{insert}(𝓟269{tree},𝓟270{leaf})
𝓛10036{expect}(𝓟269{tree}.root).toEqual(𝓟269{tree}.root)
𝓛10036{expect}(𝓟270{leaf}.parent).toBe(𝓛12643{undefined})
}
𝓛10038{it}(𝓛8743{String},𝓟267{$Lambda73})
function 𝓟271{$Lambda74} (): (𝓟272: [miss]𝓛[ty]10033{Void})
{
const 𝓟273{tree}: [OOV]𝓟[ty]60{Tree} = {root: 𝓛12643{undefined}};
𝓟92{insert}(𝓟273{tree},𝓟61{createNode}(𝓛8745{Number}))
𝓟92{insert}(𝓟273{tree},𝓟61{createNode}(𝓛8745{Number}))
𝓟92{insert}(𝓟273{tree},𝓟61{createNode}(𝓛8745{Number}))
𝓟92{insert}(𝓟273{tree},𝓟61{createNode}(𝓛8745{Number}))
𝓟92{insert}(𝓟273{tree},𝓟61{createNode}(𝓛8745{Number}))
𝓟92{insert}(𝓟273{tree},𝓟61{createNode}(𝓛8745{Number}))
𝓟92{insert}(𝓟273{tree},𝓟61{createNode}(𝓛8745{Number}))
𝓟92{insert}(𝓟273{tree},𝓟61{createNode}(𝓛8745{Number}))
𝓟92{insert}(𝓟273{tree},𝓟61{createNode}(𝓛8745{Number}))
𝓛10036{expect}(𝓟273{tree}.root).toMatchSnapshot(𝓛8743{String})
}
𝓛10038{it}(𝓛8743{String},𝓟271{$Lambda74})
}
𝓛10037{describe}(𝓛8743{String},𝓟261{$Lambda71})
function 𝓟274{$Lambda75} (): (𝓟275: [miss]𝓛[ty]10033{Void})
{
function 𝓟276{$Lambda76} (): (𝓟277: [miss]𝓛[ty]10033{Void})
{
const 𝓟278{tree}: [OOV]𝓟[ty]60{Tree} = {root: 𝓟215{createBST}()};
const 𝓟279{node20}: [OOV]𝓟[ty]59{Node} = 𝓟278{tree}.root.right.right;
const 𝓟280{replacement}: [OOV]𝓟[ty]59{Node} = 𝓟61{createNode}(𝓛8745{Number});
𝓟98{transplant}(𝓟278{tree},𝓟279{node20},𝓟280{replacement})
𝓛10036{expect}(𝓟278{tree}.root.right.right.key).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟278{tree}.root.right.right.parent.key).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟276{$Lambda76})
function 𝓟281{$Lambda77} (): (𝓟282: [miss]𝓛[ty]10033{Void})
{
const 𝓟283{tree}: [OOV]𝓟[ty]60{Tree} = {root: 𝓟215{createBST}()};
const 𝓟284{node20}: [OOV]𝓟[ty]59{Node} = 𝓟283{tree}.root.right.right;
𝓟103{remove}(𝓟283{tree},𝓟284{node20})
𝓛10036{expect}(𝓟283{tree}.root.right.right).toBe(𝓛12643{undefined})
}
𝓛10038{it}(𝓛8743{String},𝓟281{$Lambda77})
function 𝓟285{$Lambda78} (): (𝓟286: [miss]𝓛[ty]10033{Void})
{
const 𝓟287{tree}: [OOV]𝓟[ty]60{Tree} = {root: 𝓟215{createBST}()};
const 𝓟288{node18}: [OOV]𝓟[ty]59{Node} = 𝓟287{tree}.root.right;
𝓟103{remove}(𝓟287{tree},𝓟288{node18})
𝓛10036{expect}(𝓟287{tree}.root.right.key).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟285{$Lambda78})
function 𝓟289{$Lambda79} (): (𝓟290: [miss]𝓛[ty]10033{Void})
{
const 𝓟291{tree}: [OOV]𝓟[ty]60{Tree} = {root: 𝓟215{createBST}()};
𝓟103{remove}(𝓟291{tree},𝓟291{tree}.root)
𝓛10036{expect}(𝓟291{tree}.root.key).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟291{tree}.root.right.left).toBe(𝓛12643{undefined})
}
𝓛10038{it}(𝓛8743{String},𝓟289{$Lambda79})
}
𝓛10037{describe}(𝓛8743{String},𝓟274{$Lambda75})
Module: algorithms/misc/priority-queue/priority-queue
function 𝓟292{maximum} (𝓟293{queue}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟294: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}))
{
return 𝓟294 = 𝓟709{head}(𝓟293{queue})
}
function 𝓟295{extractMax} (𝓟296{queue}: 𝓛[ty]8670{Array}): (𝓟297: (𝓛[ty]8654{Promise} ≠ 𝓛[ty]8655{Number}))
{
const 𝓟298{max}: [miss]𝓛[ty]8655{Number} = 𝓟292{maximum}(𝓟296{queue});
𝓟179{setHead}(𝓟296{queue},𝓟710{last}(𝓟296{queue}))
𝓟296{queue}.pop()
𝓟378{maxHeapify}(𝓟296{queue},𝓛8745{Number},𝓟296{queue}.length)
return 𝓟297 = 𝓟298{max}
}
function 𝓟299{isParentInvalid} (𝓟300{queue}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}),𝓟301{index}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟302: 𝓛[ty]8666{Boolean})
{
return 𝓟302 = 𝓛1{<UNKNOWN>}(𝓟300{queue}.access(𝓟365{parent}(𝓟301{index})),𝓟300{queue}.access(𝓟301{index}))
}
function 𝓟303{increasePriority} (𝓟304{queue}: 𝓛[ty]8670{Array},𝓟305{index}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟306{increase}: 𝓛[ty]8655{Number}): (𝓟307: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}))
{
𝓛12564{FirstCompoundAssignment}(𝓟304{queue}.access(𝓟305{index}),𝓟306{increase})
let 𝓟308{validHeapIndex}: [miss]𝓛[ty]8655{Number} = 𝓟305{index};
while (𝓛12592{AmpersandAmpersandToken}(𝓟299{isParentInvalid}(𝓟304{queue},𝓟308{validHeapIndex}),𝓛12612{ExclamationEqualsEqualsToken}(𝓟308{validHeapIndex},𝓛8745{Number})))
{
𝓟183{swap}(𝓟304{queue},𝓟308{validHeapIndex},𝓟365{parent}(𝓟308{validHeapIndex}))
𝓟308{validHeapIndex} ⟵ 𝓟365{parent}(𝓟308{validHeapIndex});
}
return 𝓟307 = 𝓟304{queue}
}
function 𝓟309{insert} (𝓟310{queue}: 𝓛[ty]8670{Array},𝓟311{value}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟312: 𝓛[ty]8670{Array})
{
𝓟310{queue}.push(𝓛8745{Number})
𝓟303{increasePriority}(𝓟310{queue},𝓛12616{MinusToken}(𝓟310{queue}.length,𝓛8745{Number}),𝓟311{value})
return 𝓟312 = 𝓟310{queue}
}
Module: algorithms/misc/change-making/change-making.spec
function 𝓟313{$Lambda3} (): (𝓟314: [miss]𝓛[ty]10033{Void})
{
function 𝓟315{$Lambda4} (): (𝓟316: [miss]𝓛[ty]10033{Void})
{
const 𝓟317{coins}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟318{result}: [miss]𝓛[ty]8655{Number} = 𝓟39{changeMaking}(𝓟317{coins},𝓛8745{Number});
𝓛10036{expect}(𝓟318{result}).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟315{$Lambda4})
function 𝓟319{$Lambda5} (): (𝓟320: [miss]𝓛[ty]10033{Void})
{
const 𝓟321{coins}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟322{result}: [miss]𝓛[ty]8655{Number} = 𝓟39{changeMaking}(𝓟321{coins},𝓛8745{Number});
𝓛10036{expect}(𝓟322{result}).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟319{$Lambda5})
function 𝓟323{$Lambda6} (): (𝓟324: [miss]𝓛[ty]10033{Void})
{
const 𝓟325{coins}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
𝓛10036{expect}(𝓟39{changeMaking}(𝓟325{coins},𝓛8745{Number})).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟39{changeMaking}(𝓟325{coins},𝓛8745{Number})).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟39{changeMaking}(𝓟325{coins},𝓛8745{Number})).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟39{changeMaking}(𝓟325{coins},𝓛8745{Number})).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟323{$Lambda6})
}
𝓛10037{describe}(𝓛8743{String},𝓟313{$Lambda3})
Module: algorithms/misc/longest-common-subsequence/longest-common-subsequence
function 𝓟326{lcsLengths} (𝓟327{seqA}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]10051{String}),𝓟328{seqB}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]10051{String})): (𝓟329: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}))
{
const 𝓟330{lengthA}: [miss]𝓛[ty]8655{Number} = 𝓟327{seqA}.length;
const 𝓟331{lengthB}: [miss]𝓛[ty]8655{Number} = 𝓟328{seqB}.length;
const 𝓟332{lengths}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}) = 𝓛8757{Array}.CONSTRUCTOR(𝓛12641{PlusToken}(𝓟330{lengthA},𝓛8745{Number}));
function 𝓟333{$Lambda23} (): (𝓟334: [miss]𝓛[ty]8670{Array})
{
return 𝓟334 = 𝓛8757{Array}.CONSTRUCTOR(𝓛12641{PlusToken}(𝓟331{lengthB},𝓛8745{Number}))
}
𝓟154{fill}(𝓟332{lengths},𝓟333{$Lambda23})
function 𝓟335{$Lambda24} (𝓟336{i}): (𝓟337: [miss]𝓛[ty]8655{Number})
{
return 𝓟337 = 𝓛1{<UNKNOWN>}(𝓟332{lengths}.access(𝓟336{i}).access(𝓛8745{Number}),𝓛8745{Number})
}
𝓟167{range}(𝓛8745{Number},𝓟330{lengthA}).forEach(𝓟335{$Lambda24})
function 𝓟338{$Lambda25} (𝓟339{i}): (𝓟340: [miss]𝓛[ty]8655{Number})
{
return 𝓟340 = 𝓛1{<UNKNOWN>}(𝓟332{lengths}.access(𝓛8745{Number}).access(𝓟339{i}),𝓛8745{Number})
}
𝓟167{range}(𝓛8745{Number},𝓟331{lengthB}).forEach(𝓟338{$Lambda25})
function 𝓟341{$Lambda26} (𝓟342{indexA}): (𝓟343: [miss]𝓛[ty]10033{Void})
{
function 𝓟344{$Lambda27} (𝓟345{indexB}): (𝓟346: [miss]𝓛[ty]10033{Void})
{
const 𝓟347{charA}: [miss]𝓛[ty]10051{String} = 𝓟327{seqA}.access(𝓟342{indexA});
const 𝓟348{charB}: [miss]𝓛[ty]10051{String} = 𝓟328{seqB}.access(𝓟345{indexB});
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟347{charA},𝓟348{charB}))
{
𝓟332{lengths}.access(𝓛12641{PlusToken}(𝓟342{indexA},𝓛8745{Number})).access(𝓛12641{PlusToken}(𝓟345{indexB},𝓛8745{Number})) ⟵ 𝓛12641{PlusToken}(𝓟332{lengths}.access(𝓟342{indexA}).access(𝓟345{indexB}),𝓛8745{Number});
}
else
{
const 𝓟349{subSeqALength}: [miss]𝓛[ty]8655{Number} = 𝓟332{lengths}.access(𝓟342{indexA}).access(𝓛12641{PlusToken}(𝓟345{indexB},𝓛8745{Number}));
const 𝓟350{subSeqBLength}: [miss]𝓛[ty]8655{Number} = 𝓟332{lengths}.access(𝓛12641{PlusToken}(𝓟342{indexA},𝓛8745{Number})).access(𝓟345{indexB});
𝓟332{lengths}.access(𝓛12641{PlusToken}(𝓟342{indexA},𝓛8745{Number})).access(𝓛12641{PlusToken}(𝓟345{indexB},𝓛8745{Number})) ⟵ 𝓛8746{Math}.max(𝓟349{subSeqALength},𝓟350{subSeqBLength});
}
}
𝓟167{range}(𝓛8745{Number},𝓛12616{MinusToken}(𝓟331{lengthB},𝓛8745{Number})).forEach(𝓟344{$Lambda27})
}
𝓟167{range}(𝓛8745{Number},𝓛12616{MinusToken}(𝓟330{lengthA},𝓛8745{Number})).forEach(𝓟341{$Lambda26})
return 𝓟329 = 𝓟332{lengths}
}
function 𝓟351{walkLCS} (𝓟352{lengths}: 𝓛[ty]8670{Array},𝓟353{seqA}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]10051{String}),𝓟354{seqB}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]10051{String}),𝓟355{indexA}: 𝓛[ty]8655{Number},𝓟356{indexB}: 𝓛[ty]8655{Number}): (𝓟357: 𝓛[ty]10051{String})
{
if (𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟355{indexA},𝓛8745{Number}),𝓛12559{EqualsEqualsEqualsToken}(𝓟356{indexB},𝓛8745{Number})))
{
return 𝓟357 = 𝓛8743{String}
}
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟353{seqA}.access(𝓛12616{MinusToken}(𝓟355{indexA},𝓛8745{Number})),𝓟354{seqB}.access(𝓛12616{MinusToken}(𝓟356{indexB},𝓛8745{Number}))))
{
const 𝓟358{subLCS}: [miss]𝓛[ty]10051{String} = 𝓟351{walkLCS}(𝓟352{lengths},𝓟353{seqA},𝓟354{seqB},𝓛12616{MinusToken}(𝓟355{indexA},𝓛8745{Number}),𝓛12616{MinusToken}(𝓟356{indexB},𝓛8745{Number}));
return 𝓟357 = 𝓛12641{PlusToken}(𝓟358{subLCS},𝓟353{seqA}.access(𝓛12616{MinusToken}(𝓟355{indexA},𝓛8745{Number})))
}
else
{
if (𝓛12596{GreaterThanEqualsToken}(𝓟352{lengths}.access(𝓛12616{MinusToken}(𝓟355{indexA},𝓛8745{Number})).access(𝓟356{indexB}),𝓟352{lengths}.access(𝓟355{indexA}).access(𝓛12616{MinusToken}(𝓟356{indexB},𝓛8745{Number}))))
{
return 𝓟357 = 𝓟351{walkLCS}(𝓟352{lengths},𝓟353{seqA},𝓟354{seqB},𝓛12616{MinusToken}(𝓟355{indexA},𝓛8745{Number}),𝓟356{indexB})
}
else
{
return 𝓟357 = 𝓟351{walkLCS}(𝓟352{lengths},𝓟353{seqA},𝓟354{seqB},𝓟355{indexA},𝓛12616{MinusToken}(𝓟356{indexB},𝓛8745{Number}))
}
}
}
function 𝓟359{findLCS} (𝓟360{seqA}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]10051{String}),𝓟361{seqB}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]10051{String})): (𝓟362: 𝓛[ty]10051{String})
{
const 𝓟363{lengths}: [miss]𝓛[ty]8670{Array} = 𝓟326{lcsLengths}(𝓟360{seqA},𝓟361{seqB});
const 𝓟364{lcs}: [miss]𝓛[ty]10051{String} = 𝓟351{walkLCS}(𝓟363{lengths},𝓟360{seqA},𝓟361{seqB},𝓟360{seqA}.length,𝓟361{seqB}.length);
return 𝓟362 = 𝓟364{lcs}
}
Module: algorithms/sort/heap-sort/heap-sort
function 𝓟365{parent} (𝓟366{index}: 𝓛[ty]8655{Number}): (𝓟367: 𝓛[ty]8655{Number})
{
return 𝓟367 = 𝓛8746{Math}.floor(𝓛12573{SlashToken}(𝓛12616{MinusToken}(𝓟366{index},𝓛8745{Number}),𝓛8745{Number}))
}
function 𝓟368{left} (𝓟369{index}: 𝓛[ty]8655{Number}): (𝓟370: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}))
{
return 𝓟370 = 𝓛12641{PlusToken}(𝓛12548{AsteriskToken}(𝓛8745{Number},𝓟369{index}),𝓛8745{Number})
}
function 𝓟371{right} (𝓟372{index}: 𝓛[ty]8655{Number}): (𝓟373: 𝓛[ty]8655{Number})
{
return 𝓟373 = 𝓛12548{AsteriskToken}(𝓛8745{Number},𝓛12641{PlusToken}(𝓟372{index},𝓛8745{Number}))
}
function 𝓟374{isInHeap} (𝓟375{index}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟376{heapSize}: 𝓛[ty]8655{Number}): (𝓟377: 𝓛[ty]8666{Boolean})
{
return 𝓟377 = 𝓛1{<UNKNOWN>}(𝓟375{index},𝓟376{heapSize})
}
function 𝓟378{maxHeapify} (𝓟379{input}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}),𝓟380{index}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟381{heapSize}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟382: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}))
{
const 𝓟383{leftChild}: [miss]𝓛[ty]8655{Number} = 𝓟368{left}(𝓟380{index});
const 𝓟384{rightChild}: [miss]𝓛[ty]8655{Number} = 𝓟371{right}(𝓟380{index});
let 𝓟385{maxIndex}: [miss]𝓛[ty]8655{Number} = 𝓟380{index};
if (𝓛12592{AmpersandAmpersandToken}(𝓟374{isInHeap}(𝓟383{leftChild},𝓟381{heapSize}),𝓛12595{GreaterThanToken}(𝓟379{input}.access(𝓟383{leftChild}),𝓟379{input}.access(𝓟380{index}))))
{
𝓟385{maxIndex} ⟵ 𝓟383{leftChild};
}
if (𝓛12592{AmpersandAmpersandToken}(𝓟374{isInHeap}(𝓟384{rightChild},𝓟381{heapSize}),𝓛12595{GreaterThanToken}(𝓟379{input}.access(𝓟384{rightChild}),𝓟379{input}.access(𝓟385{maxIndex}))))
{
𝓟385{maxIndex} ⟵ 𝓟384{rightChild};
}
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟385{maxIndex},𝓟380{index}))
{
𝓟183{swap}(𝓟379{input},𝓟380{index},𝓟385{maxIndex})
𝓟378{maxHeapify}(𝓟379{input},𝓟385{maxIndex},𝓟381{heapSize})
}
return 𝓟382 = 𝓟379{input}
}
function 𝓟386{buildMaxHeap} (𝓟387{input}: 𝓛[ty]8670{Array}): (𝓟388: 𝓛[ty]8670{Array})
{
const 𝓟389{firstLeaf}: [miss]𝓛[ty]8655{Number} = 𝓛8746{Math}.floor(𝓛12573{SlashToken}(𝓛12616{MinusToken}(𝓟387{input}.length,𝓛8745{Number}),𝓛8745{Number}));
function 𝓟390{$Lambda94} (𝓟391{index}): (𝓟392: [miss]𝓛[ty]10033{Void})
{
𝓟378{maxHeapify}(𝓟387{input},𝓟391{index},𝓟387{input}.length)
}
𝓟171{reverseRange}(𝓟389{firstLeaf}).forEach(𝓟390{$Lambda94})
return 𝓟388 = 𝓟387{input}
}
function 𝓟393{heapSort} (𝓟394{input}: 𝓛[ty]8670{Array}): (𝓟395: 𝓛[ty]8670{Array})
{
𝓟386{buildMaxHeap}(𝓟394{input})
function 𝓟396{$Lambda95} (𝓟397{heapEnd}): (𝓟398: [miss]𝓛[ty]10033{Void})
{
𝓟183{swap}(𝓟394{input},𝓛8745{Number},𝓟397{heapEnd})
𝓟378{maxHeapify}(𝓟394{input},𝓛8745{Number},𝓟397{heapEnd})
}
𝓟171{reverseRange}(𝓛12616{MinusToken}(𝓟394{input}.length,𝓛8745{Number})).forEach(𝓟396{$Lambda95})
return 𝓟395 = 𝓟394{input}
}
Module: algorithms/sort/counting-sort/counting-sort
function 𝓟399{countingSort} (𝓟400{input}: 𝓛[ty]8670{Array},𝓟401{max}: 𝓛[ty]8655{Number}): (𝓟402: 𝓛[ty]8670{Array})
{
const 𝓟403{result}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}();
const 𝓟404{counter}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}.CONSTRUCTOR(𝓛12641{PlusToken}(𝓟401{max},𝓛8745{Number}));
𝓟404{counter}.fill(𝓛8745{Number})
function 𝓟405{$Lambda82} (𝓟406{value}): (𝓟407: [OOV]any)
{
return 𝓟407 = 𝓛12564{FirstCompoundAssignment}(𝓟404{counter}.access(𝓟406{value}),𝓛8745{Number})
}
𝓟400{input}.forEach(𝓟405{$Lambda82})
function 𝓟408{$Lambda83} (𝓟409{index}): (𝓟410: [miss]𝓛[ty]10033{Void})
{
return 𝓟410 = 𝓟159{increaseOfPrevious}(𝓟404{counter},𝓟409{index})
}
𝓟167{range}(𝓛8745{Number},𝓟401{max}).forEach(𝓟408{$Lambda83})
function 𝓟411{$Lambda84} (𝓟412{value}): (𝓟413: [miss]𝓛[ty]10033{Void})
{
𝓛12606{MinusEqualsToken}(𝓟404{counter}.access(𝓟412{value}),𝓛8745{Number})
const 𝓟414{position} = 𝓟404{counter}.access(𝓟412{value});
𝓟403{result}.access(𝓟414{position}) ⟵ 𝓟412{value};
}
𝓟711{forEachRight}(𝓟400{input},𝓟411{$Lambda84})
return 𝓟402 = 𝓟403{result}
}
Module: algorithms/sort/merge-sort/merge-sort
function 𝓟415{merge} (𝓟416{input}: 𝓛[ty]8670{Array},𝓟417{start}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟418{mid}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8655{Number}),𝓟419{end}: 𝓛[ty]8655{Number}): (𝓟420: [miss]𝓛[ty]8670{Array})
{
const 𝓟421{left}: [miss]𝓛[ty]8670{Array} = 𝓟416{input}.slice(𝓟417{start},𝓟418{mid});
const 𝓟422{right}: [miss]𝓛[ty]8670{Array} = 𝓟416{input}.slice(𝓟418{mid},𝓟419{end});
𝓟421{left}.access(𝓟421{left}.length) ⟵ 𝓛8706{Infinity} as any;
𝓟422{right}.access(𝓟422{right}.length) ⟵ 𝓛8706{Infinity} as any;
function 𝓟423{$Lambda105} (𝓟424{index}): (𝓟425: [miss]𝓛[ty]10033{Void})
{
if (𝓛12582{LessThanEqualsToken}(𝓟709{head}(𝓟421{left}),𝓟709{head}(𝓟422{right})))
{
𝓟416{input}.access(𝓟424{index}) ⟵ 𝓟421{left}.shift();
}
else
{
𝓟416{input}.access(𝓟424{index}) ⟵ 𝓟422{right}.shift();
}
}
𝓟167{range}(𝓟417{start},𝓛12616{MinusToken}(𝓟419{end},𝓛8745{Number})).forEach(𝓟423{$Lambda105})
return 𝓟420 = 𝓟416{input}
}
function 𝓟426{mergeSort} (𝓟427{input}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}),𝓟428{start},𝓟429{end}): (𝓟430: 𝓛[ty]8670{Array})
{
if (𝓛12582{LessThanEqualsToken}(𝓛12616{MinusToken}(𝓟429{end},𝓟428{start}),𝓛8745{Number}))
{
return 𝓟430 = 𝓛8757{Array}()
}
const 𝓟431{mid}: [miss]𝓛[ty]8655{Number} = 𝓛8746{Math}.floor(𝓛12573{SlashToken}(𝓛12641{PlusToken}(𝓟428{start},𝓟429{end}),𝓛8745{Number}));
𝓟426{mergeSort}(𝓟427{input},𝓟428{start},𝓟431{mid})
𝓟426{mergeSort}(𝓟427{input},𝓟431{mid},𝓟429{end})
return 𝓟430 = 𝓟415{merge}(𝓟427{input},𝓟428{start},𝓟431{mid},𝓟429{end})
}
Module: algorithms/sort/merge-and-insertion-sort/merge-and-insertion-sort.spec
function 𝓟432{$Lambda99} (): (𝓟433: [miss]𝓛[ty]10033{Void})
{
function 𝓟434{$Lambda100} (): (𝓟435: [miss]𝓛[ty]10033{Void})
{
const 𝓟436{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟437{result}: [miss]𝓛[ty]8670{Array} = 𝓟471{mergeAndInsertionSort}(𝓟436{input});
𝓛10036{expect}(𝓟437{result}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number}))
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟434{$Lambda100})
}
𝓛10037{describe}(𝓛8743{String},𝓟432{$Lambda99})
Module: algorithms/search/binary-search/binary-search
function 𝓟438{binarySearch} (𝓟439{input}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}),𝓟440{value}: 𝓛[ty]8655{Number},𝓟441{start}: 𝓛[ty]8655{Number},𝓟442{end}: 𝓛[ty]8655{Number}): (𝓟443: 𝓛[ty]8655{Number})
{
if (𝓛12546{BarBarToken}(𝓛12546{BarBarToken}(𝓛12595{GreaterThanToken}(𝓟441{start},𝓟442{end}),𝓛1{<UNKNOWN>}(𝓟440{value},𝓟439{input}.access(𝓟441{start}))),𝓛12595{GreaterThanToken}(𝓟440{value},𝓟439{input}.access(𝓟442{end}))))
{
return 𝓟443 = 𝓛12643{undefined}
}
const 𝓟444{mid}: [miss]𝓛[ty]8655{Number} = 𝓛8746{Math}.floor(𝓛12573{SlashToken}(𝓛12641{PlusToken}(𝓟442{end},𝓟441{start}),𝓛8745{Number}));
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟439{input}.access(𝓟444{mid}),𝓟440{value}))
{
return 𝓟443 = 𝓟444{mid}
}
else
{
if (𝓛1{<UNKNOWN>}(𝓟439{input}.access(𝓟444{mid}),𝓟440{value}))
{
return 𝓟443 = 𝓟438{binarySearch}(𝓟439{input},𝓟440{value},𝓛12641{PlusToken}(𝓟444{mid},𝓛8745{Number}),𝓟442{end})
}
else
{
return 𝓟443 = 𝓟438{binarySearch}(𝓟439{input},𝓟440{value},𝓟441{start},𝓛12616{MinusToken}(𝓟444{mid},𝓛8745{Number}))
}
}
}
Module: algorithms/sort/selection-sort/selection-sort.spec
function 𝓟445{$Lambda118} (): (𝓟446: [miss]𝓛[ty]10033{Void})
{
function 𝓟447{$Lambda119} (): (𝓟448: [miss]𝓛[ty]10033{Void})
{
const 𝓟449{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟450{result}: [miss]𝓛[ty]8670{Array} = 𝓟30{selectionSort}(𝓟449{input});
𝓛10036{expect}(𝓟450{result}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number}))
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟447{$Lambda119})
}
𝓛10037{describe}(𝓛8743{String},𝓟445{$Lambda118})
Module: algorithms/misc/longest-common-subsequence/longest-common-subsequence.spec
function 𝓟451{$Lambda19} (): (𝓟452: [miss]𝓛[ty]10033{Void})
{
function 𝓟453{$Lambda20} (): (𝓟454: [miss]𝓛[ty]10033{Void})
{
const 𝓟455{seqA}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
const 𝓟456{seqB}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
const 𝓟457{lengths}: [miss]𝓛[ty]8670{Array} = 𝓟326{lcsLengths}(𝓟455{seqA},𝓟456{seqB});
𝓟457{lengths} as any.y ⟵ 𝓛12641{PlusToken}(𝓛8743{String},𝓟455{seqA});
𝓟457{lengths} as any.x ⟵ 𝓛12641{PlusToken}(𝓛8743{String},𝓟456{seqB});
𝓛10036{expect}(𝓟457{lengths}).toMatchSnapshot(𝓛8743{String})
}
𝓛10038{it}(𝓛8743{String},𝓟453{$Lambda20})
}
𝓛10037{describe}(𝓛8743{String},𝓟451{$Lambda19})
function 𝓟458{$Lambda21} (): (𝓟459: [miss]𝓛[ty]10033{Void})
{
function 𝓟460{$Lambda22} (): (𝓟461: [miss]𝓛[ty]10033{Void})
{
const 𝓟462{seqA}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
const 𝓟463{seqB}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
const 𝓟464{lcs}: [miss]𝓛[ty]10051{String} = 𝓟359{findLCS}(𝓟462{seqA},𝓟463{seqB});
𝓛10036{expect}(𝓟464{lcs}).toBe(𝓛8743{String})
}
𝓛10038{it}(𝓛8743{String},𝓟460{$Lambda22})
}
𝓛10037{describe}(𝓛8743{String},𝓟458{$Lambda21})
Module: algorithms/misc/inversions-count/inversions-count.spec
function 𝓟465{$Lambda16} (): (𝓟466: [miss]𝓛[ty]10033{Void})
{
function 𝓟467{$Lambda17} (): (𝓟468: [miss]𝓛[ty]10033{Void})
{
const 𝓟469{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟470{count}: [miss]𝓛[ty]8655{Number} = 𝓟201{countInversions}(𝓟469{input});
𝓛10036{expect}(𝓟470{count}).toBe(𝓛8745{Number})
}
𝓛10038{it}(𝓛8743{String},𝓟467{$Lambda17})
}
𝓛10037{describe}(𝓛8743{String},𝓟465{$Lambda16})
Module: algorithms/sort/merge-and-insertion-sort/merge-and-insertion-sort
function 𝓟471{mergeAndInsertionSort} (𝓟472{input}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}),𝓟473{start},𝓟474{end},𝓟475{threshold}): (𝓟476: 𝓛[ty]8670{Array})
{
if (𝓛12582{LessThanEqualsToken}(𝓛12616{MinusToken}(𝓟474{end},𝓟473{start}),𝓛8745{Number}))
{
return 𝓟476 = 𝓛8757{Array}()
}
if (𝓛12582{LessThanEqualsToken}(𝓛12616{MinusToken}(𝓟474{end},𝓟473{start}),𝓟475{threshold}))
{
return 𝓟476 = 𝓟564{insertionSort}(𝓟472{input})
}
const 𝓟477{mid}: [miss]𝓛[ty]8655{Number} = 𝓛8746{Math}.floor(𝓛12573{SlashToken}(𝓛12641{PlusToken}(𝓟473{start},𝓟474{end}),𝓛8745{Number}));
𝓟471{mergeAndInsertionSort}(𝓟472{input},𝓟473{start},𝓟477{mid})
𝓟471{mergeAndInsertionSort}(𝓟472{input},𝓟477{mid},𝓟474{end})
return 𝓟476 = 𝓟415{merge}(𝓟472{input},𝓟473{start},𝓟477{mid},𝓟474{end})
}
Module: algorithms/misc/priority-queue/priority-queue.spec
function 𝓟478{$Lambda34} (): (𝓟479: [miss]𝓛[ty]10033{Void})
{
function 𝓟480{$Lambda35} (): (𝓟481: [miss]𝓛[ty]10033{Void})
{
const 𝓟482{queue}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟483{max}: [miss]𝓛[ty]8655{Number} = 𝓟295{extractMax}(𝓟482{queue});
𝓛10036{expect}(𝓟483{max}).toBe(𝓛8745{Number})
𝓛10036{expect}(𝓟482{queue}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number}))
}
𝓛10038{it}(𝓛8743{String},𝓟480{$Lambda35})
}
𝓛10037{describe}(𝓛8743{String},𝓟478{$Lambda34})
function 𝓟484{$Lambda36} (): (𝓟485: [miss]𝓛[ty]10033{Void})
{
function 𝓟486{$Lambda37} (): (𝓟487: [miss]𝓛[ty]10033{Void})
{
const 𝓟488{queue}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
𝓟303{increasePriority}(𝓟488{queue},𝓛8745{Number},𝓛8745{Number})
𝓛10036{expect}(𝓟488{queue}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number}))
}
𝓛10038{it}(𝓛8743{String},𝓟486{$Lambda37})
}
𝓛10037{describe}(𝓛8743{String},𝓟484{$Lambda36})
function 𝓟489{$Lambda38} (): (𝓟490: [miss]𝓛[ty]10033{Void})
{
function 𝓟491{$Lambda39} (): (𝓟492: [miss]𝓛[ty]10033{Void})
{
const 𝓟493{queue}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}();
𝓟309{insert}(𝓟493{queue},𝓛8745{Number})
𝓟309{insert}(𝓟493{queue},𝓛8745{Number})
𝓟309{insert}(𝓟493{queue},𝓛8745{Number})
𝓟309{insert}(𝓟493{queue},𝓛8745{Number})
𝓟309{insert}(𝓟493{queue},𝓛8745{Number})
𝓟309{insert}(𝓟493{queue},𝓛8745{Number})
𝓛10036{expect}(𝓟493{queue}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number}))
}
𝓛10038{it}(𝓛8743{String},𝓟491{$Lambda39})
function 𝓟494{$Lambda40} (): (𝓟495: [miss]𝓛[ty]10033{Void})
{
const 𝓟496{queue}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
𝓟309{insert}(𝓟496{queue},𝓛8745{Number})
𝓛10036{expect}(𝓟496{queue}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number}))
}
𝓛10038{it}(𝓛8743{String},𝓟494{$Lambda40})
}
𝓛10037{describe}(𝓛8743{String},𝓟489{$Lambda38})
Module: algorithms/misc/huffman/huffman.spec
function 𝓟497{$Lambda10} (): (𝓟498: [miss]𝓛[ty]10033{Void})
{
function 𝓟499{$Lambda11} (): (𝓟500: [miss]𝓛[ty]10033{Void})
{
const 𝓟501{frequences}: 𝓛[ty]8670{Array} = 𝓛8757{Array}({char: 𝓛8743{String},frequency: 𝓛8745{Number}},{char: 𝓛8743{String},frequency: 𝓛8745{Number}},{char: 𝓛8743{String},frequency: 𝓛8745{Number}},{char: 𝓛8743{String},frequency: 𝓛8745{Number}},{char: 𝓛8743{String},frequency: 𝓛8745{Number}},{char: 𝓛8743{String},frequency: 𝓛8745{Number}});
const 𝓟502{tree} = 𝓟542{huffman}(𝓟501{frequences});
function 𝓟503{$Lambda12} (𝓟504{node}): (𝓟505: [miss]𝓛[ty]8642{Object})
{
const 𝓟506{key} = (𝓟504{node}.char ? 𝓛12607{$Template}(𝓟504{node}.char,𝓟504{node}.frequency) : 𝓟504{node}.frequency;
return 𝓟505 = {key: 𝓟506{key},left: 𝓟504{node}.left,right: 𝓟504{node}.right}
}
const 𝓟507{serializable}: [miss]𝓛[ty]10619{Node} = 𝓟175{toSerializableTree}(𝓟502{tree},𝓟503{$Lambda12});
𝓛10036{expect}(𝓟502{tree}).toMatchSnapshot(𝓛8743{String})
}
𝓛10038{it}(𝓛8743{String},𝓟499{$Lambda11})
}
𝓛10037{describe}(𝓛8743{String},𝓟497{$Lambda10})
Module: algorithms/misc/maximum-subarray/maximum-subarray
function 𝓟508{maxCrossSubarray} (𝓟509{input}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}),𝓟510{start}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟511{mid}: 𝓛[ty]8655{Number},𝓟512{end}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟513: 𝓛[ty]8642{Object})
{
let 𝓟514{leftIndex}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓛8745{Number});
let 𝓟515{leftMaxSum}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓛8706{Infinity});
let 𝓟516{sum}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
function 𝓟517{$Lambda32} (𝓟518{index}): (𝓟519: [miss]𝓛[ty]10033{Void})
{
𝓛12564{FirstCompoundAssignment}(𝓟516{sum},𝓟509{input}.access(𝓟518{index}))
if (𝓛12595{GreaterThanToken}(𝓟516{sum},𝓟515{leftMaxSum}))
{
𝓟515{leftMaxSum} ⟵ 𝓟516{sum};
𝓟514{leftIndex} ⟵ 𝓟518{index};
}
}
𝓟171{reverseRange}(𝓟511{mid},𝓟510{start}).forEach(𝓟517{$Lambda32})
let 𝓟520{rightIndex}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓛8745{Number});
let 𝓟521{rightMaxSum}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓛8706{Infinity});
𝓟516{sum} ⟵ 𝓛8745{Number};
function 𝓟522{$Lambda33} (𝓟523{index}): (𝓟524: [miss]𝓛[ty]10033{Void})
{
𝓛12564{FirstCompoundAssignment}(𝓟516{sum},𝓟509{input}.access(𝓟523{index}))
if (𝓛12595{GreaterThanToken}(𝓟516{sum},𝓟521{rightMaxSum}))
{
𝓟521{rightMaxSum} ⟵ 𝓟516{sum};
𝓟520{rightIndex} ⟵ 𝓟523{index};
}
}
𝓟167{range}(𝓛12641{PlusToken}(𝓟511{mid},𝓛8745{Number}),𝓟512{end}).forEach(𝓟522{$Lambda33})
return 𝓟513 = {start: 𝓟514{leftIndex},end: 𝓟520{rightIndex},sum: 𝓛12641{PlusToken}(𝓟515{leftMaxSum},𝓟521{rightMaxSum})}
}
function 𝓟525{maxSubarray} (𝓟526{input}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}),𝓟527{start}: 𝓛[ty]8655{Number},𝓟528{end}: 𝓛[ty]8655{Number}): (𝓟529: 𝓛[ty]8642{Object})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12616{MinusToken}(𝓟528{end},𝓟527{start}),𝓛8745{Number}))
{
return 𝓟529 = {start: 𝓟527{start},end: 𝓟528{end},sum: 𝓟526{input}.access(𝓟527{start})}
}
const 𝓟530{mid}: [miss]𝓛[ty]8655{Number} = 𝓛8746{Math}.floor(𝓛12573{SlashToken}(𝓛12641{PlusToken}(𝓟527{start},𝓟528{end}),𝓛8745{Number}));
const 𝓟531{leftMax}: [miss]𝓛[ty]8642{Object} = 𝓟525{maxSubarray}(𝓟526{input},𝓟527{start},𝓟530{mid});
const 𝓟532{rightMax}: [miss]𝓛[ty]8642{Object} = 𝓟525{maxSubarray}(𝓟526{input},𝓛12641{PlusToken}(𝓟530{mid},𝓛8745{Number}),𝓟528{end});
const 𝓟533{crossMax}: [miss]𝓛[ty]8642{Object} = 𝓟508{maxCrossSubarray}(𝓟526{input},𝓟527{start},𝓟530{mid},𝓟528{end});
if (𝓛12592{AmpersandAmpersandToken}(𝓛12596{GreaterThanEqualsToken}(𝓟531{leftMax}.sum,𝓟532{rightMax}.sum),𝓛12596{GreaterThanEqualsToken}(𝓟531{leftMax}.sum,𝓟533{crossMax}.sum)))
{
return 𝓟529 = 𝓟531{leftMax}
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12596{GreaterThanEqualsToken}(𝓟532{rightMax}.sum,𝓟531{leftMax}.sum),𝓛12596{GreaterThanEqualsToken}(𝓟532{rightMax}.sum,𝓟533{crossMax}.sum)))
{
return 𝓟529 = 𝓟532{rightMax}
}
else
{
return 𝓟529 = 𝓟533{crossMax}
}
}
}
Module: algorithms/misc/activity-selection/activity-selection.spec
function 𝓟534{$Lambda0} (): (𝓟535: [miss]𝓛[ty]10033{Void})
{
function 𝓟536{$Lambda1} (): (𝓟537: [miss]𝓛[ty]10033{Void})
{
const 𝓟538{activities}: 𝓛[ty]8670{Array} = 𝓛8757{Array}({start: 𝓛8745{Number},finish: 𝓛8745{Number}},{start: 𝓛8745{Number},finish: 𝓛8745{Number}},{start: 𝓛8745{Number},finish: 𝓛8745{Number}},{start: 𝓛8745{Number},finish: 𝓛8745{Number}},{start: 𝓛8745{Number},finish: 𝓛8745{Number}},{start: 𝓛8745{Number},finish: 𝓛8745{Number}},{start: 𝓛8745{Number},finish: 𝓛8745{Number}},{start: 𝓛8745{Number},finish: 𝓛8745{Number}},{start: 𝓛8745{Number},finish: 𝓛8745{Number}},{start: 𝓛8745{Number},finish: 𝓛8745{Number}},{start: 𝓛8745{Number},finish: 𝓛8745{Number}});
const 𝓟539{selected}: [miss]𝓛[ty]8670{Array} = 𝓟109{activitySelector}(𝓟538{activities});
𝓛10036{expect}(𝓟539{selected}).toEqual(𝓛8757{Array}({start: 𝓛8745{Number},finish: 𝓛8745{Number}},{start: 𝓛8745{Number},finish: 𝓛8745{Number}},{start: 𝓛8745{Number},finish: 𝓛8745{Number}},{start: 𝓛8745{Number},finish: 𝓛8745{Number}}))
}
𝓛10038{it}(𝓛8743{String},𝓟536{$Lambda1})
}
𝓛10037{describe}(𝓛8743{String},𝓟534{$Lambda0})
Module: algorithms/misc/huffman/huffman
type 𝓟[ty]540{Frequency} = {char: 𝓛[ty]10051{String}, frequency: 𝓛[ty]8655{Number}}
const 𝓟541{MinHeap} = 𝓛10097{require}(𝓛8743{String});
function 𝓟542{huffman} (𝓟543{frequences}: 𝓛[ty]8670{Array}): (𝓟544: [OOV]any)
{
function 𝓟545{$Lambda13} (𝓟546{a}: [OOV]𝓟[ty]540{Frequency},𝓟547{b}: [OOV]𝓟[ty]540{Frequency}): (𝓟548: [miss]𝓛[ty]8655{Number})
{
return 𝓟548 = 𝓛12616{MinusToken}(𝓟546{a}.frequency,𝓟547{b}.frequency)
}
const 𝓟549{queue} = 𝓟541{MinHeap}.CONSTRUCTOR(𝓟545{$Lambda13});
function 𝓟550{$Lambda14} (𝓟551{freq}): (𝓟552: [OOV]any)
{
return 𝓟552 = 𝓟549{queue}.insert(𝓟551{freq})
}
𝓟543{frequences}.forEach(𝓟550{$Lambda14})
function 𝓟553{$Lambda15} (): (𝓟554: [miss]𝓛[ty]10033{Void})
{
const 𝓟555{left}: [OOV]𝓟[ty]540{Frequency} = 𝓟549{queue}.removeHead();
const 𝓟556{right}: [OOV]𝓟[ty]540{Frequency} = 𝓟549{queue}.removeHead();
const 𝓟557{merged}: [miss]𝓛[ty]8642{Object} = {frequency: 𝓛12641{PlusToken}(𝓟555{left}.frequency,𝓟556{right}.frequency),left: 𝓟555{left},right: 𝓟556{right}};
𝓟549{queue}.insert(𝓟557{merged})
}
𝓟167{range}(𝓛8745{Number},𝓛12616{MinusToken}(𝓟543{frequences}.length,𝓛8745{Number})).forEach(𝓟553{$Lambda15})
return 𝓟544 = 𝓟549{queue}.removeHead()
}
Module: algorithms/sort/counting-sort/counting-sort.spec
function 𝓟558{$Lambda80} (): (𝓟559: [miss]𝓛[ty]10033{Void})
{
function 𝓟560{$Lambda81} (): (𝓟561: [miss]𝓛[ty]10033{Void})
{
const 𝓟562{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟563{result}: [miss]𝓛[ty]8670{Array} = 𝓟399{countingSort}(𝓟562{input},𝓟712{max}(𝓟562{input}));
𝓛10036{expect}(𝓟563{result}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number}))
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟560{$Lambda81})
}
𝓛10037{describe}(𝓛8743{String},𝓟558{$Lambda80})
Module: algorithms/sort/insertion-sort/insertion-sort
function 𝓟564{insertionSort} (𝓟565{input}: 𝓛[ty]8670{Array}): (𝓟566: 𝓛[ty]8670{Array})
{
function 𝓟567{$Lambda98} (𝓟568{pivot},𝓟569{pivotIndex}): (𝓟570: [miss]𝓛[ty]10033{Void})
{
let 𝓟571{compareIndex}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓟569{pivotIndex},𝓛8745{Number});
while (𝓛12592{AmpersandAmpersandToken}(𝓛12595{GreaterThanToken}(𝓟571{compareIndex},𝓛12616{MinusToken}(𝓛8745{Number})),𝓛12595{GreaterThanToken}(𝓟565{input}.access(𝓟571{compareIndex}),𝓟568{pivot})))
{
𝓟163{moveRight}(𝓟565{input},𝓟571{compareIndex})
𝓛12606{MinusEqualsToken}(𝓟571{compareIndex},𝓛8745{Number})
}
𝓟565{input}.access(𝓛12641{PlusToken}(𝓟571{compareIndex},𝓛8745{Number})) ⟵ 𝓟568{pivot};
}
𝓟565{input}.forEach(𝓟567{$Lambda98})
return 𝓟566 = 𝓟565{input}
}
Module: algorithms/misc/maximum-subarray/maximum-subarray.spec
function 𝓟572{$Lambda28} (): (𝓟573: [miss]𝓛[ty]10033{Void})
{
function 𝓟574{$Lambda29} (): (𝓟575: [miss]𝓛[ty]10033{Void})
{
const 𝓟576{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛12616{MinusToken}(𝓛8745{Number}),𝓛8745{Number},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛12616{MinusToken}(𝓛8745{Number}),𝓛12616{MinusToken}(𝓛8745{Number}),𝓛8745{Number},𝓛8745{Number},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛8745{Number},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛12616{MinusToken}(𝓛8745{Number}),𝓛8745{Number},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛8745{Number});
const 𝓟577{result}: [miss]𝓛[ty]8642{Object} = 𝓟508{maxCrossSubarray}(𝓟576{input},𝓛8745{Number},𝓛8745{Number},𝓛12616{MinusToken}(𝓟576{input}.length,𝓛8745{Number}));
𝓛10036{expect}(𝓟577{result}).toEqual({start: 𝓛8745{Number},end: 𝓛8745{Number},sum: 𝓛8745{Number}})
}
𝓛10038{it}(𝓛8743{String},𝓟574{$Lambda29})
}
𝓛10037{describe}(𝓛8743{String},𝓟572{$Lambda28})
function 𝓟578{$Lambda30} (): (𝓟579: [miss]𝓛[ty]10033{Void})
{
function 𝓟580{$Lambda31} (): (𝓟581: [miss]𝓛[ty]10033{Void})
{
const 𝓟582{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛12616{MinusToken}(𝓛8745{Number}),𝓛8745{Number},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛12616{MinusToken}(𝓛8745{Number}),𝓛12616{MinusToken}(𝓛8745{Number}),𝓛8745{Number},𝓛8745{Number},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛8745{Number},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛12616{MinusToken}(𝓛8745{Number}),𝓛8745{Number},𝓛12616{MinusToken}(𝓛8745{Number}),𝓛8745{Number});
const 𝓟583{result}: [miss]𝓛[ty]8642{Object} = 𝓟525{maxSubarray}(𝓟582{input},𝓛8745{Number},𝓛12616{MinusToken}(𝓟582{input}.length,𝓛8745{Number}));
𝓛10036{expect}(𝓟583{result}).toEqual({start: 𝓛8745{Number},end: 𝓛8745{Number},sum: 𝓛8745{Number}})
}
𝓛10038{it}(𝓛8743{String},𝓟580{$Lambda31})
}
𝓛10037{describe}(𝓛8743{String},𝓟578{$Lambda30})
Module: algorithms/sort/quick-sort/quick-sort.spec
const 𝓟584{last} = 𝓛10097{require}(𝓛8743{String});
function 𝓟585{$Lambda106} (): (𝓟586: [miss]𝓛[ty]10033{Void})
{
function 𝓟587{$Lambda107} (): (𝓟588: [miss]𝓛[ty]10033{Void})
{
const 𝓟589{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟590{pivotIndex}: [miss]𝓛[ty]8655{Number} = 𝓟135{partition}(𝓟589{input},𝓛8745{Number},𝓛12616{MinusToken}(𝓟589{input}.length,𝓛8745{Number}),𝓛8744{Boolean});
𝓛10036{expect}(𝓟590{pivotIndex}).toBe(𝓛8745{Number})
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟587{$Lambda107})
function 𝓟591{$Lambda108} (): (𝓟592: [miss]𝓛[ty]10033{Void})
{
const 𝓟593{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟594{pivotIndex}: [miss]𝓛[ty]8655{Number} = 𝓟135{partition}(𝓟593{input},𝓛8745{Number},𝓛12616{MinusToken}(𝓟593{input}.length,𝓛8745{Number}),𝓛8744{Boolean});
const 𝓟595{pivot}: [miss]𝓛[ty]8655{Number} = 𝓟593{input}.access(𝓟594{pivotIndex});
function 𝓟596{$Lambda109} (𝓟597{value},𝓟598{index}): (𝓟599: [miss]𝓛[ty]10033{Void})
{
if (𝓛1{<UNKNOWN>}(𝓟598{index},𝓟594{pivotIndex}))
{
𝓛10036{expect}(𝓟597{value}).toBeLessThanOrEqual(𝓟595{pivot})
}
else
{
if (𝓛12595{GreaterThanToken}(𝓟598{index},𝓟594{pivotIndex}))
{
𝓛10036{expect}(𝓟597{value}).toBeGreaterThan(𝓟595{pivot})
}
else
{
𝓛10036{expect}(𝓟597{value}).toBe(𝓟595{pivot})
}
}
}
𝓟593{input}.forEach(𝓟596{$Lambda109})
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟591{$Lambda108})
function 𝓟600{$Lambda110} (): (𝓟601: [miss]𝓛[ty]10033{Void})
{
const 𝓟602{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟603{pivot} = 𝓟584{last}(𝓟602{input});
const 𝓟604{pivotIndex}: [miss]𝓛[ty]8655{Number} = 𝓟135{partition}(𝓟602{input},𝓛8745{Number},𝓛12616{MinusToken}(𝓟602{input}.length,𝓛8745{Number}),𝓛8744{Boolean});
const 𝓟605{smaller}: [miss]𝓛[ty]8670{Array} = 𝓟602{input}.slice(𝓛8745{Number},𝓟604{pivotIndex});
function 𝓟606{$Lambda111} (𝓟607{value}): (𝓟608: [OOV]any)
{
return 𝓟608 = 𝓛10036{expect}(𝓟607{value}).toBeLessThanOrEqual(𝓟603{pivot})
}
𝓟605{smaller}.forEach(𝓟606{$Lambda111})
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟600{$Lambda110})
function 𝓟609{$Lambda112} (): (𝓟610: [miss]𝓛[ty]10033{Void})
{
const 𝓟611{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟612{pivot} = 𝓟584{last}(𝓟611{input});
const 𝓟613{pivotIndex}: [miss]𝓛[ty]8655{Number} = 𝓟135{partition}(𝓟611{input},𝓛8745{Number},𝓛12616{MinusToken}(𝓟611{input}.length,𝓛8745{Number}),𝓛8744{Boolean});
const 𝓟614{bigger}: [miss]𝓛[ty]8670{Array} = 𝓟611{input}.slice(𝓛12641{PlusToken}(𝓟613{pivotIndex},𝓛8745{Number}));
function 𝓟615{$Lambda113} (𝓟616{value}): (𝓟617: [OOV]any)
{
return 𝓟617 = 𝓛10036{expect}(𝓟616{value}).toBeGreaterThan(𝓟612{pivot})
}
𝓟614{bigger}.forEach(𝓟615{$Lambda113})
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟609{$Lambda112})
}
𝓛10037{describe}(𝓛8743{String},𝓟585{$Lambda106})
function 𝓟618{$Lambda114} (): (𝓟619: [miss]𝓛[ty]10033{Void})
{
function 𝓟620{$Lambda115} (): (𝓟621: [miss]𝓛[ty]10033{Void})
{
const 𝓟622{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟623{result}: [miss]𝓛[ty]8670{Array} = 𝓟146{quickSort}(𝓟622{input});
𝓛10036{expect}(𝓟623{result}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number}))
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟620{$Lambda115})
function 𝓟624{$Lambda116} (): (𝓟625: [miss]𝓛[ty]10033{Void})
{
const 𝓟626{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟627{result}: [miss]𝓛[ty]8670{Array} = 𝓟146{quickSort}(𝓟626{input},𝓛8745{Number},𝓛12616{MinusToken}(𝓟626{input}.length,𝓛8745{Number}),𝓛8744{Boolean});
𝓛10036{expect}(𝓟627{result}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number}))
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟624{$Lambda116})
}
𝓛10037{describe}(𝓛8743{String},𝓟618{$Lambda114})
Module: algorithms/sort/merge-sort/merge-sort.spec
function 𝓟628{$Lambda101} (): (𝓟629: [miss]𝓛[ty]10033{Void})
{
function 𝓟630{$Lambda102} (): (𝓟631: [miss]𝓛[ty]10033{Void})
{
const 𝓟632{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟633{result}: [miss]𝓛[ty]8670{Array} = 𝓟415{merge}(𝓟632{input},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
𝓛10036{expect}(𝓟633{result}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number}))
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟630{$Lambda102})
}
𝓛10037{describe}(𝓛8743{String},𝓟628{$Lambda101})
function 𝓟634{$Lambda103} (): (𝓟635: [miss]𝓛[ty]10033{Void})
{
function 𝓟636{$Lambda104} (): (𝓟637: [miss]𝓛[ty]10033{Void})
{
const 𝓟638{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟639{result}: [miss]𝓛[ty]8670{Array} = 𝓟426{mergeSort}(𝓟638{input});
𝓛10036{expect}(𝓟639{result}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number}))
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟636{$Lambda104})
}
𝓛10037{describe}(𝓛8743{String},𝓟634{$Lambda103})
Module: algorithms/sort/heap-sort/heap-sort.spec
function 𝓟640{$Lambda85} (): (𝓟641: [miss]𝓛[ty]10033{Void})
{
function 𝓟642{$Lambda86} (): (𝓟643: [miss]𝓛[ty]10033{Void})
{
𝓛10036{expect}(𝓟368{left}(𝓛8745{Number})).toEqual(𝓛8745{Number})
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟642{$Lambda86})
function 𝓟644{$Lambda87} (): (𝓟645: [miss]𝓛[ty]10033{Void})
{
𝓛10036{expect}(𝓟371{right}(𝓛8745{Number})).toEqual(𝓛8745{Number})
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟644{$Lambda87})
}
𝓛10037{describe}(𝓛8743{String},𝓟640{$Lambda85})
function 𝓟646{$Lambda88} (): (𝓟647: [miss]𝓛[ty]10033{Void})
{
function 𝓟648{$Lambda89} (): (𝓟649: [miss]𝓛[ty]10033{Void})
{
const 𝓟650{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟651{result}: [miss]𝓛[ty]8670{Array} = 𝓟378{maxHeapify}(𝓟650{input},𝓛8745{Number},𝓟650{input}.length);
𝓛10036{expect}(𝓟651{result}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number}))
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟648{$Lambda89})
}
𝓛10037{describe}(𝓛8743{String},𝓟646{$Lambda88})
function 𝓟652{$Lambda90} (): (𝓟653: [miss]𝓛[ty]10033{Void})
{
function 𝓟654{$Lambda91} (): (𝓟655: [miss]𝓛[ty]10033{Void})
{
const 𝓟656{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟657{result}: [miss]𝓛[ty]8670{Array} = 𝓟386{buildMaxHeap}(𝓟656{input});
𝓛10036{expect}(𝓟657{result}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number}))
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟654{$Lambda91})
}
𝓛10037{describe}(𝓛8743{String},𝓟652{$Lambda90})
function 𝓟658{$Lambda92} (): (𝓟659: [miss]𝓛[ty]10033{Void})
{
function 𝓟660{$Lambda93} (): (𝓟661: [miss]𝓛[ty]10033{Void})
{
const 𝓟662{input}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
const 𝓟663{result}: [miss]𝓛[ty]8670{Array} = 𝓟393{heapSort}(𝓟662{input});
𝓛10036{expect}(𝓟663{result}).toEqual(𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number}))
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟660{$Lambda93})
}
𝓛10037{describe}(𝓛8743{String},𝓟658{$Lambda92})
Module: algorithms/misc/rod-cutting/rod-cutting
type 𝓟[ty]664{BestResults} = {bestPrices: 𝓛[ty]8670{Array}, bestFirstCuts: 𝓛[ty]8670{Array}}
function 𝓟665{topDownCutRod} (𝓟666{prices}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟667{length}: 𝓛[ty]8655{Number}): (𝓟668: [OOV]𝓟[ty]664{BestResults})
{
const 𝓟669{bestPrices}: 𝓛[ty]8670{Array} = 𝓛8757{Array}.CONSTRUCTOR(𝓛12641{PlusToken}(𝓟667{length},𝓛8745{Number}));
𝓟669{bestPrices}.fill(𝓛12616{MinusToken}(𝓛8706{Infinity}))
const 𝓟670{bestFirstCuts}: 𝓛[ty]8670{Array} = 𝓛8757{Array}.CONSTRUCTOR(𝓛12641{PlusToken}(𝓟667{length},𝓛8745{Number}));
return 𝓟668 = 𝓟671{topDownCutRodAux}(𝓟666{prices},𝓟667{length},𝓟669{bestPrices},𝓟670{bestFirstCuts})
}
function 𝓟671{topDownCutRodAux} (𝓟672{prices}: 𝓛[ty]8670{Array},𝓟673{length}: 𝓛[ty]8655{Number},𝓟674{bestPrices}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}),𝓟675{bestFirstCuts}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array})): (𝓟676: [OOV]𝓟[ty]664{BestResults})
{
if (𝓛12596{GreaterThanEqualsToken}(𝓟674{bestPrices}.access(𝓟673{length}),𝓛8745{Number}))
{
return 𝓟676 = {bestPrices: 𝓟674{bestPrices},bestFirstCuts: 𝓟675{bestFirstCuts}}
}
let 𝓟677{maxCutPrice}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓛8706{Infinity});
let 𝓟678{bestFirstCut}: 𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓛8745{Number});
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟673{length},𝓛8745{Number}))
{
𝓟677{maxCutPrice} ⟵ 𝓛8745{Number};
}
else
{
function 𝓟679{$Lambda50} (𝓟680{firstCut}): (𝓟681: [miss]𝓛[ty]10033{Void})
{
const 𝓟682{remainingRod}: [OOV]𝓟[ty]664{BestResults} = 𝓟671{topDownCutRodAux}(𝓟672{prices},𝓛12616{MinusToken}(𝓟673{length},𝓟680{firstCut}),𝓟674{bestPrices},𝓟675{bestFirstCuts});
const 𝓟683{cutPrice}: [miss]𝓛[ty]8655{Number} = 𝓛12641{PlusToken}(𝓟672{prices}.access(𝓟680{firstCut}),𝓟682{remainingRod}.bestPrices.access(𝓛12616{MinusToken}(𝓟673{length},𝓟680{firstCut})));
if (𝓛12595{GreaterThanToken}(𝓟683{cutPrice},𝓟677{maxCutPrice}))
{
𝓟677{maxCutPrice} ⟵ 𝓟683{cutPrice};
𝓟678{bestFirstCut} ⟵ 𝓟680{firstCut};
}
}
𝓟167{range}(𝓛8745{Number},𝓟673{length}).forEach(𝓟679{$Lambda50})
}
𝓟674{bestPrices}.access(𝓟673{length}) ⟵ 𝓟677{maxCutPrice};
𝓟675{bestFirstCuts}.access(𝓟673{length}) ⟵ 𝓟678{bestFirstCut};
return 𝓟676 = {bestPrices: 𝓟674{bestPrices},bestFirstCuts: 𝓟675{bestFirstCuts}}
}
function 𝓟684{bottomUpCutRod} (𝓟685{prices}: 𝓛[ty]8670{Array},𝓟686{length}: 𝓛[ty]8655{Number}): (𝓟687: [OOV]𝓟[ty]664{BestResults})
{
const 𝓟688{bestPrices}: 𝓛[ty]8670{Array} = 𝓛8757{Array}.CONSTRUCTOR(𝓛12641{PlusToken}(𝓟686{length},𝓛8745{Number}));
const 𝓟689{bestFirstCuts}: 𝓛[ty]8670{Array} = 𝓛8757{Array}.CONSTRUCTOR(𝓛12641{PlusToken}(𝓟686{length},𝓛8745{Number}));
𝓟688{bestPrices}.fill(𝓛12616{MinusToken}(𝓛8706{Infinity}))
𝓟688{bestPrices}.access(𝓛8745{Number}) ⟵ 𝓛8745{Number};
function 𝓟690{$Lambda51} (𝓟691{subLength}): (𝓟692: [miss]𝓛[ty]10033{Void})
{
let 𝓟693{maxCutPrice}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓛8706{Infinity});
function 𝓟694{$Lambda52} (𝓟695{firstCut}): (𝓟696: [miss]𝓛[ty]10033{Void})
{
const 𝓟697{cutPrice}: [miss]𝓛[ty]8655{Number} = 𝓛12641{PlusToken}(𝓟685{prices}.access(𝓟695{firstCut}),𝓟688{bestPrices}.access(𝓛12616{MinusToken}(𝓟691{subLength},𝓟695{firstCut})));
if (𝓛12595{GreaterThanToken}(𝓟697{cutPrice},𝓟693{maxCutPrice}))
{
𝓟693{maxCutPrice} ⟵ 𝓟697{cutPrice};
𝓟688{bestPrices}.access(𝓟691{subLength}) ⟵ 𝓟693{maxCutPrice};
𝓟689{bestFirstCuts}.access(𝓟691{subLength}) ⟵ 𝓟695{firstCut};
}
}
𝓟167{range}(𝓛8745{Number},𝓟691{subLength}).forEach(𝓟694{$Lambda52})
}
𝓟167{range}(𝓛8745{Number},𝓟686{length}).forEach(𝓟690{$Lambda51})
return 𝓟687 = {bestPrices: 𝓟688{bestPrices},bestFirstCuts: 𝓟689{bestFirstCuts}}
}
function 𝓟698{cutRod} (𝓟699{prices}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟700{length}: 𝓛[ty]8655{Number},𝓟701{strategy}: [OOV]any): (𝓟702: 𝓛[ty]8670{Array})
{
const 𝓟703{bestFirstCuts}: [miss]𝓛[ty]8670{Array} = (𝓛12559{EqualsEqualsEqualsToken}(𝓟701{strategy},𝓛8743{String}) ? 𝓟684{bottomUpCutRod}(𝓟699{prices},𝓟700{length}) : 𝓟665{topDownCutRod}(𝓟699{prices},𝓟700{length}).bestFirstCuts;
let 𝓟704{remainingRod}: [miss]𝓛[ty]8655{Number} = 𝓟700{length};
const 𝓟705{bestCuts}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
while (𝓟704{remainingRod})
{
𝓟705{bestCuts}.push(𝓟703{bestFirstCuts}.access(𝓟704{remainingRod}))
𝓛12606{MinusEqualsToken}(𝓟704{remainingRod},𝓟703{bestFirstCuts}.access(𝓟704{remainingRod}))
}
return 𝓟702 = 𝓟705{bestCuts}
}