Вот пример вычисления ряда Фибоначчи с использованием рекурсии в Rust:

fn fibonacci_recursive(n: u32) -> u32 {
    if n <= 1 {
        return n;
    }

    return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2);
}
fn main() {
    let n = 10;
    for i in 0..n {
        println!("Fibonacci({}) = {}", i, fibonacci_recursive(i));
    }
}

В этом коде мы определяем функцию fibonacci_recursive, которая принимает на вход 32-битное целое число без знака nи возвращает число Фибоначчи в позиции n. Базовый случай — когда nменьше или равно 1, и в этом случае мы просто возвращаем n. В противном случае мы рекурсивно вызываем fibonacci_recursiveдля n-1и n-2и суммируем результаты.

Что касается других методов расчета ряда Фибоначчи, вот несколько альтернатив:

1. Итеративный подход с использованием циклов:

   fn fibonacci_iterative(n: u32) -> u32 {
   if n <= 1 {
       return n;
   }
   let (mut a, mut b) = (0, 1);
   for _ in 2..=n {
       let temp = a + b;
       a = b;
       b = temp;
   }
   return b;
   }

2. Использование мемоизации для оптимизации рекурсивного подхода:

   use std::collections::HashMap;
   fn fibonacci_memoization(n: u32, memo: &mut HashMap<u32, u32>) -> u32 {
   if n <= 1 {
       return n;
   }
   
   if memo.contains_key(&n) {
       return *memo.get(&n).unwrap();
   }
   
   let result = fibonacci_memoization(n - 1, memo) + fibonacci_memoization(n - 2, memo);
   memo.insert(n, result);
   
   return result;
   }
   fn fibonacci_with_memoization(n: u32) -> u32 {
   let mut memo: HashMap<u32, u32> = HashMap::new();
   return fibonacci_memoization(n, &mut memo);
   }

3. Метод матричного возведения в степень (эффективен для больших n):

   fn multiply_matrix(a: [[u32; 2]; 2], b: [[u32; 2]; 2]) -> [[u32; 2]; 2] {
   let mut result = [[0; 2]; 2];
   for i in 0..2 {
       for j in 0..2 {
           for k in 0..2 {
               result[i][j] += a[i][k] * b[k][j];
           }
       }
   }
   return result;
   }
   fn power_matrix(a: [[u32; 2]; 2], n: u32) -> [[u32; 2]; 2] {
   if n == 0 || n == 1 {
       return a;
   }
   
   let mut result = [[1, 0], [0, 1]];
   let mut base = a;
   let mut exp = n;
   
   while exp > 0 {
       if exp % 2 == 1 {
           result = multiply_matrix(result, base);
       }
       base = multiply_matrix(base, base);
       exp /= 2;
   }
   
   return result;
   }
   fn fibonacci_matrix_exponentiation(n: u32) -> u32 {
   let base = [[1, 1], [1, 0]];
   let result = power_matrix(base, n);
   return result[0][1];
   }

Это всего лишь несколько примеров вычисления ряда Фибоначчи в Rust с использованием разных подходов. Не стесняйтесь выбирать тот, который лучше всего соответствует вашим потребностям.