How to skip over whitespaces in .map. Ruby

Question

This is my code:

def weirdcase (string)
  string.chars.map.with_index { |letter, index|
    unless index.odd?;
      letter = letter.upcase
    else
      letter
    end }.compact.join("")
end

This is what it's supposed to do:

"ThIs Is A TeSt"

And this is what I got:

"ThIs iS A TeSt"

It's giving me the wrong string in return because it's counting/including the white spaces in my code. All I need to do is find a way to skip the white spaces then I'm good to go. Thanks!

question from:https://stackoverflow.com/questions/65948008/how-to-skip-over-whitespaces-in-map-ruby

Answer 1

The problem

I assume that the objective is to capitalize, for each word, all letters at even indices (the first letter of the word having index zero).

Here are two ways to do that. Both methods use String#gsub with a regular expression. Depending on requirements it may be necessary to change str.gsub... to str.downcase.gsub... for both methods.

Use a regular expression to match one- or two-characters strings, two if possible, and capitalize those strings.

def weirdcase(str)
  str.gsub(/(?<=A| |[^ ]{2})[^ ]{1,2}/) { |s| s.capitalize } 
end

weirdcase "this is a sentence for    testing"
  #=> "ThIs Is A SeNtEnCe FoR    TeStInG"

The regular expression reads, "match one or two characters other than spaces, two if possible ([^ ]{1,2}), that are immediately preceded by one of the following: the beginning of the string (A), a space or two characters other than spaces. (?<=A| |[^ ]{2}) is a positive lookbehind.

s.capitalize invokes the method String#capitalize on the match.

Use a cycling enumerator

def weirdcase(str)
  enum = [:upcase, :downcase].cycle
  str.gsub(/./) do |s|
    if s == ' '
      enum.rewind
      ' '
    else
      s.public_send(enum.next)
    end
  end
end

weirdcase "this is a sentence for testing"
  #=> "ThIs Is A SeNtEnCe FoR TeStInG"

The regular expression /./ matches each character in the string.

See Array#cycle, Enumerator#rewind, Enumerator#next and Object#public_send.

Note the following.

enum = [:upcase, :downcase].cycle
  #=> #<Enumerator: [:upcase, :downcase]:cycle>
enum.next
  #=> :upcase
enum.next
  #=> :downcase
enum.next
  #=> :upcase                       
enum.rewind
  #=> #<Enumerator: [:upcase, :downcase]:cycle>
enum.next
  #=> :upcase
enum.next
  #=> :downcase
... ad infinitum