Aplicación práctica del algoritmo para la representación de Zeckendorff

Como en el pasado

Escribí un artículo sobre el algoritmo recursivo de Zeckendorff: post

Código de muestra

def le_fib(limit, fib)
  theoretical = fib[fib.count - 1] + fib[fib.count - 2]
  return fib.last if theoretical > limit

  fib << theoretical
  le_fib(limit, fib)
end

def main(target,result)
  temporary = le_fib(target, [1,1])
  result << temporary
  return result if target - temporary <= 0

  main(target - temporary, result)
end
pp main(gets.to_i,[])

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Función  Le_fib  : busca de forma recursiva una serie de Fibonacci con un límite, de modo que el siguiente número no sea mayor que el número objetivo de entrada  . Es importante aquí que no estemos interesados ​​en toda la serie de Fibonacci, solo su final es importante para nosotros.

La función  principal  : busca recursivamente una matriz cuyos números sean números de Fibonacci, y que juntos nos darían un número de entrada.

Aunque en verdad, los comentarios sugirieron una solución más elegante:

Un ciclo y negocio

n, F = 100, [1, 2]
while F[-1] < n do
  F << F[-2] + F[-1]
end
F.reverse.each do |f|
  if f <= n
    n -= f
    print f
    print '+' if n > 0
  end
end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

En la práctica, usaré el segundo algoritmo, ya que está menos sobrecargado con acciones innecesarias.

Enunciado del problema en el que "impulsaremos este algoritmo"

Hay un cierto conjunto de productos, relativamente hablando:

[Pollo, tomates, lavash, champiñones].

Estos productos tienen un valor tanto de costo como de usuario final.

Por ejemplo, la gradación se puede hacer de la siguiente manera

[pollo> tomates> champiñones> lavash] .

, 1 "Low cost", 1 "High cost" .

().

( Ruby) , .

, .

x y .

1. 

   

2. Y - .
   
   
   
   - , .
   
   
   
   . Y

   
   
   
   
   

   

3. 1 89. , "Middle cost" .
   
   
   
   3 x = 1 y = 143.

   
   
   
   
   

, :

• - ( )

  
  
  
  
  

• Collector, Hash ( -> , -> )

  
  
  
  
  

, autoloader , .

, Telegram , .

, ,

@fib = [1,2,3,5,8,13,21,34,55,89]
    def collect_the_items
      food_hash = Hash.new
      (0..9).each do |iterator|
        food_hash[@fib[iterator]] = FOOD.first[iterator]
      end
      puts food_hash.map{|key,value| "#{key} - #{value}"}
    end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, :

def get_sequence(limit)  
  result = []  n, fib = limit, [1, 2]  
  while fib[-1] < n do
    fib << fib[-2] + fib[-1]  end
  fib.reverse.each do |f|    if f <= n
      n -= f
      result << f
    end
  end
  result
end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

- .

def generate_food
          food_array = Collector.collect_the_items
          food = []
          rarity = rand(1..143)
          get_sequence(rarity).each do |key|
            food << food_array[key]
          end
          food
end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, 6 , .

. - .

:

Low cost : ?

Mid cost : ?

High cost : ?

Aplicar el algoritmo de representación de Zeckendorff me satisface por completo. Es decir, realiza la tarea que se le asigna.

Uno de los primeros comentarios bajo el artículo en el que se basa esta aplicación práctica, me acaba de hacer la pregunta: "pero realmente, ¿dónde se puede aplicar esto?" Como puede ver, este algoritmo se puede utilizar para tales tareas.

Y no estoy diciendo que esta sea la única opción correcta para compilar una lista de productos para mi bot, pero realmente funciona bastante bien.