const f = factorial;

const log = (...msg) => {
    console.log(msg.join(" "));
}

const flog = (feladat) => {
    log(`=================== task ${feladat} ===`);
}

const feladat = (n, f) => {
    flog(n);
    f();
}


feladat(2, () => {
    const vals = [13, 11, 13, 23, 33, 33, 31, 23, 33, 21]
    
    const px = {};
    const py = {};
    const pxy = {};
    
    for (const v of vals) {
        const x = `${v}`[0];
        const y = `${v}`[1];
        
        if (px[`${x}`]) px[`${x}`]++;
        else px[`${x}`] = 1;
        
        if (py[`${y}`]) py[`${y}`]++;
        else py[`${y}`] = 1;
        
        if (pxy[`${x}${y}`]) pxy[`${x}${y}`]++;
        else pxy[`${x}${y}`] = 1;
    }
    
    const ex = Object.entries(px).map(kv => parseInt(kv[0]) * (kv[1]/vals.length)).reduce((a,v) => a+v)
    const ey = Object.entries(py).map(kv => parseInt(kv[0]) * (kv[1]/vals.length)).reduce((a,v) => a+v)
    const exy = Object.entries(pxy).map(kv => (parseInt(kv[0][0]) * parseInt(kv[0][1])) * (kv[1]/vals.length)).reduce((a,v) => a+v)
    
    log(exy - (ex * ey))
})

feladat(5, () => {
    log("harom sornyi osszeadas")
})

feladat(6, () => {
    log("uveges feladat")
})

feladat(7, () => {
    log("dobokocka lol")
})

feladat(8, () => {
    log("odusszeusz")
    const road_a = 1/3;
    const road_s = 1/3;
    const road_m = 1/3;
    
    const true_a = 1/5;
    const true_s = 1/3;
    const true_m = 1/4;
    
    const false_a = 1 - true_a;
    const false_s = 1 - true_s;
    const false_m = 1 - true_m;
    
    const total_false = false_a * road_a + false_s * road_s + false_m * road_m;
    
    log((false_m * road_m) / total_false)
    log(45/133)
})

feladat(9, () => {
    log("the thing with money")
    const initial = 80;
    const dev = [4.0, -4.0, -3.0].map(v => 1 + (v / 100));
    let days = 4;
    
    function calculateRecursive(value, year) {
        if (year === 0) return value;
        
        let result = 0.0;
        for (const factor of dev) {
            result += parseFloat(calculateRecursive(value * factor, year - 1));
        }
        return result;
    }
    
    const s4 = calculateRecursive(initial, days);
    
    const modifier = Math.pow(1/dev.length, days);
    const expected = modifier * s4;
    log(expected);
    
    function expectedDaysToDrop(initial, dropPercent, rates) {
        const target = initial * (1 - dropPercent / 100);
        const expectedMultiplier = rates.reduce((sum, r) => sum + r, 0) / rates.length;
    
        let n = Math.log(target / initial) / Math.log(expectedMultiplier);
        return Math.ceil(n);
    }
    
    const left = expectedDaysToDrop(initial, 30, dev);
    log(`${left}`);

})

feladat(9.2, () => {
    log("the thing with money p2")
    const initial = 100;
    const dev = [5, 4.0, -6].map(v => 1 + (v / 100));
    const days = 4;
    
    
    function rec(value, days) {
        if (days === 0) return value;
        
        let result = 0.0;
        for (const factor of dev) {
            result += parseFloat(rec(value * factor, days - 1));
        }
        
        return result;
    }
    
    const s4 = rec(initial, days)
    
    const modifier = Math.pow(1 / dev.length, days);
    const expected = modifier * s4;
    log(expected);
    
    function expectedD(initial, perc, rates) {
        const target = initial * (1 - perc / 100);
        const expected = rates.reduce((a, v) => a+v, 0) / rates.length;
        
        const n = Math.log(target / initial) / Math.log(expected);
        return Math.ceil(n);
    }
    
    const dropDay = expectedD(initial, 30, dev)
    log(dropDay);
});


feladat(3, () => {
    const a = 3;
    const b = 6;
    
    const l1 = 21/16;
    const l2 = 17/4;
    
    const F = l => (l < a) ? 0 : (l - a) / (b - a);
    
    const p = F(l2) - F(l1);
    const e = (a + b) / 2;
    
    log(`p = ${p}`);
    log(`e = ${e}`);
});

feladat(3.5, () => {
    const a = 5;
    const b = 10;
    
    const l1 = 123/16;
    const l2 = 63/8;
    
    const F = l => (l < a) ? 0 : (l - a) / (b - a);
    
    const P = F(l2) - F(l1);
    const E = (a + b) / 2;
    
    log(`p = ${P}`)
    log(`e = ${E}`)
})






"";