integer_sequences.rb

gistfile1.txt

# Number sequence enumerators
define :fibonacci do
  Enumerator.new do |y|
    a = b = 1
    while true do
      y << a
      a, b = b, a + b
    end
  end
end

define :primes do |from=2|
  (from..).lazy.select{|i| (2..Math.sqrt(i)).none? {|n| (i % n).zero?}}
end

define :prime_difference do
  Enumerator.new do |y|
    prime = 2
    next_prime = 3
    primes = primes 5
    while true
      y << next_prime-prime
      prime = next_prime
      next_prime = primes.next
    end
  end
end

# https://rosettacode.org/wiki/Pi#Ruby
define :pi do
  Enumerator.new do |y|
    q, r, t, k, n, l = 1, 0, 1, 1, 3, 3
    while true
      if 4*q+r-t < n*t then
        y << n
        nr = 10*(r-n*t)
        n = ((10*(3*q+r)) / t) - 10*n
        q *= 10
        r = nr
      else
        nr = (2*q+r) * l
        nn = (q*(7*k+2)+r*l) / (t*l)
        q *= k
        t *= l
        l += 2
        k += 1
        n = nn
        r = nr
      end
    end
  end
end

# https://web.archive.org/web/20100730015238/http://www.cs.utsa.edu/~wagner/pi/ruby/pi_works.html
# https://oeis.org/A001622
define :phi do
  Enumerator.new do |y|
    k, a, b, a1, b1 = 2, 2, 1, 3, 2
    while true
      p, q, k = 1, 1, k+1
      a, b, a1, b1 = a1, b1, p*a+q*a1, p*b+q*b1
      d = a / b
      d1 = a1 / b1
      while d == d1
        y << d
        a, a1 = 10*(a%b), 10*(a1%b1)
        d, d1 = a/b, a1/b1
      end
    end
  end
end

# https://oeis.org/A001113
define :euler do
  Enumerator.new do |y|
    k, a, b, a1, b1 = 2, 3, 1, 8, 3
    while true
      p, q, k = k, k+1, k+1
      a, b, a1, b1 = a1, b1, p*a+q*a1, p*b+q*b1
      d = a / b
      d1 = a1 / b1
      while d == d1
        y << d
        a, a1 = 10*(a%b), 10*(a1%b1)
        d, d1 = a/b, a1/b1
      end
    end
  end
end

# https://www.mathpages.com/home/kmath312/kmath312.htm
define :reverse_sum do |n=17509097067,base=10|
  Enumerator.new do |y|
    while true
      y << n
      n = (n.to_i+n.to_s.reverse.to_i).to_s(base).to_i
    end
  end
end

# https://en.wikipedia.org/wiki/Collatz_conjecture
# https://themarquisdesheric.github.io/collatz-conjecture-music/
define :collatz do |n=987654321|
  Enumerator.new do |enum|
    while n > 1
      n = n % 2 == 0 ? n / 2 : 3 * n + 1
      enum.yield n
    end
  end
end

# https://en.wikipedia.org/wiki/Arithmetic_progression
define :aprog do |a=1,x=2,e=Float::INFINITY|
  (a..e).lazy.collect {|n| a+(n-1)*x }
end

# https://en.wikipedia.org/wiki/Geometric_progression
define :gproq do |a=1,r=2,e=Float::INFINITY|
  (a..e).lazy.collect {|n| a * r ** (n-1) }
end

# https://en.wikipedia.org/wiki/Quadratic_function
define :quadratic do |a,b,c,s=0,e=Float::INFINITY|
  (s..e).lazy.collect {|n| a*(n**2)+(b*n)+c }
end

define :primes do |e=Float::INFINITY|
  (2..e).lazy.reject {|n| (2..Math.sqrt(n)).any?{ |j| n % j == 0 }}
end

# https://oeis.org/A005132
define :recaman do
  Enumerator.new do |y|
    s = []
    0.step do |i|
      x = i == 0 ? 0 : s[i-1]-i
      s << ((x>=0 and !s.include? x) ? x : s[i-1]+i)
      y << s[i]
    end
  end
end

# https://oeis.org/A005185
define :hoffQ do
  Enumerator.new do |y|
    q = []
    0.step do |i|
      q << (i<2 ? 1 : q[i - q[i - 1]] + q[i - q[i - 2]])
      y << q[i]
    end
  end
end

# https://oeis.org/A002487
define :sterns do
  Enumerator.new do |y|
    a=[1,1]
    0.step do |i|
      y << (i>0 ? a[i] : 0)
      a << a[i]+a[i+1] << a[i+1]
    end
  end
end

# https://oeis.org/A000265
define :frac2 do
  Enumerator.new do |y|
    1.step do |n|
      n>>=1 while n%2==0
      y << n
    end
  end
end

# https://oeis.org/A030101
define :binrev do |base=2|
  Enumerator.new do |y|
    0.step do |n|
      y << n.to_s(base).reverse.to_i(base)
    end
  end
end

# https://oeis.org/A000217
define :triangular do
  Enumerator.new do |y|
    s = []
    0.step do |i|
      s[i]=i+1
      y << s.inject(&:+)
    end
  end
end

# Generative methods

# Creates self similar sequence from given init state and range
define :self_similar do |start=[0], range=(1..10), number=5|
  range.to_a.pick(number).inject(start) {|acc,j| acc.flat_map{|n|[n,n+j]}}
end

# Creates sequence that resembles sloth canon
define :sloth_series do |start=[0,1,0]|
  start.inject(start) {|acc,j| acc.flat_map{|n|[n,n+j]}}
end

# Count of certain digits in given base
# By default same as digit sum in base 2
define :digit_count do |n,num=1,base=2|
  n.to_s(base).count(num.to_s)
end

# Sum of digits in given base, for example:
# http://oeis.org/A000120
# http://oeis.org/A007953
# http://oeis.org/A053735
define :digit_sum do |n,base=2|
  n.to_s(base).chars.reduce(0) { |sum,n| sum = sum.to_i + n.to_i}
end

# https://oeis.org/A004718
# https://web.archive.org/web/20071010092358/http://www.pernoergaard.dk/eng/strukturer/uendelig/ukonstruktion03.html
define :norgard do |n|
  n.to_s(2).chars.reduce(0) {|s,b| b == '1' ? s+1 : -s }
end

# Get all integers that sum to given integer (Not including 1 and itself)
define :integer_sum do |value, max = value|
  if value == 0
    [[]]
  else
    2.upto(max-1).flat_map do |n|
      integer_sum(value - n, [value, n].min).map do |ns|
        [n] + ns
      end
    end
  end
end

# Get all divisors to integer divided to integers that lead to even, odd or primes (Not including 1 and itself)
define :divisors do |s|
  parts = {:to_even=>[], :to_odd=>[], :to_prime=>[]}
  (2..s-1).map do |i|
    if s%i==0
      parts[:even].push(s/i)
    else
      if ((2..Math.sqrt(i)).none? { |n| (i % n).zero? })
        parts[:prime].push(i)
      else
        parts[:odd].push(i)
      end
    end
  end
  parts
end