plateau7.rb

#!/usr/bin/ruby1.8
 
 
def oddop(n)
	case $o
		when 0
			return n * 3 + 1
		when 1
			return (n * 3 + 1) / 2
		when 2 
			begin
				n = (n * 3 + 1) / 2 
			end while (n.odd?)
			return n
	end
	
end

def evenop(n)
	case $e
		when 0
			return n / 2
		when 1
			begin
				n /= 2
			end while (n.even?)
			return n
	end

end

def f1(n)
	
	if ($d == 0) then
		n = oddop(n) if (n.odd?)
		n = evenop(n) if (n.even?)
	else
		n = evenop(n) if (n.even?)
		n = oddop(n) if (n.odd?)
	end
	
	return n
end
	
def f2(l)
	
	n = l.last
	while (n > 4)
		n = f1(n)
		l << n
	end

end

 
def delta2(l)
 
        l = (1...l.size).map { |i| l[i] - l[i - 1] }
        y = 0
        l = (1...l.size).map { |i| x = l[i] - l[i - 1]; y += x; [x, y] }
        return l
end

 
def dense(n)
 
        s = n.to_s(2)
        c = 0
        s.length.times \
        {
                |i|
                c += s[i, 1].to_i
        }
        return c.to_f / s.length
 
end

def f(n)
 
        n1 = n
        c = 0
	l = []
        while (n > 4 && n >= n1)
		n = f1(n)

		l << n
                c += 1
        end
        return {'c' => c, 'd' => (0.5 - dense(n1)).abs, 'l' => l}
 
end

def long(m)
 
        l = [{'n' => 1, 'p' => 0}.merge(f(1))]
        t = 0
 
        loop \
        {
                l = l.sort_by { |x| [x['c'], -x['d']] }.reverse
 
                x = l.delete_at(rand([l.size, 20].min))
 
                p2 = x['p'] + 1
                n2 = x['n'] + 2 ** p2
 
 
                x1 = x.dup
                x1['p'] = p2
                l << x1
 
                x2 = {'n' => n2, 'p' => p2}.merge(f(n2))
                l << x2
                t += 1
 
                return if (t >= 2000)
		
                z = l.max_by { |x| x['c'] }
                return z['n'], z['l'] if (z['c'] >= m)
        }
 
end

def params()
	a = {'even' => 2, 'odd' => 3, 'ord' => 2, 'way' => 2}
	b = a.dup
	b.keys.each { |x| b[x] = 0 }

	k = b.keys
	w = []
	
	begin
		w << b.dup
		c = 0
		begin
			b[k[c]] += 1
			break if (b[k[c]] != a[k[c]])
			b[k[c]] = 0
			c += 1
		end while (c < k.size)
	end while (c < k.size)
		
	return w
end

def test(w)
	
	$stderr.puts(w.inspect)
	$d, $o, $e, $w = w['ord'], w['odd'], w['even'], w['way']
	
	c1 = c2 = c3 = 0
	m = 100
	m.times \
	{
		|i|
		$stderr.print("#{i}\t") if (i % 10 == 0)
		
		if ($w == 0) then
			l = [rand(2**100) | 1]
		else
			begin
				n, l = long(80)
				$stderr.print("*") if (n.nil?)
			end while (n.nil?)
		end
		
		f2(l)
		
		
		l1 = delta2(l.map { |x| Math.log(x) })
		l2 = delta2(l.map { |x| x.to_s(2).length })
		 
		l = [l1, l2].transpose

		c1 += 1 if (l.select { |x| x[0][1] > 0 }.empty?)
		c2 += 1 if (l.select { |x| x[1][1] > 0 }.empty?)
		c3 += l.size
	}
	$stderr.puts
	puts([c1, c2, c3.to_f / m, w.inspect].join("\t"))
	$stdout.flush
end


w = params()

w.each { |p| test(p) }