Added 10 kata in Ruby

Author: malachispencer

ruby/5kyu/valid-parentheses.rb

@@ -0,0 +1,78 @@
+=begin
+Codewars. 30/04/20. "Valid Parentheses". 5kyu. Here we create a method that
+takes a string of parentheses and determines whether the order of the
+parentheses is valid. For example, "(())((()())())" would be valid and so we
+return true, ")(()))" would be false and so we return false. Here is the
+solution I used to solve the challenge.
+1) We define our method valid_parentheses_ms?, which takes a string as an
+ argument.
+2) We initialise a counter called bal (for balance), this will keep track of
+ the balance of our parentheses as we iterate over our string.
+3) We call the each_char method, which allows us to iterate over each character
+ of our string.
+4) If our character is an open parenthesis "(" our count increments by 1, if
+ our character is a close parenthesis ")", we decrement by 1. If the balance
+ is ever -1, that means we have a new close parenthesis coming before any
+ open parenthesis and so we can return false right away.
+5) If our loop has finished, we didn't encounter a close coming before an open,
+ but we may have more open's than closes, in which case bal > 0 and we return
+ false.
+6) If bal is 0, our parentheses are valid because there are an equal and
+ correctly ordered amount of open and closed parentheses, so we return true.
+=end
+
+def valid_parentheses_ms?(str)
+ bal = 0
+ str.each_char do |c|
+ return false if bal == -1
+ bal += 1 if c == "("
+ bal -= 1 if c == ")"
+ end
+ bal == 0 ? true : false
+end
+
+=begin
+Here is another solution, submitted by a Codewars user.
+1) We convert our string to an array of characters, then we call
+ each_with_object on it and iterate over every character.
+2) If we encounter an open parenthesis, we add it to the new array (stack)
+ using push.
+3) If we encounter a close parenthesis after an open, we delete that open
+ parenthesis from the stack.
+4) If we encounter a close parenthesis and there is no open parenthesis to
+ remove from the stack, pop will return nil, which means we have a close
+ before an open and so we return false immediately.
+5) Once we've iterated through the entire array of characters, if stack is
+ empty the parentheses were balanced and so true is returned. If stack is
+ not empty, that means it contains 1 or more open parenthesis, with of course
+ no close's to match, in which case the parentheses are not valid, so false
+ is correctly returned.
+=end
+
+def valid_parentheses_x(str)
+ str.chars.each_with_object([]) do |c, stack|
+ if c == '('
+ stack.push(c)
+ elsif c == ')'
+ stack.pop or return false
+ end
+ end.empty?
+end
+
+=begin
+Here is another solution, which uses gsub and a regex.
+1) We delete every character apart from parentheses from the string.
+2) We start a while loop and call the gsub! method with open and closed
+ parentheses as the pattern to match. gsub continues to remove pairs of open
+ and closed parentheses until there is no pattern left to match.
+3) If after gsub has performed its work the string is empty, the string only
+ consisted of balanced pairs and so the condition is true, if the string is
+ not empty, all of the parentheses were not balanced and so the condition is
+ false.
+=end
+
+def valid_parentheses(str)
+ str = str.delete("^()")
+ while str.gsub!("()","") ; end
+ str == ""
+end

ruby/6kyu/codwars-or-codewars.rb

@@ -0,0 +1,52 @@
+=begin
+Codewars. 06/06/20. "Codwars or Codewars?". 6kyu. Here we create a method that accepts a URL as a string and determines if it would result
+in a request to codwars.com. The URLs are all valid but may or may not contain a scheme, they may or may not contain subdirectories, and 
+they may or may not contain query strings. The subdomain may be "codewars.com" in a URL with a codwars domain and visa versa e.g. 
+"http://codewars.com.codwars.com". The directory in the path may contain "codewars.com" and visa versa e.g. 
+"https://this.is.an.unneccesarily.long.subdomain.codwars.com/katas.are.really.fun.codewars.com/". The query string may also contain
+"codewars.com" or "codwars.com". Here is the solution I developed to solve the challenge.
+1) We require the the URI (Univeral Resource Identifier) library from Ruby's built-in URI class, which allows us to parse URLs. A URL
+ (Uniform Resource Locator) is a specific type of URI which normally locates an existing resource on the Internet.
+2) A URL consists of a scheme, a host (which may include a port number), a path and a query string.
+ 1) Format: scheme://host:port/path?query
+ 2) Example without port: http://www.codewars.com/path?this=is&a=querystring
+ 3) Example with port: http://www.example.com:1030/software/index.html?this=is&a=querystring
+2) We define our method codwars_ms?, with takes a string URL. The Ruby developer convention is to place a question mark at the end of 
+ methods which return true or false.
+3) Using the URI.parse method with the string URL passed in, we check if the URL doesn't contain a scheme, if not, we add one to it. 
+ Taking this step will allow us to extract the host much easier.
+4) Using the host method from the URI class, we extract the host from the url. Now the scheme, path and querystring have all been removed
+ from the URL, making it much easier for us to use a regex to check whether it's a codwars domain.
+5) In a URL, the host consists of the subdomain, domain name and the top level domain, here are 2 examples:
+ 1) freedomplatform.londonreal.tv: freedomplatform (subdomain), londonreal (domain), .tv (TLD).
+ 2) www.codewars.com: www. (subdomain), codewars (domain), .com (TLD).
+6) Using the case equality operator, we then use a regex to check whether the URL will result in a request to codwars.com. If so, our
+ method will return true, if not, it will return false.
+7) In our regex, ^ asserts the start of the string; (www\.|.+\.)? matches 0 or 1 of either "www." or 1 or more characters followed by a
+ dot, these are the potential subdomains; the subdomain - or nothing - should be followed by codwars.com at the end of the string, which 
+ we match with (codwars\.com)$.
+=end
+
+require "uri"
+
+def codwars_ms?(url)
+ url = "http://#{url}" if URI.parse(url).scheme.nil?
+ host = URI.parse(url).host
+ /^(www\.|.+\.)?(codwars\.com)$/ === host
+end
+
+=begin
+Here is another method which solves the challenge solely with a regex and the case equality operator.
+1) ^ asserts the start of the string.
+2) (https?:\/\/)? matches 0 or 1 scheme. Because the scheme could be http:// or https://, inside this capture group we place a 0 or 1
+ quantifier after s (s?).
+3) ([a-z]+\.)* matches the subdomain, which can be 1 or more groups of letters followed by a dot. Because a subdomain may not even exist,
+ we place a 0 or more quantifier after the capture group.
+4) codwars\.com matches the domain name and top level domain.
+5) ([?\/]|$) matches either the beginning of a querystring or the beginning of a path, or the end of the string. This comes straight after
+ codwars.com.
+=end
+
+def codwars?(url)
+ /^(https?:\/\/)?([a-z]+\.)*codwars\.com([?\/]|$)/ === url
+end

ruby/6kyu/compare-versions.rb

@@ -0,0 +1,48 @@
+=begin
+Codewars. 21/07/20. 'Compare Versions'. 6kyu. Here we create a method that takes two arguments, version 1 and version 2, it returns true
+if v1 is a newer or equal version than v2, and false if not. Here is the solution I developed to solve the challenge.
+1) We define our function compare_versions_ms, which takes two versions as its arguments.
+2) Our versions come in the form of strings, so first we split them at their dots, then map over the numbers and convert them to integers.
+ Now v1 and v2 are arrays of something like a major, minor, patch e.g. [10, 4, 6], although some inputs contain 2 numbers, 4 numbers or
+ more.
+3) Now we map over v1 with index, and we subtract the number in the same index position in v2. If v2 is shorter than v1 and so a number in
+ the corresponding index position doesn't exist, we subtract 0.
+4) Now we create a variable called con for condition, if every value in v1 is 0 or above, we can almost assume that it is the newer version,
+ provided we do one more check, that is, whether v2 has more numbers than v1, if that is the case, v2 is the newer version. So if all of
+ the numbers in v1 are 0 or greater, con is currently set to true.
+5) At this point, if con is false, we know for sure that v1 is not the newer version. For example, comparing 10.2.3 with 9.2.3 would give us
+ [-1, 0, 0].
+6) If con is currently true, but v2 is longer than v1, we return false because v1 is not the newer version. Otherwise, we return true.
+=end
+
+def compare_versions_ms(v1,v2)
+ v2 = v2.split('.').map(&:to_i)
+ v1 = v1.split('.').map(&:to_i)
+ v1 = v1.map.with_index {|n,i| n - (v2[i] || 0)}
+ con = v1.all? {|n| n >= 0}
+ con == false ? false : v2.size > v1.size ? false : true
+end
+
+=begin
+Here is a shorter solution which uses the spaceship operator.
+1) We split v1 into an array of its numbers, then map over the numbers and convert them to integers. We do the same for v2.
+2) We compare both arrays using the spaceship operator. The spaceship operator works in the following manner:
+ 1) v1 < v2 // -1
+ 2) v1 == v2 // 0
+ 3) v1 > v2 // 1
+ 4) v1 and v2 are not comparable // nil
+3) Thus if our spaceship operator comparison is greater than or equal to 0, we return true, if it's -1, we return false.
+=end
+
+def compare_versions(v1,v2)
+ (v1.split('.').map(&:to_i) <=> v2.split('.').map(&:to_i)) >= 0
+end
+
+=begin
+Here is another solution, which uses Ruby's built-in Version class to create version objects and then compare them with the greater than
+or equal to comparison operator.
+=end
+
+def compare_versions_x(v1,v2)
+ Gem::Version.new(v1) >= Gem::Version.new(v2)
+end

ruby/6kyu/simple-fun-#170-sum-groups.rb

@@ -0,0 +1,106 @@
+=begin
+Codewars. 24/04/20. 'Simple Fun #170: Sum Groups'. 6kyu. Given an array of 
+integers, sum consecutive even numbers and consecutive odd numbers. Repeat 
+the process while it can be done and return the length of the final array. 
+Here is a refined version of the top solution on Codewars.
+1) We define our method sum_groups, which takes an array of integers as its
+ argument.
+2) We return the size of the array unless the array still contains any
+ consecutive even numbers. a.even? == b.even? essentially evaluates whether
+ both a.even? and b.even? are equal to true or false so if both are true we
+ don't return arr.size because we have consecutive evens. Likewise, if both
+ are false we don't return the array size, because we have consecutive odds.
+3) If there are consecutives, we call sum_groups recursively with the chunking
+ and summing process performed on the array.
+4) arr.chunk(&:even?) returns an array of arrays where each sub-array's first
+ element is a true (if it's even) and a false (if it's odd); the second
+ element in the sub-array is an array with all the consecutive values that
+ match the conditions of the first element.
+5) We then call map(&:last) to remove those first elements (booleans) and now
+ we have an array of arrays containing consecutive evens and consecutive odds.
+6) We map over the array of arrays and sum each sub-array, which essentially
+ sums all the odd consecutives and all the even consecutives.
+7) Now we have a new array of integers. If there are no consecutives, the size
+ of it is returned. If not, the chunk and sum process runs again. This
+ process continues until we have no consecutive odds or evens, then we
+ return the length of the final array.
+9) If our starting array is [2,1,2,2,6,5,0,2,0,5,5,7,7,4,3,3,9], after the
+ first recursive call it will be [2,1,10,5,2,24,4,15]. We have consecutives
+ [2,24,4] so a second recursive call is done, after which we have
+ [2,1,10,5,30,15]. Now we have no consecutives, so we return the array size,
+ 6.
+10) In this method, we could substitute a.even? == a.even? with
+ a.odd? == b.odd?, and it would still work, because what we're comparing is
+ equal boolean values, equal boolean values mean we have a consecutive,
+ either even or odd.
+11) We could also substitute arr.chunk(&:even?) with arr.chunk(&:odd?),
+ because regardless of which we use, consecutive odds and evens are grouped
+ together as a result of either argument being placed in the chunk method.
+12) Also, all 3 uses of even? could simply be uses of odd? and our method
+ still would work.
+=end
+
+def sum_groups(arr)
+ return arr.size unless arr.each_cons(2).any? {|a,b| a.even? == b.even?}
+ sum_groups(arr.chunk(&:even?).map(&:last).map(&:sum))
+end
+
+=begin
+Here is a refined version of another solution submitted by a Codewars user,
+which uses the slice_when method instead of the chunk method.
+1) We call the slice_when method on the array. The slice_when method takes 2
+ block variables representing element before and element after and groups an
+ array based on the block. It is similar to the chunk method.
+2) In our slice_when block we group together consecutive evens and odds in an
+ array of arrays and store this in a variable groups.
+3) We return the array size if every sub-array in groups contains 1 element,
+ which means we have no consecutives.
+4) If not, we resursively call the method with the sub-arrays - and hence
+ consecutives - summed.
+5) Once there are no consecutive odds or evens, every sub-array in groups will
+ contain 1 element, in which case the array size is returned.
+=end
+
+def sum_groups_sw(arr)
+ groups = arr.slice_when {|a,b| a.even? != b.even?}.to_a
+ return arr.size if groups.all? {|g| g.size == 1}
+ sum_groups_sw(groups.map(&:sum))
+end
+
+=begin
+Here is the method I found online that allowed me to pass the challenge, it's
+clever in that it doesn't sum the numbers at all, but it's not a method I
+would voluntarily use.
+1) We call the chunk method on our array of integers with odd? passed in as an
+ argument and turn this from an enumerator into an array. We essentially
+ create an array of arrays where the first element of each sub-array is a
+ boolean (true if odd, false if even) and the second element of the sub-array
+ is all the consecutive values matching the condition of the first element.
+ We store this in a variable chunks.
+2) We return the size of the array passed in if it is equal to the size of it
+ chunked, this basically means our original array has been chunked and
+ mapped down to contain no consecutives. If not, we run the "mapped" process
+ on chunks.
+3) In the "mapped" process - stored in the variable mapped - we call the map
+ method on the chunks array of arrays. If the first value is true (meaning
+ this was an odd number) and the size of the consecutive terms of this
+ number is odd also, we convert that entire sub-array to 1.
+4) In all other cases, i.e. if the first element if false (meaning the
+ number was even) or the first element is true but its consecutive terms are
+ even in quantity, the sub-array is converted to 0.
+5) If our original array we're [2,1,2,2,6,5,0,2,0,5,5,7,7,4,3,3,9], after being
+ chunked and mapped it would be [0,1,0,1,0,0,0,1]. Our method is then called
+ resursively with mapped passed in, mapped becomes arr and the size of mapped
+ is 8, so arr.size is 8. The size of mapped (arr) chunked is 6. So in this
+ instance the array size is not returned and the mapped process runs again.
+6) Once mapped is chunked and mapped again it becomes [0,1,0,1,0,1], this new
+ mapped is passed into the method again. This time mapped (arr) size (6) is
+ equal to its chunks size (6). This gives us the size of the final array, 6.
+=end
+
+def sum_groups_ms(arr)
+ chunks = arr.chunk(&:odd?).to_a
+ return arr.size if arr.size == chunks.size
+ mapped = chunks.map {|odd,terms| odd && terms.size.odd? ? 1 : 0}
+ sum_groups(mapped)
+end

ruby/6kyu/simple-string-indices.rb

@@ -0,0 +1,28 @@
+=begin
+Codewars. 11/05/20. "Simple string indices". 6kyu. Here we create a method
+that takes a string with brackets and an index of an opening bracket and we
+must return the index position of the matching closing bracket. We return -1 if
+there is no opening bracket at the given index position. Here is the solution I
+developed to solve the challenge.
+1) We define our method closing_bracket_ms, which takes a string with brackets
+ and the position of the opening bracket as its arguments.
+2) If there isn't an opening bracket in the n index position, we return -1.
+3) We initialize a counter variable bal (for balance).
+4) We iterate over each character in the string with index and skip iterations
+ before the index position of n (our opening bracket).
+5) We increment bal by 1 if we encounter an opening bracket.
+6) We decrement bal by 1 if we encounter a closing bracket.
+7) If bal becomes 0, we have found the matching closing bracket of our opening
+ bracket and so we return its index position.
+=end
+
+def closing_bracket_ms(s,n)
+ return -1 if s[n] != "("
+ bal = 0
+ s.each_char.with_index do |c,i|
+ next if i < n
+ bal += 1 if c == "("
+ bal -= 1 if c == ")"
+ return i if bal == 0
+ end
+end

ruby/6kyu/strip-url-params.rb

@@ -0,0 +1,28 @@
+=begin
+Codewars. 06/06/20. 'Strip Url Params'. 6kyu. Here we create a method that takes a url string and removes all duplicate query strings 
+keeping only the first as well as removes any query string parameter specified within the 2nd argument (an optional array). Here is the 
+solution I developed to solve the challenge.
+1) We define our method strip_url_query_ms, which takes a url and an optional array holding query string parameters that should also be 
+ removed (if the array contains any query string parameters).
+2) First we slice out the host from the url using a regex and store it in a variable host.
+3) In our regex, (.+\..+\.\w+) is the one and only capture group, which extracts the host. .+\. matches one or more of any character
+ followed by a dot, this is the subdomain. .+ is the domain name. \.\w+ is the top level domain. After the host name we have \??|$ which
+ matches 0 or 1 question marks (denoting the start of the query string) or the end of the string $ (if no query string is the url).
+4) Using the scan method, we generate an array of each query string parameter. In our regex, \w\=\d+ matches the likes of "a=1", "b=2",
+ "c=33", "d=76" etc.
+5) We then call reject on the query string paramter array, for each query string parameter, we check if its first letter is included in
+ a string of our parameters to strip (the optional array), if so, that query string parameter is removed from the array.
+6) We then call the group_by method on the array and group together all query string paramters which have the same letter.
+7) We then call the values method on this hash, now we have an array of arrays where each sub-array holds duplicate query string parameters.
+8) We map over the array and keep the first element from each sub-array thereby keeping only the first occurrence of all query string
+ parameters, then we join the array delimited by an ampersand, which seperated each query string parameter in the original URL.
+9) If the query string is empty, we return the host, if not, using string interpolation, we return the host, plus the question mark denoting
+ the start of the query string, plus the query string. 
+=end
+
+def strip_url_query_ms(url, ps = [])
+ host = url[/^(.+\..+\.\w+)\??|$/, 1]
+ qs = url.scan(/\w\=\d+/).reject {|q| ps.join =~ /#{q[0]}/}.
+ group_by {|q| q[0]}.values.map(&:first).join("&")
+ qs.empty? ? host : "#{host}?#{qs}"
+end