Programming101-Ruby/week03/3-My-Enumerable/solution.rb at b02f47bdf769cfe4f6691bbe29098a6cbb43ac0e · HackBulgaria/Programming101-Ruby · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
# Implementation of our own Enumerable class
module MyEnumerable
  def map
    Array.new.tap do |arr|
      each do |element|
        value = yield element
        arr << value
      end
    end
  end

  def filter
    Array.new.tap do |arr|
      each do |element|
        arr << element if (yield element) == true
      end
    end
  end

  def reject
    Array.new.tap do |arr|
      each do |element|
        arr << element if (yield element) == false
      end
    end
  end

  def reduce(initial = nil)
    each do |element|
      if initial.nil?
        initial = element
      else
        initial = yield element, initial
      end
    end
    initial
  end

  def any?
    each do |element|
      if (yield element) == false
        false
      else
        return true
      end
    end
  end

  def all?
    each do |element|
      if (yield element) == false
        return false
      else
        true
      end
    end
  end

  def include?(element)
    each do |item|
      if item == element
        return true
      else
        false
      end
    end
  end

  def count(element = nil)
    counter = 0
    each do |item|
      counter += 1 if element.nil?
      counter += 1 if item == element
    end
    counter
  end

  def size
    counter = 0
    each do
      counter += 1
    end
    counter
  end

  def min
    reduce do |element, accumulator|
      accumulator > element ? element : accumulator
    end
  end

  def min_by
    reduce do |element, accumulator|
      (yield accumulator) > element.size ? element : accumulator
    end
  end

  def max
    reduce do |element, accumulator|
      accumulator < element ? element : accumulator
    end
  end

  def max_by
    reduce do |element, accumulator|
      (yield accumulator) < element.size ? element : accumulator
    end
  end

  def take(n)
    counter = 0
    Array.new.tap do |arr|
      each do |element|
        return Array.new if n == 0
        arr << element
        counter += 1
        break if counter == n
      end
    end
  end

  def take_while
    Array.new.tap do |arr|
      each do |element|
        if (yield element) == true
          arr << element
        else
          break
        end
      end
      return [] if arr.size == 0
    end
  end

  def drop(n)
    counter = 0
    Array.new.tap do |arr|
      each do |element|
        arr << element if counter >= n
        counter += 1
      end
    end
  end

  def drop_while
    counter = 0
    each do |element|
      counter += 1 if (yield element) == true
      return drop(counter) if (yield element) == false
    end
  end
end