Added 52 kata in Ruby

Author: malachispencer

ruby/4kyu/most-frequently-used-words-in-a-text.rb

@@ -0,0 +1,53 @@
+=begin
+Codewars. 19/05/20. 'Most frequently used words in a text'. 4kyu. Here we create 
+a method that takes a string of text - which can include punctuation or line breaks - 
+and returns the top 3 most occuring words in the text. For example, 
+"e e e e DDD ddd DdD: ddd ddd aa aA Aa, bb cc cC e e e" should return ["e", "ddd", "aa"]. 
+Words may contain one or more apostrophes and words should be treated case-insensitively 
+and returned lower case. Here is the solution I used to solve the challenge, after having
+to look up solutions on Github.
+1) We define our method top_3_words, which takes a string of text as its
+ argument.
+2) We downcase the string as we should treat matches case insensitively.
+3) We then call the scan method to create an array of all the words in the
+ text. In our regex, [a-z']+ matches 1 or more letters or apostrophes and
+ placing word boundaries \b either side of it ensures that apostrophes by
+ themselves are not matched. Essentially, our regex creates an array of
+ words which may or may not contain apostrophes.
+4) We then call the group_by method and group all of the same words together.
+5) We then turn the values of the hash into their size, thereby leaving us with
+ a hash where the key is the word and the value is the count of the word in
+ the text.
+6) We then sort the hash according to the count's as if they were negative
+ integers, which puts the largest takes first and leaves us with an array of
+ arrays rather than a hash.
+7) We then use the take method to grab the first 3 elements of the array of
+ arrays, which gives us the top 3 counts.
+8) We map over the array and keep only the words.
+=end
+
+def top_3_words(s)
+ s.downcase.scan(/\b[a-z']+\b/).group_by(&:itself).transform_values(&:size).sort_by {|k,v,| -v}.take(3).map(&:first)
+end
+
+=begin
+Here is another solution.
+1) We downcase the string then call the scan method to generate an array of
+ all the words in the text.
+2) In scan's regex, we match a single letter [a-z] followed by 0 or more
+ letters or apostrophes [a-z']*.
+3) We then call inject on the array of words and initialize a counter hash
+ inside inject's initializer.
+4) In our block we make the keys of our hash the word and increment its count
+ by 1 every time that word is found. We then return the hash from inside
+ the inject block, without this the hash would not automatically return.
+5) We then sort the hash with counts in descending order thereby converting it
+ from a hash to an array of arrays.
+6) We grab the first 3 sub-arrays, then map over them and keep only the first
+ element from each. Now we have an array with the top 3 most frequently used
+ words in the text.
+=end
+
+def top_3_words_x(s)
+ s.downcase.scan(/[a-z][a-z']*/).inject(Hash.new(0)) {|h,w| h[w] += 1 ; h}.sort_by {|k,v| -v}.first(3).map(&:first)
+end

ruby/4kyu/recover-a-secret-string-from-random-triplets.rb

@@ -0,0 +1,48 @@
+=begin
+Codewars. 02/06/20. "Recover a secret string from random triplets". 4kyu. We are given a collection of random triplets from which we must
+recover a secret string. In each random triplet, we are given a (not necessarily consecutive) order of appearance of letters in the secret 
+string. No letter occurs more than once in the secret string. After seeing Owen Patrick F. Falculan's Python solution in his YouTube
+tutorial, here is the adaptation I built to solve the challenge.
+1) We define our method recover_secret_ms, which takes an array of arrays where each sub-array contains not necessarily consecutive but
+ ordered random triplets from the secret string.
+2) We intialize an empty string, where we will store our secret string.
+3) We then iterate over each sub-array, making a block variable for each triplet, x (the 1st), y (the 2nd) and z (the 3rd).
+4) In our block, if x is not included in the secret string s, we concatenate it to the front of s using prepend. Likewise, if y is not 
+ included in s, we concatenate it to the front of s.
+5) We then get to our first sorting part. If y is included in s but its index position is less than that of x, we remove y from s, then
+ reinsert it into the string 1 position after x. Remember, a y always comes after an x in the secret string.
+6) Now we get to z, if this is not included in s, we concatenate it to the front of the string using prepend. Then if the index position of
+ z in s is less than the index position of y in s, we remove z from s then reinsert 1 position after y.
+7) This process is performed as we iterate each triplet, because our triplets always have x, y and z in order of appearance in the secret
+ string, once we've iterated all triplets we'll have a correctly sorted secret string. Our use of the index method with s is fine because
+ no letter occurs more than once in the secret string.
+8) [['t','u','p'],['w','h','i'],['t','s','u'],['a','t','s'],['h','a','p'],['t','i','s'],['w','h','s']] returns "whatisup" but let's take
+ a look at how our algorithm on it to see how it works.
+9) 1) t", s = "t"; "u", s = "ut"; index position of "u" is less than "t", so we slice then reinsert and s = "tu"; "p", s = "ptu"; index
+ position of "p" is less than that of "u" so we slice and reinsert then s = "tup". 
+ 2) "w", s = "wtup"; "h", s = "hwtup"; index position of "h" is less than that of "w", so we slice and reinsert and then s = "whtup"; 
+ "i", s = "iwhtup"; index position of "i" is less than that of "h" so we slice and reinsert then s = "whitup". 
+ 3) "t" is already included so no need to add it; "s", s = "swhitup"; index position of "s" is lower than that of "t", so we slice and 
+ reinsert then s = "whitsup"; "u" is already in s so no need to add it; index position of "u" is not lower than "s" so no sorting 
+ needed. 
+ 4) "a", s = "awhitsup"; "t" is already included so no need to add it; index position of "t" is not less than that of "a" so no need for 
+ sorting; "s" already included; index position of "s" is not lower than that of "t" so no need for sorting. 
+ 5) "h" already included; "a" already included; index position of "a" lower than "h", slice and reinsert then s = "whaitsup"; "p" is 
+ already included; index position of "p" not lower than "a". 
+ 6) "t" already included; "i" already included; index position of "i" less than "t", slice and reinsert then s = "whatisup"; "s" is 
+ already included; "s" index not lower than "i" index. 
+ 7) "w" already included; "h" already included; "h" index not lower than "w" index; "s" already included; "s" index not lower than "h" 
+ index.
+=end
+
+def recover_secret_ms(t)
+ s = ""
+ t.each do |x,y,z|
+ if s !~ /#{x}/ ; s.prepend(x) ; end
+ if s !~ /#{y}/ ; s.prepend(y) ; end
+ if s =~ /#{y}/ && s.index(y) < s.index(x) ; s.slice!(s.index(y)) ; s.insert((s.index(x)+1), y) ; end
+ if s !~ /#{z}/ ; s.prepend(z) ; end
+ if s =~ /#{z}/ && s.index(z) < s.index(y) ; s.slice!(s.index(z)) ; s.insert(s.index(y)+1, z) ; end
+ end
+ s
+end

ruby/4kyu/strip-comments.rb

@@ -0,0 +1,23 @@
+=begin
+Codewars. 20/05/20. 'Strip Comments'. 4kyu. Here we create a method that strips 
+all text that follows any comment markers passed in, any whitespace at the end of 
+the line should also be stripped out. Here is an example input and output:
+apples, pears # and bananas apples, pears
+grapes grapes
+bananas !apples bananas
+In code the input will look like ("apples, pears # and bananas\ngrapes\nbananas
+!apples", ["#", "!"]) and the output should be "apples, pears\ngrapes\nbananas".
+Here is the solution I used to solve the challenge after seeing a solution on Github.
+1) We define our method strip_comments, which takes a string which includes
+ newlines and an array containing comment markers.
+2) We call gsub on the string.
+3) In our regex, we match 1 or more spaces \s+, followed by any one of our
+ comment markers [#{m.join}], followed by one or more of any character
+ except newlines .+. We remove all of these.
+4) This ensures that the space, the comment marker and all the text or space
+ that follows it, up to a newline, is stripped from the string.
+=end
+
+def strip_comments(s,m)
+ s.gsub(/\s+[#{m.join}].+/, '')
+end

ruby/5kyu/#hashtag.rb

@@ -0,0 +1,27 @@
+=begin
+Codewars. 05/05/20. '#Hashtag'. 5kyu. Here we create a method that takes a string 
+and returns only the words that have 1 or more # symbols at the beginning, returning 
+the words without the # symbol. Here is the solution I used to solve the challenge.
+1) We define our method get_hashtags_ms, which takes a string of a "social
+ media post" as an argument.
+2) We split the string into an array of words.
+3) We call the grep method, which is like the select method, returning an
+ array of all elements which match our pattern. Our regex matches for every
+ word that starts with one or more hashtags.
+4) In our regex, \A asserts position at the start of the string, \Z asserts
+ position at the end of the string.
+5) (\#)+ is capture group 1, matching for 1 or more occurences of a hashtag, +
+ being the 1 or more quantifier.
+6) ([a-zA-Z]+) is capture group 2, any series of letters which follow 1 or more
+ hashtags.
+7) In our block we return $2 (capture group 2), which with grep gives us an
+ array of words that originally started with 1 or more hashtags.
+8) When we call $1 we get 1 hashtag from every word that started with 1 or more
+ hashtags, so if there was 3 we don't get 3, we get 1. If we want to get all
+ the preceding hashtags we simply do (\#+)+, placing a 1 or more quantifier
+ inside the hashtag capture group.
+=end
+
+def get_hashtags_ms(post)
+ post.split.grep(/\A(\#)+([a-zA-Z]+)\Z/) {$2}
+end

ruby/5kyu/bob's-reversing-obfuscator.rb

@@ -0,0 +1,68 @@
+=begin
+Codewars. 20/05/20. 'Bob's reversing obfuscator'. 5kyu. Here we create a method 
+that takes an encoded string and uses just a marker and our wits to decode the string. 
+An input of ("Lor-.tile gnicsipida rutetcesnoc ,tema tis rolod muspi me", "-") should
+return "Lorem ipsum dolor sit amet, consectetur adipiscing elit." An input of
+("q.qSusqsitanenev cen lsin sillom subinif ecsuF .itnetop essidnep", "q") should return 
+"Suspendisse potenti. Fusce finibus mollis nisl nec venenatis." Here is the solution I 
+developed to solve the challenge. My solution occasionally fails a random test, delivering 
+the error message "'tr' : invalid range "|-q" in string transliteration (ArgumentError)."
+1) We define our method decoder_ms, which takes an encoded string and a marker,
+ the marker can feature once or multiple times in the string.
+2) We create an empty array called d, where we will store segments of the
+ decoded message.
+3) Based on a pattern that I figured out by working with the string
+ "Dq.silucaiqonec mollq odommoc qis ipsum qlsin lev" and its marker "q". If
+ we split each sub-section at q boundaries we get the following:
+ ["D", ".silucai", "onec moll", " odommoc ", "is ipsum ", "lsin lev"].
+4) Comparing with final output "Donec mollis ipsum vel nisl commodo iaculis.",
+ we see that everything in an even index position doesn't need reversing,
+ they only need to be appended together. Everything in an odd index position
+ however, needs to be reversed and then shifted to position -1, then -2,
+ then -3 etc as they are encounterd in the array.
+5) With this in mind, we create an empty array where we will store our
+ sub-sections, then we initialize the position counters for sub-sections
+ that will be added to the new array. The first even will be placed in
+ position 0 and the first odd will be placed in position -1.
+6) We then split the encoded string by its markers, then iterate over it with
+ index. If the index of the segment is even, we insert it in d, wherever
+ even position counter is at (initially 0), then increment ev by 1.
+7) If the index of the segment is odd, we insert a reversed version of that
+ string in the position where the odd position counter is currently at
+ (initially -1), then decrement od by 1.
+8) Now our array of strings has been decoded, we return it joined back into
+ a string.
+9) To provide one more example, when ("q.qSusqsitanenev cen lsin sillom subinif
+ ecsuF .itnetop essidnep", "q") is split into sub-sections it produces:
+ ["",".","Sus","sitanenev cen lsin sillom subinif ecsuF .itnetop essidnep"].
+ "" and "Sus" are appended together, "." is shifted to position -1, and
+ then "sitanenev cen lsin sillom subinif ecsuF .itnetop essidnep" reversed is
+ placed in position -2. Then it is all joined into the decoded string.
+=end
+
+def decoder_ms(e,m)
+ d = [] ; ev = 0 ; od = -1
+ e.split(m).each_with_index do |s,i|
+ d.insert(ev, s) && ev += 1 if i.even?
+ d.insert(od, s.reverse) && od -= 1 if i.odd?
+ end
+ d.join
+end
+
+=begin
+Here is a superior solution, which doesn't fail any random tests.
+1) We split the encoded string at its markers, then we call the partition
+ method with index.
+2) The partition method returns an array of 2 sub-arrays where the first
+ contains the elements which evaluate to true and the second with the
+ elements which evaluate to false.
+3) In our block, we partition the elements which are in even index positions
+ (first sub-array) and the elements which are in odd index positions (second
+ sub-array). We store these sub-arrays in variables called ev and od.
+4) We join the even strings and then concatenate the odd strings joined and
+ reversed, leaving us with our decoded string.
+=end
+
+def decoder(e, m)
+ ev, od = e.split(m).partition.with_index {|s, i| i.even?} ; ev.join + od.join.reverse
+end

ruby/5kyu/break-the-caesar!.rb

@@ -0,0 +1,63 @@
+=begin
+Codewars. 18/05/20. "Break the Caesar!". 5kyu. The Caesar cipher encrypts a
+message by shifting each letter a certain number of places in the alphabet. For
+example, applying a shift of 5 to "Hello, world!" yields "Mjqqt, btwqi!". Here
+we create a method that takes an encrypted message, and then returns the most
+likely shift that was used to decode it. The decoding is verified by checking
+if all or most of the decoded string's words are in a set called WORDS,
+provided in the kata. Here is the solution I developed to solve the challenge,
+which occasionally fails 1 or 2 random tests. While my solution may not be
+perfect for this kata, it still provides a perfectly good caesar decoder.
+1) We define our method break_caesar_ms, which takes an encrypted message as
+ its argument.
+2) We sanitise the string by removing everything which isn't a letter or a
+ space - thereby removing punctuation - and then we downcase the string, as
+ all the words in the WORDS set are lower case.
+3) We create a for loop from 0 to 25, which covers all the possible shifts.
+4) In our for loop, we call gsub on the string and match each letter. If the
+ ASCII value of the letter minus i (the shift) falls outside the bounds of
+ of letter ASCII values, we subtract i from the ASCII value of the letter,
+ then add 26 so that it loops back around to an alphabetical ASCII value.
+5) For example, if a letter is "d", and the correct shift is 7, the ASCII value
+ of "d" is 100 and 100 - 7 = 93, but 93 is "]". But when we add 26 to 93 we
+ get 119 and the corresponding character to that ASCII value is "w", which is
+ 7 places back from "d" in the alphabet.
+6) If the ASCII value minus the shift does not fall below the (lower cased)
+ letter ASCII range, we simply do the ASCII minus the shift.
+7) We are subtracting because we are decoding the cipher and hence moving
+ letters back to their original position. If we were encoding, we'd be
+ adding the shift to the ASCII value instead.
+8) On each loop the shifted string gets stored in a variable d (for decoded),
+ we return i if all the words in an array of words of d, are included in the
+ set, or, if the count of d's included words in WORDS is all but one of them.
+ We also check with this condition that d doesn't contain only 1 word,
+ because this would make one the basic tests "DAM!" fail.
+9) If all or all but one of d's words are included in WORDS, we return i
+ because we assume we have uncovered the correct shift.
+10) This manages to pass all the tests most of the time, but occasionally we
+ get 1 random fail, or 2 random fails, probably because there are random
+ cases where the decoded string has 2 words which aren't included in WORDS.
+=end
+
+def break_caesar_ms(s)
+ s.gsub!(/([^a-z|\s])/i, '').downcase!
+ for i in 0..25
+ d = s.gsub(/([a-z])/) {$1.ord - i < 97 ? (($1.ord - i) + 26).chr : ($1.ord - i).chr}
+ return i if d.split.all? {|w| WORDS.include?(w)} ||
+ d.split.count {|w| WORDS.include?(w)} == d.split.size - 1 && d.split.size != 1
+ end
+end
+
+=begin
+Here is an improved version of my solution, which doesn't fail any random
+tests because it returns the shift which produces a string containing the
+highest amount of words in WORDS. This is more precise than returning the shift
+which has all or all but one words in WORDS.
+=end
+
+def break_caesar(s)
+ s.gsub!(/([^a-z|\s])/i, '').downcase!
+ (0..25).max_by do |i|
+ s.gsub(/([a-z])/) {$1.ord - i < 97 ? (($1.ord - i) + 26).chr : ($1.ord - i).chr}.split.count {|w| WORDS.include?(w)}
+ end
+end