奇偶归一猜想(Collatz)

collatz.es6

let cache           = {
        1: 1
    },
    MAX             = 1e6,
    odd             = n => 3 * n + 1,
    even            = n => n / 2,
    isEven          = n => n % 2 == 0,

    collatzSequence = n => {
        let chains = [ n ]

        let check = num => {
            let c = cache[ num ] || 0

            if ( c || num === 1 ) {
                c = c ? ( c - 1 ) : 1

                chains.forEach( ( v, i ) => {
                    if ( !cache[ v ] ) {
                        cache[ v ] = chains.length - i + c
                    }
                } )

                return cache[ n ]
            }

            let next = isEven( num ) ? even( num ) : odd( num )
            chains.push( next )
            return check( next )
        }

        return check( n )
    }

let sequences = []

for ( let begin = 1; begin <= MAX; begin++ ) {
    sequences.push( {
        key: begin,
        value: collatzSequence( begin )
    } )
}

console.log( sequences.sort( ( a, b ) => b.value - a.value )[ 0 ])

count-numbers.es6

let single    = [
        'one',
        'two',
        'three',
        'four',
        'five',
        'six',
        'seven',
        'eight',
        'nine'
    ],
    tens      = [
        'ten',
        'eleven',
        'twelve',
        'thirteen',
        'fourteen',
        'fifteen',
        'sixteen',
        'seventeen',
        'eighteen',
        'nineteen'
    ],

    tensMore  = [
        'twenty',
        'thirty',
        'forty',
        'fifty',
        'sixty',
        'seventy',
        'eighty',
        'ninety'
    ],

    translate = n => {
        if ( n < 10 ) {
            return {
                text: single[ n - 1 ],
                value: 0
            }
        }

        if ( n < 20 ) {
            return {
                text: tens[ n - 10 ],
                value: 0
            }
        }

        if ( n < 100 ) {
            return {
                text: tensMore[ parseInt( n / 10 ) - 2 ],
                value: n % 10
            }
        }

        if ( n < 1000 ) {
            let remain = n % 100
            return {
                text: single[ parseInt( n / 100 ) - 1 ] + 'hundred' + ( remain ? 'and' : ''),
                value: remain
            }
        }

        if ( n < 10000 ) {
            return {
                text: single[ parseInt( n / 1000 ) - 1 ] + 'thousand',
                value: n % 1000
            }
        }
    }

let count = 0

for ( let i = 1; i < 1001; i++ ) {
    let tmp = i,
        str = '',
        result

    while ( tmp > 0 ) {
        result = translate( tmp )
        str += result.text
        tmp    = result.value
    }
    
    count += str.length
}

console.log( count )