JavaScript

2018.09.13

5%の確率に挑戦して少なくとも1回成功する割合が85%を超えるのは、何回挑戦したときか→37回

const main = () => {
    'use strict';
    
    const p = console.log;
    const probabilityOf_percent = (percent) => {
        const randomDouble100 = Math.random() * 100;
        return (randomDouble100 < percent);
    };
    const challengeForOneWin = (percent, times) => {
        for(let i=0; i<times; i++){
            if(probabilityOf_percent(percent)){
                return true;
            }
        }
        return false;
    };
    const getOneWinProportion = (percent, times) => {
        let cnt = 0;
        for(let i=0; i<times; i++){
            if(challengeForOneWin(percent, times)){
                cnt++;
            }
        }
        const proportion = cnt * 100.0 / times;
        return proportion;
    };
    const getOneWinProportionAverage_calculation = (percent, challengeTimes, times) => {
        let proportionSum = 0;
        for(let i=0; i<times; i++){
            proportionSum += getOneWinProportion(percent, challengeTimes);
        }
        const proportionAverage = proportionSum / times;
        return proportionAverage;
    };
    const getOneWinProportionAverage_analytic = (percent, challengeTimes) => {
        const result = (1.0 - Math.pow(1 - percent / 100.0, challengeTimes)) * 100;

        return result;
    };
    const sub = () => {
        const times = 10000;
        const challengeTimes = 37;
        const percent = 5.0;
        
        const result_calculation = getOneWinProportionAverage_calculation(percent, challengeTimes, times);
        const result_analytic = getOneWinProportionAverage_analytic(percent, challengeTimes);

        p("result_calculation : " + result_calculation);
        p("result_analytic : " + result_analytic);
    };
    sub();
};
main();

const main = () => {

'use strict';

const p = console.log;

const probabilityOf_percent = (percent) => {

const randomDouble100 = Math.random() * 100;

return (randomDouble100 < percent);

};

const challengeForOneWin = (percent, times) => {

for(let i=0; i<times; i++){

if(probabilityOf_percent(percent)){

return true;

}

return false;

};

const getOneWinProportion = (percent, times) => {

let cnt = 0;

for(let i=0; i<times; i++){

if(challengeForOneWin(percent, times)){

cnt++;

}

const proportion = cnt * 100.0 / times;

return proportion;

};

const getOneWinProportionAverage_calculation = (percent, challengeTimes, times) => {

let proportionSum = 0;

for(let i=0; i<times; i++){

proportionSum += getOneWinProportion(percent, challengeTimes);

}

const proportionAverage = proportionSum / times;

return proportionAverage;

};

const getOneWinProportionAverage_analytic = (percent, challengeTimes) => {

const result = (1.0 - Math.pow(1 - percent / 100.0, challengeTimes)) * 100;

return result;

};

const sub = () => {

const times = 10000;

const challengeTimes = 37;

const percent = 5.0;

const result_calculation = getOneWinProportionAverage_calculation(percent, challengeTimes, times);

const result_analytic = getOneWinProportionAverage_analytic(percent, challengeTimes);

p("result_calculation : " + result_calculation);

p("result_analytic : " + result_analytic);

};

sub();

};

main();

result_calculation : 85.03594594594543
result_analytic : 85.01097459511844

1 2	result_calculation : 85.03594594594543 result_analytic : 85.01097459511844

2018.09.08

厚さ0.1ミリの新聞紙を37回折ったら地球の直径を超えるみたいなやつ

function main() {
  'use strict';
  const p = console.log;
  const getDouble = n => n + n;
  const getDoubleAtTimes = (n, times) => {
    for (let i = 0; i < times; i++) {
      n = getDouble(n);
    }
    return n;
  };
  const foldNewspaper = (m, times) => {
    return getDoubleAtTimes(m, times);
  };
  const dispFoldNewspaper = (m, times) => {
    const mm = foldNewspaper(m, times);
    p(`新聞紙の厚さ:${m}[m], 折った回数:${times}回, 得られた長さ:${mm}[m]`);
  };
  const sub = () => {
    const m = 0.0001;
    dispFoldNewspaper(m, 0);
    dispFoldNewspaper(m, 1);
    dispFoldNewspaper(m, 10);
    dispFoldNewspaper(m, 37);
    dispFoldNewspaper(m, 100);
  };
  sub();
}
main();

function main() {

'use strict';

const p = console.log;

const getDouble = n => n + n;

const getDoubleAtTimes = (n, times) => {

for (let i = 0; i < times; i++) {

n = getDouble(n);

}

return n;

};

const foldNewspaper = (m, times) => {

return getDoubleAtTimes(m, times);

};

const dispFoldNewspaper = (m, times) => {

const mm = foldNewspaper(m, times);

p(`新聞紙の厚さ:${m}[m], 折った回数:${times}回, 得られた長さ:${mm}[m]`);

};

const sub = () => {

const m = 0.0001;

dispFoldNewspaper(m, 0);

dispFoldNewspaper(m, 1);

dispFoldNewspaper(m, 10);

dispFoldNewspaper(m, 37);

dispFoldNewspaper(m, 100);

};

sub();

}

main();

新聞紙の厚さ:0.0001[m], 折った回数:0回, 得られた長さ:0.0001[m]
新聞紙の厚さ:0.0001[m], 折った回数:1回, 得られた長さ:0.0002[m]
新聞紙の厚さ:0.0001[m], 折った回数:10回, 得られた長さ:0.1024[m]
新聞紙の厚さ:0.0001[m], 折った回数:37回, 得られた長さ:13743895.3472[m]
新聞紙の厚さ:0.0001[m], 折った回数:100回, 得られた長さ:1.2676506002282295e+26[m]

新聞紙の厚さ:0.0001[m], 折った回数:0回, 得られた長さ:0.0001[m]

新聞紙の厚さ:0.0001[m], 折った回数:1回, 得られた長さ:0.0002[m]

新聞紙の厚さ:0.0001[m], 折った回数:10回, 得られた長さ:0.1024[m]

新聞紙の厚さ:0.0001[m], 折った回数:37回, 得られた長さ:13743895.3472[m]

新聞紙の厚さ:0.0001[m], 折った回数:100回, 得られた長さ:1.2676506002282295e+26[m]

2018.09.08

1000000 以下の素数の個数の計算にかかる時間(ミリ秒)

JavaScriptはCよりおよそ4倍の時間がかかる。

function main() {
  'use strict';
  const p = console.log;
  const isPrime = n => {
    if (n <= 1) {
      return false;
    }
    if (n === 2 || n === 3) {
      return true;
    }
    if (n % 2 === 0) {
      return false;
    }
    const floorSqrt = Math.floor(Math.sqrt(n));
    for (let i = 3; i <= floorSqrt; i++) {
      if (n % i === 0) {
        return false;
      }
    }
    return true;
  };
  const countPrimeUnderNorN = n => {
    let cnt = 0;
    for (let i = 0; i < n; i++) {
      if (isPrime(i)) {
        cnt++;
      }
    }
    return cnt;
  };
  const calcTimeLapseMs = func => {
    const start_ms = new Date().getTime();
    const result = func();
    const end_ms = new Date().getTime();
    const elapsed_ms = end_ms - start_ms;
    return [elapsed_ms, result];
  };
  const sub = () => {
    const n = 1000000;
    let timeLapseMs, result;
    [timeLapseMs, result] = calcTimeLapseMs(() => {
      return countPrimeUnderNorN(n);
    });
    p(n + " 以下の素数の個数の計算にかかる時間(ミリ秒)");
    p();
    p("timeLapseMs : " + timeLapseMs + " ミリ秒");
    p("result : " + result + " 個");
  };
  sub();
}
main();

function main() {

'use strict';

const p = console.log;

const isPrime = n => {

if (n <= 1) {

return false;

}

if (n === 2 || n === 3) {

return true;

}

if (n % 2 === 0) {

return false;

}

const floorSqrt = Math.floor(Math.sqrt(n));

for (let i = 3; i <= floorSqrt; i++) {

if (n % i === 0) {

return false;

}

return true;

};

const countPrimeUnderNorN = n => {

let cnt = 0;

for (let i = 0; i < n; i++) {

if (isPrime(i)) {

cnt++;

}

return cnt;

};

const calcTimeLapseMs = func => {

const start_ms = new Date().getTime();

const result = func();

const end_ms = new Date().getTime();

const elapsed_ms = end_ms - start_ms;

return [elapsed_ms, result];

};

const sub = () => {

const n = 1000000;

let timeLapseMs, result;

[timeLapseMs, result] = calcTimeLapseMs(() => {

return countPrimeUnderNorN(n);

});

p(n + " 以下の素数の個数の計算にかかる時間(ミリ秒)");

p();

p("timeLapseMs : " + timeLapseMs + " ミリ秒");

p("result : " + result + " 個");

};

sub();

}

main();

1000000 以下の素数の個数の計算にかかる時間(ミリ秒)

timeLapseMs : 391 ミリ秒
result : 78498 個

1000000 以下の素数の個数の計算にかかる時間(ミリ秒)

timeLapseMs : 391 ミリ秒

result : 78498 個

2018.09.07

1000本のワインの中から1本の毒入りワインを見つける問題を解いた

/*
一滴でも飲むと20時間後に死ぬ毒が、1000本のワインのうち1本にだけ入っている。
奴隷に飲ませて、24時間以内にどれが毒入りか調べるとき、奴隷は何人必要か。

こたえ 10人。
検出アルゴリズムのテスト。
*/
class Wine {
    constructor(id, isPoison) {
        this.id = id;
        this.isPoison = isPoison;
    }
    pour() {
        return this.isPoison;
    }
}
class Slave {
    constructor(pos) {
        this.pos = pos;
        this.poisoned = false;
    }
    drink(wine){
        this.isPoisoned = (this.isPoisoned || wine.pour());
    }
}

const p = console.log;

function readSlaves(slaves) {
    const len = slaves.length;
    let s = '';
    for(let i=len-1; 0<=i; i--){
        const slave = slaves[i];
        s += (slave.isPoisoned ? '1' : '0');
    }
    return s;
}

function decimalToBinaryStrPadded(n) {
    return ('0000000000' + n.toString(2)).substr(-10);
}

function binaryDrinking(slaves, wines) {
    wines.forEach(wine => {
        const binStrPadded = decimalToBinaryStrPadded(wine.id);
        slaves.forEach(slave => {
            if(binStrPadded.substr(9 - slave.pos, 1) === '1'){
                slave.drink(wine);
            }
        });
    });
}

function setWinePoison(wines, id) {
    wines.forEach(wine => {
        if(wine.id === id){
            wine.isPoison = true;
            return;
        }
    });
}

function binKetaToNum(binKeta) {
    if(binKeta < 0) {
        return 0;
    }
    return Math.pow(2, binKeta);
}

function binStrToDecimal(s) {
    const len = s.length;
    let sum = 0;
    for(let i=len-1; 0<=i; i--){
        const binKeta = len-1-i;
        const on = (s.substr(i, 1) === '1');
        if(on){
            sum += binKetaToNum(binKeta);
        }
    }
    return sum;
}

function generateSlaves() {
    const slaves = [];
    for(let i=0; i<10; i++) {
        slaves.push(new Slave(i));
    }
    return slaves;    
}

function generateWines() {
    const wines = [];
    for(let i=0; i<1000; i++){
        wines.push(new Wine(i+1, false));
    }
    return wines;    
}

function tasting(poisonWineId){
    const slaves = generateSlaves();
    const wines = generateWines();

    setWinePoison(wines, poisonWineId);
    binaryDrinking(slaves, wines);
    const binaryStr = readSlaves(slaves);

    p(
        "poisonWineId : " + poisonWineId + ", "
        + "readSlaves(slaves) : " + binaryStr
    );
}

function main() {
    tasting(0);
    tasting(777);
    tasting(1000);
}

main();

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

一滴でも飲むと20時間後に死ぬ毒が、1000本のワインのうち1本にだけ入っている。

奴隷に飲ませて、24時間以内にどれが毒入りか調べるとき、奴隷は何人必要か。

こたえ 10人。

検出アルゴリズムのテスト。

class Wine {

constructor(id, isPoison) {

this.id = id;

this.isPoison = isPoison;

}

pour() {

return this.isPoison;

}

class Slave {

constructor(pos) {

this.pos = pos;

this.poisoned = false;

}

drink(wine){

this.isPoisoned = (this.isPoisoned || wine.pour());

}

const p = console.log;

function readSlaves(slaves) {

const len = slaves.length;

let s = '';

for(let i=len-1; 0<=i; i--){

const slave = slaves[i];

s += (slave.isPoisoned ? '1' : '0');

}

return s;

}

function decimalToBinaryStrPadded(n) {

return ('0000000000' + n.toString(2)).substr(-10);

}

function binaryDrinking(slaves, wines) {

wines.forEach(wine => {

const binStrPadded = decimalToBinaryStrPadded(wine.id);

slaves.forEach(slave => {

if(binStrPadded.substr(9 - slave.pos, 1) === '1'){

slave.drink(wine);

}

});

}

function setWinePoison(wines, id) {

wines.forEach(wine => {

if(wine.id === id){

wine.isPoison = true;

return;

}

});

}

function binKetaToNum(binKeta) {

if(binKeta < 0) {

return 0;

}

return Math.pow(2, binKeta);

}

function binStrToDecimal(s) {

const len = s.length;

let sum = 0;

for(let i=len-1; 0<=i; i--){

const binKeta = len-1-i;

const on = (s.substr(i, 1) === '1');

if(on){

sum += binKetaToNum(binKeta);

}

return sum;

}

function generateSlaves() {

const slaves = [];

for(let i=0; i<10; i++) {

slaves.push(new Slave(i));

}

return slaves;

}

function generateWines() {

const wines = [];

for(let i=0; i<1000; i++){

wines.push(new Wine(i+1, false));

}

return wines;

}

function tasting(poisonWineId){

const slaves = generateSlaves();

const wines = generateWines();

setWinePoison(wines, poisonWineId);

binaryDrinking(slaves, wines);

const binaryStr = readSlaves(slaves);

"poisonWineId : " + poisonWineId + ", "

+ "readSlaves(slaves) : " + binaryStr

);

}

function main() {

tasting(0);

tasting(777);

tasting(1000);

}

main();

poisonWineId : 0, readSlaves(slaves) : 0000000000
poisonWineId : 777, readSlaves(slaves) : 1100001001
poisonWineId : 1000, readSlaves(slaves) : 1111101000

poisonWineId : 0, readSlaves(slaves) : 0000000000

poisonWineId : 777, readSlaves(slaves) : 1100001001

poisonWineId : 1000, readSlaves(slaves) : 1111101000

2018.09.04

bignumber.jsを使った小数点以下の計算

// https://github.com/MikeMcl/bignumber.js/blob/master/bignumber.js
const BigNumber = require('./bignumber.js') 
const p = console.log

const a = new BigNumber(0.000000000000000001)
const b = new BigNumber(1000000000)
const c = a.multipliedBy(b)

p("a * b = c")
p("a : " + a.toFixed())
p("b : " + b.toFixed())
p("c : " + c.toFixed())

// https://github.com/MikeMcl/bignumber.js/blob/master/bignumber.js

const BigNumber = require('./bignumber.js')

const p = console.log

const a = new BigNumber(0.000000000000000001)

const b = new BigNumber(1000000000)

const c = a.multipliedBy(b)

p("a * b = c")

p("a : " + a.toFixed())

p("b : " + b.toFixed())

p("c : " + c.toFixed())

a * b = c
a : 0.000000000000000001
b : 1000000000
c : 0.000000001

a * b = c

a : 0.000000000000000001

b : 1000000000

c : 0.000000001

2018.09.04

非同期処理も順番守って出力させたい

class PrinterBuffer {
  constructor(id) {
    this.isConsole = (id === undefined)
    this.ps = []
    if (this.isConsole) {
      this.lineFeedMark = '\n'
    } else {
      this.lineFeedMark = '<br>'
      this.element = document.getElementById(id)
    }
  }
  output(s) {
    if (this.isConsole) {
      console.log(s)
    } else {
      this.element.innerHTML = s
    }
  }
  flush() {
    Promise.all(this.ps).then(results => {
      let s = "";
      for (const result of results) {
        s += result + this.lineFeedMark
      }
      this.output(s)
    })
  }
  push(s) {
    this.ps.push(new Promise(resolve => {
      resolve(s)
    }))
  }
  pushPromise(promise, writeBack) {
    this.ps.push(new Promise(resolve => {
      promise.then(result => {
        resolve(writeBack(result))
      })
    }))
  }
  pushPromiseArray(promiseArray, arrayWriteBack) {
    this.ps.push(new Promise(resolve => {
      Promise.all(promiseArray).then(results => {
        resolve(arrayWriteBack(results))
      })
    }))
  }
}

function main() {
  // const p = new PrinterBuffer('p1')
  const p = new PrinterBuffer()
  const getPromiseVar = (len) => {
    const ps = []
    for (var i = 0; i < len; i++) {
      ps.push(new Promise(resolve => {
        setTimeout(() => {
          resolve(i)
        }, 0);
      }))
    }
    return ps
  }
  const getPromiseLet = (len) => {
    const ps = []
    for (let i = 0; i < len; i++) {
      ps.push(new Promise(resolve => {
        setTimeout(() => {
          resolve(i)
        }, 0);
      }))
    }
    return ps
  }
  const len = 5;

  p.push("first")
  p.pushPromise(new Promise(resolve => {
    resolve("pushPromise() first");
  }), ret => ret)

  p.pushPromiseArray(getPromiseVar(len), rets => rets)

  p.push("second")
  p.pushPromise(new Promise(resolve => {
    resolve("pushPromise() second");
  }), ret => ret)

  p.pushPromiseArray(getPromiseLet(len), rets => rets)

  p.push("third")
  p.pushPromise(new Promise(resolve => {
    resolve("pushPromise() third");
  }), ret => ret)

  p.flush()
}

main()

class PrinterBuffer {

constructor(id) {

this.isConsole = (id === undefined)

this.ps = []

if (this.isConsole) {

this.lineFeedMark = '\n'

} else {

this.lineFeedMark = '<br>'

this.element = document.getElementById(id)

}

output(s) {

if (this.isConsole) {

console.log(s)

} else {

this.element.innerHTML = s

}

flush() {

Promise.all(this.ps).then(results => {

let s = "";

for (const result of results) {

s += result + this.lineFeedMark

}

this.output(s)

})

}

push(s) {

this.ps.push(new Promise(resolve => {

resolve(s)

}))

}

pushPromise(promise, writeBack) {

this.ps.push(new Promise(resolve => {

promise.then(result => {

resolve(writeBack(result))

})

}))

}

pushPromiseArray(promiseArray, arrayWriteBack) {

this.ps.push(new Promise(resolve => {

Promise.all(promiseArray).then(results => {

resolve(arrayWriteBack(results))

})

}))

}

function main() {

// const p = new PrinterBuffer('p1')

const p = new PrinterBuffer()

const getPromiseVar = (len) => {

const ps = []

for (var i = 0; i < len; i++) {

ps.push(new Promise(resolve => {

setTimeout(() => {

resolve(i)

}, 0);

}))

}

return ps

}

const getPromiseLet = (len) => {

const ps = []

for (let i = 0; i < len; i++) {

ps.push(new Promise(resolve => {

setTimeout(() => {

resolve(i)

}, 0);

}))

}

return ps

}

const len = 5;

p.push("first")

p.pushPromise(new Promise(resolve => {

resolve("pushPromise() first");

}), ret => ret)

p.pushPromiseArray(getPromiseVar(len), rets => rets)

p.push("second")

p.pushPromise(new Promise(resolve => {

resolve("pushPromise() second");

}), ret => ret)

p.pushPromiseArray(getPromiseLet(len), rets => rets)

p.push("third")

p.pushPromise(new Promise(resolve => {

resolve("pushPromise() third");

}), ret => ret)

p.flush()

}

main()

first
pushPromise() first
5,5,5,5,5
second
pushPromise() second
0,1,2,3,4
third
pushPromise() third

first

pushPromise() first

5,5,5,5,5

second

pushPromise() second

0,1,2,3,4

third

pushPromise() third

2018.08.28

Promise.all()は本当に並列処理しているのか

⇒Promise.all()は本当に並列処理している

main();

function main() {
  const p = console.log;
  const getTimeoutPromise = timespan_ms => {
    return new Promise(resolve => {
      setTimeout(() => {
        resolve("timespan_ms : " + timespan_ms);
      }, timespan_ms);
    });
  };
  const sub = () => {
    const ps = [];
    ps.push(getTimeoutPromise(50));
    ps.push(getTimeoutPromise(40));
    ps.push(getTimeoutPromise(100));
    ps.push(getTimeoutPromise(30));
    ps.push(getTimeoutPromise(20));
    ps.push(getTimeoutPromise(10));

    const start = new Date();
    new Promise(resolve => {
      Promise.all(ps).then(results => {
        resolve(results);
      });
    }).then(result => {
      p(result);
      const end = new Date();
      const timelapse = end.getTime() - start.getTime();
      p("timelapse : " + timelapse + "[ms]");
    });
  };
  sub();
}

main();

function main() {

const p = console.log;

const getTimeoutPromise = timespan_ms => {

return new Promise(resolve => {

setTimeout(() => {

resolve("timespan_ms : " + timespan_ms);

}, timespan_ms);

});

};

const sub = () => {

const ps = [];

ps.push(getTimeoutPromise(50));

ps.push(getTimeoutPromise(40));

ps.push(getTimeoutPromise(100));

ps.push(getTimeoutPromise(30));

ps.push(getTimeoutPromise(20));

ps.push(getTimeoutPromise(10));

const start = new Date();

new Promise(resolve => {

Promise.all(ps).then(results => {

resolve(results);

});

}).then(result => {

p(result);

const end = new Date();

const timelapse = end.getTime() - start.getTime();

p("timelapse : " + timelapse + "[ms]");

});

};

sub();

}

[ 'timespan_ms : 50',
  'timespan_ms : 40',
  'timespan_ms : 100',
  'timespan_ms : 30',
  'timespan_ms : 20',
  'timespan_ms : 10' ]
timelapse : 103[ms]

[ 'timespan_ms : 50',

'timespan_ms : 40',

'timespan_ms : 100',

'timespan_ms : 30',

'timespan_ms : 20',

'timespan_ms : 10' ]

timelapse : 103[ms]

2018.08.26

60％を3回試行と80%を2回試行ではどちらの期待値が高いか

~~60％を3回の方が高い~~
すみません、80％を2回の方が高いです。答えの見方を間違えておりました。
本件の最新記事はこちらです。

60％を3回試行と80%を2回試行ではどちらの期待値が高いか→80%を2回の方が高い

// 60％の成功率を3回チャレンジして2回以上成功する確率を教えて下さいヾ(｡>д<)ﾉ
main();

function main() {
  const p = console.log;
  const probabilityOf = n => Math.random() * 100 < n;
  const challenge = (percent, limit, targetCnt, isBool = false) => {
    let cnt = 0;
    for (let i = 0; i < limit; i++) {
      if (probabilityOf(percent)) {
        if (isBool) {
          return true;
        }
        cnt++;
      }
    }
    if (isBool) {
      if (cnt === 0) {
        return false;
      }
    }
    return targetCnt <= cnt;
  };
  const calcProportion = (percent, limit, times) => {
    let cnt = 0;
    for (let i = 0; i < times; i++) {
      if (challenge(percent, limit, 1, true)) {
        cnt++;
      }
    }
    const proportion = cnt * 100.0 / times;
    return proportion;
  };
  const dispProportion = (percent, limit, times) => {
    const proportion = calcProportion(percent, limit, times);
    let msg = percent + "% に" + limit + "回 挑戦して成功する割合 " + proportion + "% (" + times + "回試行)";
    p(msg);
  };
  const calcHitCnt = (percent, limit) => {
    let cnt = 0;
    for (let i = 0; i < limit; i++) {
      if (probabilityOf(percent)) {
        cnt++;
      }
    }
    return cnt;
  };
  const calcExpectedValue = (percent, limit, times) => {
    let cnt = 0;
    for (let i = 0; i < times; i++) {
      cnt += calcHitCnt(percent, limit);
    }
    expectedValue = cnt / times;
    return expectedValue;
  };
  const dispExpectedValue = (percent, limit, times) => {
    const expectedValue = calcExpectedValue(percent, limit, times);
    let msg = percent + "% に" + limit + "回 挑戦した時の期待値 " + expectedValue + "% (" + times + "回試行)";
    p(msg);
  };

  const times = 2000000;
  let percent = 60.0;
  let limit = 3;
  dispExpectedValue(percent, limit, times);
  percent = 80.0;
  limit = 2;
  dispExpectedValue(percent, limit, times);
}

// 60％の成功率を3回チャレンジして2回以上成功する確率を教えて下さいヾ(｡>д<)ﾉ

main();

function main() {

const p = console.log;

const probabilityOf = n => Math.random() * 100 < n;

const challenge = (percent, limit, targetCnt, isBool = false) => {

let cnt = 0;

for (let i = 0; i < limit; i++) {

if (probabilityOf(percent)) {

if (isBool) {

return true;

}

cnt++;

}

if (isBool) {

if (cnt === 0) {

return false;

}

return targetCnt <= cnt;

};

const calcProportion = (percent, limit, times) => {

let cnt = 0;

for (let i = 0; i < times; i++) {

if (challenge(percent, limit, 1, true)) {

cnt++;

}

const proportion = cnt * 100.0 / times;

return proportion;

};

const dispProportion = (percent, limit, times) => {

const proportion = calcProportion(percent, limit, times);

let msg = percent + "% に" + limit + "回挑戦して成功する割合 " + proportion + "% (" + times + "回試行)";

p(msg);

};

const calcHitCnt = (percent, limit) => {

let cnt = 0;

for (let i = 0; i < limit; i++) {

if (probabilityOf(percent)) {

cnt++;

}

return cnt;

};

const calcExpectedValue = (percent, limit, times) => {

let cnt = 0;

for (let i = 0; i < times; i++) {

cnt += calcHitCnt(percent, limit);

}

expectedValue = cnt / times;

return expectedValue;

};

const dispExpectedValue = (percent, limit, times) => {

const expectedValue = calcExpectedValue(percent, limit, times);

let msg = percent + "% に" + limit + "回挑戦した時の期待値 " + expectedValue + "% (" + times + "回試行)";

p(msg);

};

const times = 2000000;

let percent = 60.0;

let limit = 3;

dispExpectedValue(percent, limit, times);

percent = 80.0;

limit = 2;

dispExpectedValue(percent, limit, times);

}

60% に3回 挑戦した時の期待値 1.800217% (2000000回試行)
80% に2回 挑戦した時の期待値 1.600028% (2000000回試行)

1 2	60% に3回挑戦した時の期待値 1.800217% (2000000回試行) 80% に2回挑戦した時の期待値 1.600028% (2000000回試行)

2018.08.25

indexの宣言がletかvarかで結果が変わる件を難しく書いた

jsらしい気がする。

const main = () => {
  const p = console.log;
  const copyFromBtoA = (a, b) => {
    for (const k of Object.keys(b)) {
      const v = b[k];
      a[k] = v;
    }
  };
  const getPromiseArr_let = () => {
    const ps = [];
    for (let i = 0; i < 5; i++) {
      ps.push(new Promise(resolve => {
        setTimeout(() => {
          resolve(i);
        }, 0);
      }));
    }
    return ps;
  };
  const getPromiseArr_var = () => {
    const ps = [];
    for (var i = 0; i < 5; i++) {
      ps.push(new Promise(resolve => {
        setTimeout(() => {
          resolve(i);
        }, 0);
      }));
    }
    return ps;
  };
  const doPromiseAll = (ps, func) => {
    Promise.all(ps).then(results => {
      func(results);
    });
  };
  const sub = () => {
    const psLet = [];
    const psVar = [];
    copyFromBtoA(psLet, getPromiseArr_let());
    copyFromBtoA(psVar, getPromiseArr_var());
    doPromiseAll(psLet, p);
    doPromiseAll(psVar, p);
  };
  sub();
};
main();

const main = () => {

const p = console.log;

const copyFromBtoA = (a, b) => {

for (const k of Object.keys(b)) {

const v = b[k];

a[k] = v;

}

};

const getPromiseArr_let = () => {

const ps = [];

for (let i = 0; i < 5; i++) {

ps.push(new Promise(resolve => {

setTimeout(() => {

resolve(i);

}, 0);

}));

}

return ps;

};

const getPromiseArr_var = () => {

const ps = [];

for (var i = 0; i < 5; i++) {

ps.push(new Promise(resolve => {

setTimeout(() => {

resolve(i);

}, 0);

}));

}

return ps;

};

const doPromiseAll = (ps, func) => {

Promise.all(ps).then(results => {

func(results);

});

};

const sub = () => {

const psLet = [];

const psVar = [];

copyFromBtoA(psLet, getPromiseArr_let());

copyFromBtoA(psVar, getPromiseArr_var());

doPromiseAll(psLet, p);

doPromiseAll(psVar, p);

};

sub();

};

main();

[ 0, 1, 2, 3, 4 ]
[ 5, 5, 5, 5, 5 ]

1 2	[ 0, 1, 2, 3, 4 ] [ 5, 5, 5, 5, 5 ]

2018.08.24

ループとコールバックの問題(varとletで結果が変わる)

非同期処理を実行するfor文で使うindexの宣言をvarでするかletでするかで、するかだけで結果が変わる。
こんなの難しすぎる。

const main_idxVar = () => {
  var ps = [];
  for (var i = 0; i < 5; i++) {
    ps.push(new Promise(resolve => {
      setTimeout(() => {
        resolve(i);
      }, 0);
    }));
  }
  Promise.all(ps).then(values => {
    console.log(values);
  });
};
const main_idxLet = () => {
  var ps = [];
  var len = 5;
  for (let i = 0; i < 5; i++) {
    ps.push(new Promise(resolve => {
      setTimeout(() => {
        resolve(i);
      }, 0);
    }));
  }
  Promise.all(ps).then(values => {
    console.log(values);
  });
};
main_idxVar();
main_idxLet();

const main_idxVar = () => {

var ps = [];

for (var i = 0; i < 5; i++) {

ps.push(new Promise(resolve => {

setTimeout(() => {

resolve(i);

}, 0);

}));

}

Promise.all(ps).then(values => {

console.log(values);

});

};

const main_idxLet = () => {

var ps = [];

var len = 5;

for (let i = 0; i < 5; i++) {

ps.push(new Promise(resolve => {

setTimeout(() => {

resolve(i);

}, 0);

}));

}

Promise.all(ps).then(values => {

console.log(values);

});

};

main_idxVar();

main_idxLet();

[ 5, 5, 5, 5, 5 ]
[ 0, 1, 2, 3, 4 ]

1 2	[ 5, 5, 5, 5, 5 ] [ 0, 1, 2, 3, 4 ]

4 5 6 789 10 11 12

JavaScript

5%の確率に挑戦して少なくとも1回成功する割合が85%を超えるのは、何回挑戦したときか→37回

厚さ0.1ミリの新聞紙を37回折ったら地球の直径を超えるみたいなやつ

1000000 以下の素数の個数の計算にかかる時間(ミリ秒)

1000本のワインの中から1本の毒入りワインを見つける問題を解いた

bignumber.jsを使った小数点以下の計算

非同期処理も順番守って出力させたい

Promise.all()は本当に並列処理しているのか

60％を3回試行と80%を2回試行ではどちらの期待値が高いか

indexの宣言がletかvarかで結果が変わる件を難しく書いた

ループとコールバックの問題(varとletで結果が変わる)

最近の投稿

サイトマップ

カテゴリー

アーカイブ

人気の投稿とページ

Twitter