Praktische Anwendung des Algorithmus zur Zeckendorff-Darstellung

Wie in der Vergangenheit

Ich habe einen Artikel über den rekursiven Zeckendorff-Algorithmus geschrieben: post

Beispielcode

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,[])

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Die Funktion  le_fib  sucht rekursiv nach einer Fibonacci-Reihe mit einem Limit, sodass die nächste Zahl nicht größer als die eingegebene Zielnummer ist  . Hier ist es wichtig, dass wir uns nicht für die gesamte Fibonacci-Serie interessieren, sondern nur für deren Ende.

Die  Hauptfunktion  - rekursiv sucht nach einem Array , deren Zahlen sind Fibonacci - Zahlen, und die zusammen würde uns eine Eingangsnummer.

Obwohl in Wahrheit, schlugen die Kommentare eine elegantere Lösung vor:

Ein Zyklus und Geschäft

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
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

In der Praxis werde ich den zweiten Algorithmus verwenden, da er weniger mit unnötigen Aktionen überlastet ist.

Problemstellung, wo wir "diesen Algorithmus pushen" werden

Relativ gesehen gibt es eine Reihe von Produkten:

[Huhn, Tomaten, Lavash, Pilze].

Diese Produkte haben sowohl einen Wert als auch einen Wert für den Endverbraucher.

Zum Beispiel kann die Abstufung wie folgt erfolgen

[Huhn> Tomaten> Pilze> 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 : ?

Die Anwendung des Zeckendorff-Darstellungsalgorithmus befriedigt mich voll und ganz. Das heißt, es führt die ihm zugewiesene Aufgabe aus.

Einer der ersten Kommentare unter dem Artikel, auf dem diese praktische Anwendung basiert, stellte mir nur die Frage: "Aber wirklich, wo kann dies angewendet werden?" Wie Sie sehen können, kann dieser Algorithmus für solche Aufgaben verwendet werden.

Und ich sage nicht, dass dies die einzig richtige Option ist, um eine Liste von Produkten für meinen Bot zusammenzustellen, aber es ist wirklich ziemlich fähig und funktioniert.