function that returns the number of letters that repeat in a string

Question

Trying to make a function that counts the number of letters that appear more than once anywhere in a string (not necessarily together, and not the the number of times they repeat). This is what I have:

def num_repeats(string)

    repeat = []

    i1 = 0
    i2 = 1
    while i1 < string.length 
        while  i2 < string.length
            if (string[i1] == string[i2]) && (!repeat.include? string[i1]) 
                repeat << string[i1]
            end
            i2 +=1
        end 
        i1+=1
    end

    return repeat.length
end

puts(num_repeats('sldhelanlaskjkajksda'))

For some reason, it only pushes the first letter of the string if that first letter has been used in the rest of the string, but after that, it seems like the method stops looping through the rest of the string.

I'd like to know first why the current code is not working and if there is a way to fix it, and I also welcome other better solutions.

Answer 1

Here is an orthodox way to do it:

'sldhelanlaskjkajksda'.each_char.group_by(&:itself).count{|_, v| v.length > 1}
# => 6

---

The reason your code does not work is because, (i) once the i2 loop terminates, you increment i1, and try for another i2 loop in the next i1 iteration, but since i2 hasn't been touched after failed to satisfy the loop condition, it will not satisfy the condition again, and the i2 loop will never run again, and (ii) you are initializing i2 to a constant.

To fix it, initialize i2 within i1 loop at the beginning, and initialize it to i2 = i1 + 1, not 1.

Answer 2

Another way:

s = 'sldhelanlaskjkajksda'

a = s.chars
  #=> ["s", "l", "d", "h", "e", "l", "a", "n", "l", "a",
  #    "s", "k", "j", "k", "a", "j", "k", "s", "d", "a"] 
a.difference(a.uniq).uniq.size
  #=> 6

where Array#difference is defined in my answer here.

We have:

b = a.uniq
  #=> ["s", "l", "d", "h", "e", "a", "n", "k", "j"] 
c = a.difference(b)
  #=> ["l", "l", "a", "s", "k", "a", "j", "k", "s", "d", "a"] 
d = c.uniq
  #=> ["l", "a", "s", "k", "j", "d"] 
d.size
  #=> 6 

Answer 3

None of these answers consider that OP asked for repeating letters

But this does:

'sldhe-lanlas-kjkajksda'.scan(/([a-z])(?=.*\1)/i).uniq.size
#=> 6

Answer 4

This is the solution for your problem

    def num_repeats(string)
        repeat = []
        i1 = 0
        i2 = 1

        while i1 < string.length
            while  i2 < string.length
                if (string[i1] == string[i2]) && !(repeat.include? string[i1]) 
                    repeat << string[i1]
                end
               i2 +=1
            end 
            i1+=1
            i2 = i1 + 1
        end
        return repeat.length
    end 
    puts(num_repeats('sldhelanlaskjkajksda'))

Answer 5

Here is bit simpler (hopefully) and little Ruby-ish, solution:

def num_repeats(string)

    # chars in string
    chars = string.split('')

    # initialize map - for each char, count is initialized to 0
    hash = chars.uniq.inject({}) { |h, c| h[c] = 0; h}

    # for each char in string, lets count its occurrences
    chars.each do |c| 
        hash[c] += 1
    end

    # now lets pick those entries from the map where the count is > 1
    hash_with_repeated_chars = hash.select {|k, v| v > 1 }

    # now lets pick the chars that are repeated by picking keys of hash
    repeated_chars = hash_with_repeated_chars.select { |k, v| k}

    # return the count of repeated chars
    return repeated_chars.count
end

p num_repeats('abc')    # Prints 0
p num_repeats('abbc')   # Prints 1
p num_repeats('abbcc')  # Prints 2
p num_repeats('aabbcc') # Prints 3

---

I also have a Ruby version that is different from all other answers (and hence, bit inefficient due to multiple iterations it does internally)

s = 'sldhelanlaskjkajksda'
p s.chars.combination(2).to_a.uniq.map(&:sort).map(&:uniq).select{|a| a.size.eql?(1)}.count

Answer 6

Create a hash and set the default value to 0. Use the gsub method to remove all white space from the string. Convert the string into an array of string characters using the split method. Iterate over each letter in the array and store the key as each letter and the number of times each letter occurs as the key's value. Finally Remove any key from the hash with a value that is less than 2. Return the hash's length since this corresponds to the number of letters in the hash that have occurred more than once in your original string. Hope this explanation helps and that it answers your question. The code below could be more compact but it is in its current form in the hopes of being more explanatory and informative.

  def counter(string)
  counts = Hash.new(0)
  result = string.gsub(" ","")
  result = result.split('')

  result.each do |letter|
    counts[letter] += 1
  end

  counts.delete_if { |key,value| value < 2}

  return counts.length

end