Find the odd int - Ruby Nested Loop Error

if count % 2.0 != 0
      int << b
    end

The problem you have here is that your pushing b instead of a into the integer array, so what's happening is that instead of the value that you counted being pushed in, your pushing in the last value of b which is the last value element in the array regardless as long as the condition that the counter is an odd number, although b and counter have nothing to do with each other. so to fix it you replace b with a so that it pushes in the value you are testing comparing with the other elements in the second loop

fix:

if count % 2.0 != 0
      int << a
    end

a similar yet simpler code that does a similar job except in a shorter and more understandable way is:

def find_it(seq)
  numberWithOddCount = 0
  seq.each do |currentElement|
    counter = 0
    seq.each { |elementToCompare| counter += 1 if currentElement == elementToCompare}
    numberWithOddCount = currentElement if counter % 2 != 0
  end
  numberWithOddCount
end

Just added a few tid-bits that you could also utilize to shorten and simplify code.

Happy Coding!

Note:

You could utilize built in ruby methods in creative ways to make the code do what you want in very few lines (or even one line) such as what @iGian did in the questions comments, but if your still new to ruby then its best to utilize those methods one by one when learning them otherwise you'll be confused. But if your willing to take the time now to learn them, I suggest you take his code and separate each method execution into its own line and output what each method had done to know what's doing what. and practice using each separately.

def find_it(seq)
  seq.group_by{|x| x}.select{|k, v| (v.count % 2.0 !=0)}.first[0]
end

The above code will take a sequence in an array. Here we are grouping by elements:

For example:

[1,1,2,-2,5,2,4,4,-1,-2,5].group_by{|x| x}
# => {1=>[1, 1], 2=>[2, 2], -2=>[-2, -2], 5=>[5, 5], 4=>[4, 4], -1=>[-1]}

after getting the above results, we are finding the whose elements count not odd with the select condition.

ex:

[1,1,2,-2,5,2,4,4,-1,-2,5].group_by{|x| x}.select{|k, v| (v.count % 2.0 !=0)}

we will get the results as {-1=>[-1]}

we are taking the key as result element.

@aimen_alt is right about your mistake

but let's decompose your problem.

First, you need to calculate the appearances of each number. Second, you need to find the one with the odd count of the appearances. Accordingly to the problem, there is only one such number, so you can return it right away.

You can go your way and do it in O(N^2) complexity by scanning your sequence for each item in the sequence (so N items in the sequence multiply by the size of the sequence N = N*N). You can do it linearly* by constructing a Hash and than you'll be able to get the key with odd value:

def find_it(seq)
  numbers = {}
  seq.each do |item|
    numbers[item] = numbers[item].to_i + 1
  end
  numbers.select{ |k,v| v.odd? }.first.first
end

to be more idiomatic you can use group_by to group the numbers themselves:

seq = [1, 2, 6, 1, 2]
seq.group_by{ |item| item }
#=> {1=>[1, 1], 2=>[2, 2], 6=>[6]}

You can see that each value is an Array, and you just need to get one with the odd amount of items:

seq = [1, 2, 6, 1, 2]
seq.group_by{ |item| item }.select{ |k, v| v.size.odd? }
#=> {6=>[6]}

And the last thing you would like to do is to get the value of the key:

seq.group_by{ |item| item }.select{ |k, v| v.size.odd? }.keys.first

So, the final solution would be

def find_it(seq)
  seq.group_by{ |item| item }
     .select{ |k, v| v.size.odd? }
     .keys
     .first
end

as @pascalbetz mentioned:

def find_it(seq)
  seq.group_by{ |item| item }
     .find{ |k, v| v.size.odd? }
     .first
end

What about this one

def find_it(seq)
  seq.reduce(:^)
end

^ -> this symbol is bitwise XOR. reduce function is taking each value and doing whatever work assigned inside. In this case, it's taking each element and doing an XOR operation. the first element is doing XOR with zero and the next element doing XOR with the previous result and so on.

In this way, we found the odd element.

How XOR operation work

0 ^ 2 = 2
4 ^ 4 = 0

If you want to know more about XOR. kindly refer to this.

Thank you for all the detailed answers, I'm going over everyone's answers now. I'm new to Ruby, and I'm still in the process of learning the methods/rules of using them/Big O notation, so I much appreciated everyone's input. Codewar listed some top ranked solutions. This seems to be the fastest so far:

def find_it(seq)   
   seq.detect { |n| seq.count(n).odd? } 
end