Aplikasi Praktis Algoritma untuk Representasi Zeckendorff

Seperti dulu

Saya menulis artikel di Recursive Zeckendorff Algorithm: post

Kode sampel

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

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Fungsi  le_fib  - mencari deret Fibonacci dengan batas secara rekursif, sehingga angka berikutnya tidak lebih besar dari nomor target masukan  . Penting di sini bahwa kita tidak tertarik pada keseluruhan deret Fibonacci, hanya ujungnya yang penting bagi kita.

Fungsi  utama  - secara rekursif mencari larik yang angkanya adalah bilangan Fibonacci, dan yang akan memberi kita jumlah masukan secara total.

Meskipun sebenarnya, komentar tersebut menyarankan solusi yang lebih elegan:

Satu siklus dan bisnis

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
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Dalam praktiknya, saya akan menggunakan algoritme kedua karena tidak terlalu kelebihan beban dengan tindakan yang tidak perlu.

Pernyataan masalah di mana kita akan "mendorong algoritma ini"

Ada serangkaian produk tertentu, secara relatif:

[Ayam, tomat, lavash, jamur].

Produk ini memiliki biaya dan nilai pengguna akhir.

Misalnya, gradasi dapat dilakukan sebagai berikut

[ayam> tomat> jamur> 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 : ?

Menerapkan algoritma representasi Zeckendorff benar-benar memuaskan saya. Artinya, ia melakukan tugas yang ditugaskan padanya.

Salah satu komentar pertama di bawah artikel yang menjadi dasar penerapan praktis ini, hanya mengajukan pertanyaan kepada saya: "tapi sungguh, di mana ini bisa diterapkan?" Seperti yang Anda lihat, algoritme ini dapat digunakan untuk tugas semacam itu.

Dan saya tidak mengatakan bahwa ini adalah satu-satunya opsi yang benar untuk menyusun daftar produk untuk bot saya, tetapi ini benar-benar mampu dan berfungsi.