#Выполнил задание

test/newil86/arrays/solution.rb

@@ -0,0 +1,27 @@
+module Newil86
+  module Arrays
+    include Enumerable
+    class << self
+      def replace(array)
+        max_val = array.max
+        array.map { |elem| elem > 0 ? max_val : elem }
+      end
+
+      def search(array, find)
+        first = 0
+        last = array.length - 1
+        while first <= last
+          middle_elem = (last - first) / 2 + first
+          if find < array[middle_elem]
+            last = middle_elem - 1
+          elsif find > array[middle_elem]
+            first = middle_elem + 1
+          else
+            return middle_elem
+          end
+        end
+        -1
+      end
+    end
+  end
+end

test/newil86/arrays/test.rb

@@ -0,0 +1,25 @@
+require './test/test_helper.rb'
+require_relative './solution.rb'
+
+class Newil86::ArraysTest < Minitest::Test
+  # Заменить все положительные элементы целочисленного массива на максимальное значение элементов массива.
+  def test_replace
+    array = [3, 2, -8, 4, 100, -6, 7, 8, -99]
+    new_array = Newil86::Arrays.replace(array)
+    assert new_array == [100, 100, -8, 100, 100, -6, 100, 100, -99]
+  end
+
+  # Реализовать бинарный поиск
+  # Функция должна возвращать индекс элемента
+  def test_bin_search
+    assert Newil86::Arrays.search([1], 900) == -1
+    assert Newil86::Arrays.search([1], 1) == 0
+    assert Newil86::Arrays.search([], 900) == -1
+    assert Newil86::Arrays.search([1, 4, 5, 7, 8, 9], 9) == 5
+    assert Newil86::Arrays.search([1, 4, 5, 7, 8, 9], 1) == 0
+    assert Newil86::Arrays.search([1, 4, 5, 7, 8, 9], 6) == -1
+
+    array = (1..10000).to_a
+    assert Newil86::Arrays.search(array, array[1000]) == 1000
+  end
+end

test/newil86/fp/solution.rb

@@ -0,0 +1,26 @@
+module Newil86
+  module Fp
+    class << self
+      # Обратиться к параметрам фильма можно так:
+      # film["name"], film["rating_kinopoisk"], film["rating_imdb"],
+      # film["genres"], film["year"], film["access_level"], film["country"]
+      def rating(array)
+        filtered_films = array.select do |film|
+          !film['country'].nil? && film['country'].split(',').length >= 2 && !film['rating_kinopoisk'].to_f.zero?
+        end
+
+        rating_sum = filtered_films.map { |film| film['rating_kinopoisk'].to_f }.reduce(:+)
+        rating_sum / filtered_films.length
+      end
+
+      def chars_count(films, threshold)
+        letter = 'и'
+
+        selected = films.select do |item|
+          item['rating_kinopoisk'] && item['rating_kinopoisk'].to_f >= threshold
+        end
+        selected.map { |item| item['name'].count(letter) }.reduce(:+)
+      end
+    end
+  end
+end

test/newil86/fp/test.rb

@@ -0,0 +1,25 @@
+require 'csv'
+require './test/test_helper.rb'
+require_relative './solution.rb'
+
+class Newil86::FpTest < Minitest::Test
+  # Посчитать средний рейтинг фильмов по версии кинопоиска у которых две или больше стран
+  # Фильмы у которых рейтиг не задан или равен 0 не учитывать в расчете среднего.
+  def test_rating
+    array = CSV.readlines('./test/fixtures/films.csv', headers: true)
+
+    result = Newil86::Fp.rating(array)
+    assert result == 6.809410385259628
+  end
+
+  # Посчитать количество фильмов в которые входит буква 'и' в названиях всех фильмов с рейтингом кинопоиска больше или равным заданному значению
+  def test_chars_count
+    array = CSV.readlines('./test/fixtures/films.csv', headers: true)
+
+    result = Newil86::Fp.chars_count(array, 5)
+    assert result == 3850
+
+    result = Newil86::Fp.chars_count(array, 8.5)
+    assert result == 40
+  end
+end

test/newil86/fp2/solution.rb

@@ -0,0 +1,38 @@
+module Newil86
+  module Fp2
+    class MyArray < Array
+      # Использовать стандартные функции массива для решения задач нельзя.
+      # Использовать свои написанные функции для реализации следующих - можно.
+
+      # Написать свою функцию my_each
+      def my_each
+        for index in 0..(length - 1)
+          yield(self[index])
+        end
+        self
+      end
+
+      # Написать свою функцию my_map
+      def my_map
+        arr = MyArray.new
+        my_each { |elem| arr << yield(elem) }
+        arr
+      end
+
+      # Написать свою функцию my_compact
+      def my_compact
+        ary = MyArray.new
+        my_each { |elem| ary << elem unless elem.nil? }
+        ary
+      end
+
+      # Написать свою функцию my_reduce
+      def my_reduce(sum = nil)
+        arr_copy = MyArray.new(self)
+        sum = sum.nil? ? arr_copy.shift : sum
+        arr_copy.my_each { |i| sum = yield(i, sum) }
+        sum
+      end
+    end
+  end
+end

test/newil86/fp2/test.rb

@@ -0,0 +1,45 @@
+require 'csv'
+require './test/test_helper.rb'
+require_relative './solution.rb'
+
+class Newil86::Fp2Test < Minitest::Test
+  def setup
+    @array = generate :array
+    @my_array = Newil86::Fp2::MyArray.new(@array)
+    @int = generate :int
+  end
+
+  def test_my_each
+    result = []
+    my_result = []
+
+    func = -> (element) { result << element if element.odd? }
+    my_func = -> (element) { my_result << element if element.odd? }
+
+    assert @array.each(&func) == @my_array.my_each(&my_func)
+    assert result == my_result
+  end
+
+  def test_my_map
+    func = -> (element) { element * @int }
+    assert @array.map(&func) == @my_array.my_map(&func)
+    assert @array.map(&func).map(&func) == @my_array.my_map(&func).my_map(&func)
+  end
+
+  def test_my_compact
+    func = -> (element) { element if element.even? }
+    func_another = -> (element) { element * @int }
+    func_yet_another = -> (element) { element.even? }
+    assert @array.map(&func).compact == @my_array.my_map(&func).my_compact
+    assert @array.map(&func).compact.map(&func_another) == @my_array.my_map(&func).my_compact.my_map(&func_another)
+    assert @array.map(&func_yet_another).compact == @my_array.my_map(&func_yet_another).my_compact
+  end
+
+  def test_my_reduce
+    func = -> (acc, element) { acc * element }
+
+    assert @array.reduce(&func) == @my_array.my_reduce(&func)
+    assert @array.reduce(2, &func) == @my_array.my_reduce(2, &func)
+    assert @array.reduce(&:+) == @my_array.my_reduce(&:+)
+  end
+end