function lineup(lijst) {
    let output = [];
    let kleuren = [];
    for (let element of lijst) {
        if (output.length !== 0) {
            let i = 0;
            while(kleuren[i] === "R"){
                i += 1;
            }
            output.splice(i, 0, element["naam"]);
            kleuren.splice(i, 0, element["kleur"]);
        } else {
            output.push(element["naam"]);
            kleuren.push(element["kleur"]);
        }
    }
    return output;
}

############################

var nootjes = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];

function ontleding(chars) {
    let i = chars[1] !== "#" ? 1 : 2
    let begin = chars.substring(0,i);
    let einde = chars.substring(i);
    output = {
        "grondnoot": begin,
        "symbool": einde
    };
    return output;
}

function noten(noot, interval) {
    let output = [];
    for (let i of interval) {
        output.push(nootjes[(i + nootjes.indexOf(noot)) % 12]);
    }
    return output
}

function akkoord(noot, akkoordtypes, akkoordsymbolen) {
    let grondnoot = ontleding(noot)["grondnoot"];
    let symbool = ontleding(noot)["symbool"];
    let type = akkoordsymbolen[symbool];
    let interval = akkoordtypes[type];
    return noten(grondnoot, interval);
}

#####################


function naomees(str) {
    let regex = /^(ba|di|du).*\1$/;
    let regexoutput = /^(ba|di|du|)$/;
    let test = str;
    while(regex.test(test)) {
        test = test.substring(2, test.length - 2);
    }
    return regexoutput.test(test);
}


#####################



function winst(lijst, sales) {
    let regex = /^((-*K-*V-*)*|-+)$/;
    let winst = 0
    if (regex.test(sales)) {
        while(sales.includes("K")) {
            let k = sales.indexOf("K");
            let v = sales.indexOf("V");
            teller = v
            winst += lijst[v] - lijst[k]
            sales = sales.substring(v+1);
            lijst = lijst.slice(v+1)
        }
    } else {
        throw {
            name: "AssertionError",
            message: "ongeldige acties"
        };
    }
    return winst;
}

function maximaleWinst(lijst) {
    let p1 = 0
    let p2 = -lijst[0]
    for (let i = 1; i < lijst.length; i += 1) {
        let tussenp1 = p1
        p1 = Math.max(tussenp1, p2 + lijst[i]);
        p2 = Math.max(p2, tussenp1 - lijst[i]);
    }
    return p1;
}



########################



function dwarsdoorsnede(rijen, richtingen) {
    if ((richtingen.length/2 % rijen) === 0) {
        let output = [];
        let kolom = richtingen.length/rijen;
        for(let i = 0; i < rijen*kolom; i += kolom) {
            let string = richtingen.substring(i, kolom+i);
            let lijst = [];
            for(let i = 0; i < string.length; i += 2) {
                lijst.push(string.substring(i, i+2));
            }
            output.push(lijst);
        }
        return output;
    } else {
        throw {
            name: "AssertionError",
            message: "ongeldige dwarsdoorsnede"
        };
    }
}

function diepte(grot){
    let veranderCoords = {
        "N": [-1, 0],
        "O": [0, 1],
        "Z": [1, 0],
        "W": [0, -1]
    };
    let veranderInkom = {
        "N": "Z",
        "O": "W",
        "Z": "N",
        "W": "O"
    };
    let rijen = grot.length;
    let kolommen = grot[0].length;
    let rij = 0;
    let kolom = 0;
    let aantal = 0;
    let inkom = "N";
    while((0 <= rij  && rij < rijen) && (0 <= kolom && kolom < kolommen) && (grot[rij][kolom].includes(inkom))) {
        let richtingen = grot[rij][kolom];
        let uitkom = richtingen.replace(inkom, "");
        rij += veranderCoords[uitkom][0];
        kolom += veranderCoords[uitkom][1];
        inkom = veranderInkom[uitkom];
        aantal += 1;
    }
    return aantal;
}