Ruby练习二input: ['cars', 'for', 'potatoes', 'racs', 'four','scar', 'creams', 'scream']=> output: [["c

Q1: Rock Paper Scissors Tournament

A rock, paper, scissors tournament is encoded as a bracketed array of games - that is, each element can be considered its own tournament.

[[ [ ["Kristen", "P"], ["Dave", "S"] ], [ ["Richard", "R"], ["Michael", "S"] ],], [[ ["Allen", "S"], ["Omer", "P"] ], [ ["David E.", "R"], ["Richard X.", "P"] ] ]]

> Under this scenario, Dave would beat Kristen (S>P), Richard 
would beat Michael (R>S), and then Dave and Richard would play
 (Richard wins since R>S); similarly, Allen would beat Omer, 
Richard X. would beat David E., and Allen and Richard X. would 
play (Allen wins since S>P); and finally Richard would beat Allen
 since R>S, that is, continue until there is only a single winner.
1. Write a method rps_tournament_winner that takes a 
tournament encoded as a bracketed array and returns the winner
 (for the above example, it should return [“Richard”, “R”]).
2. Tournaments can be nested arbitrarily deep, i.e., it may require 
multiple rounds to get to a single winner. You can assume that
the initial array is well formed (that is, there are 2N players, and 
each one participates in exactly one match per round).

#### My Example Code
Recursively

```ruby
#!/usr/bin/env ruby
# encoding: utf-8

require_relative 'rps_game_winner' #ensure code from series one Q3 is in the same dir

# check base case condition(if true, rps_game_winner()can be called)
def base_case?(player)
    # eg [["Kristen","P"],["Dave","S"]] will return true
    return player[0][0].class == String 
end

def rps_tournament_winner(list)
    # using recursion
    if base_case?(list)
        winner = rps_game_winner(list)
    else
        winner_a = rps_tournament_winner(list[0]) #divide
        winner_b = rps_tournament_winner(list[1]) #divide
        winner = rps_game_winner([winner_a,winner_b]) #as base case
    end
    # note where winner appears
    return winner #as base case
end

tournament_list =
[[
  [ ["Kristen", "P"], ["Dave", "S"] ],
  [ ["Richard", "R"], ["Michael", "S"] ],
],
[
  [ ["Allen", "S"], ["Omer", "P"] ],
  [ ["David E.", "R"], ["Richard X.", "P"] ]
]]

if __FILE__ == $0
    print rps_tournament_winner(tournament_list)
end

My Example Code

Iteration

# encoding: utf-8
# using iteration rather than recursion

require_relative 'rps_game_winner'

# some helper functions
# check base case condition(if true, rps_game_winner()can be called)
def base_case?(player)
    # eg [["Kristen","P"],["Dave","S"]] will return true
    return player[0][0].class == String 
end

def mark(winner)
    #help ensure only same level players compete
    #[["Kristen","P"]] => ["Kristen","P",{:level=>num}]
    if winner[2].nil?
        winner << {:level=>1}
    else
        winner[2][:level] += 1
    end
    return winner   
end

def unmark(winner)
    # ["Kristen","P",{:level=>num}] => [["Kristen","P"]]
    winner.delete_at(2)
    return winner
end

def rps_tournament_winner(list)
    # using iteration (here I use two stacks to help)
    stack_p = [] #stack to keep divided players
    stack_p << list #player
    stack_w = [] #for winners,
    while !stack_p.empty?
        list = stack_p.pop
        if base_case?(list)
            winner = rps_game_winner(list)
            winner_d = stack_w.pop # winner waitting in the winner stack
            if winner_d.nil?
                #when we just get the first winner
                stack_w << mark(winner)
            else
                if winner_d[2][:level] = mark(winner)[2][:level]
                    #make sure player level match
                    winner = rps_game_winner([winner,unmark(winner_d)])
                else
                    #if match fails, push into winner stack
                    stack_w << winner_d << mark(winner)
                end
            end
        else
            #divide into two groups again
            stack_p << list[0] << list[1]
        end
    end

    return unmark(winner)   
end

tournament_list =

[[
  [ ["Kristen", "P"], ["Dave", "S"] ],
  [ ["Richard", "R"], ["Michael", "S"] ],
],
[
  [ ["Allen", "S"], ["Omer", "P"] ],
  [ ["David E.", "R"], ["Richard X.", "P"] ]
]]

if __FILE__ == $0
    print rps_tournament_winner(tournament_list)
end

Q2: Combine Anagrams

An anagram is a word obtained by rearranging the letters of another word. For example, “rats”, “tars” and “star” are an anagram group because they are made up of the same letters. Given an array of strings, write a method that groups them into anagram groups and returns the array of groups. Case does not matter in classifying string as anagrams (but case should be preserved in the output), and the order of the anagrams in the groups does not matter. Example:

input: ['cars', 'for', 'potatoes', 'racs', 'four','scar', 'creams', 'scream']

=> output: [["cars", "racs", "scar"], ["four"], ["for"], ["potatoes"], ["creams", "scream"]]

HINT: you can quickly tell if two words are anagrams by sorting their

letters, keeping in mind that upper vs lowercase doesn't matter

def combine_anagrams(words)

<YOUR CODE HERE>

end

#### My Example Code

```ruby
def combine_anagrams(words)
    anagram = Hash.new #use hash to store group values
    words.each do |word|
        # use sortted letters as key and original words as values
        key = word.chars.sort{|a,b| a.casecmp(b)}.join
        if anagram.has_key?(key)
            anagram[key].push(word)
        else
            anagram[key] = [word] # assign a new array
        end
    end
    return anagram.values   
end

def combine_anagrams_1(words)
    # or this one-line method
    return words.group_by{|element| element.downcase.chars.sort}.values
end

words_list = ['cars','for','potatoes','racs','four','scar','creams','scream']
print combine_anagrams(words_list)
#print combine_anagrams_1(words_list)

Q3: Dessert

Create a class Dessert with getters and setters for name and calories. Define instance methods healthy?, which returns true if a dessert has less than 200 calories, and delicious?, which

returns true for all desserts. Create a class JellyBean that extends Dessert, and add a getter and setter for flavor. Modify delicious? to return false if the flavor is black licorice (but delicious? should still return true for all other flavors and for all non-JellyBean desserts). Here is the framework (you may define additional helper methods):

class Dessert
    def initialize(name, calories)
        # YOUR CODE HERE
    end
    def healthy?
        # YOUR CODE HERE
    end
    def delicious?
        # YOUR CODE HERE
    end
end

class JellyBean < Dessert def initialize(name, calories, flavor) # YOUR CODE HERE end def delicious? # YOUR CODE HERE end end

####My Example Code

```ruby
class Dessert
    def initialize(name,calories)
        # initialize instance variables
        @name = name
        @calories = calories
    end
    
    def healthy?
        if @calories > 200
            return true
        else
            return false
        end
    end

    def delicious?
        return true
    end
    
    # getters and setters
    attr_accessor:name,:calories
end

apple = Dessert.new("apple",150)
puts apple.healthy?
#print apple.calories

class JellyBean < Dessert
    def initialize(name,calories,flavor)
        super(name,calories) # send arguments to parent
        @flavor = flavor
    end

    def delicious?
        if @flavor.downcase=="black licorice"
            return false
        else
            return true
        end
    end

    # getter and setters
    def flavor
        @flavor
    end

    def flavor=(value)
        @flavor = value
    end
    # or attr_accessor
    # attr_accessor:flavor

end

jelly = JellyBean.new("ijelly",1500,"black licorice")
puts jelly.delicious?
#puts jelly.name

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏人工智能头条

将机器学习应用于金融技术领域的15家公司(英)

1502
来自专栏CreateAMind

Building Agents with Imagination

1453
来自专栏程序生活

第四周编程作业(二)-Deep Neural Network for Image Classification: ApplicationDeep Neural Network for Image Cl

Deep Neural Network for Image Classification: Application When you finish this, ...

9097
来自专栏生信技能树

乳腺癌预后基因集

In addition to cell of origin and somatic mutation events, studies over the past...

1263
来自专栏专知

【最新】CVPR 2018 论文集下载和 Tutorial 大全目录

【导读】计算机视觉最具影响力的学术会议之一的 IEEE CVPR 于2018 年 6 月 18 日 在美国盐湖城召开举行。在2014年CVPR上首次超过2000...

1862
来自专栏专知

ACL 2018 计算语言学协会接受论文列表

3691
来自专栏HansBug's Lab

1342: [Baltic2007]Sound静音问题

1342: [Baltic2007]Sound静音问题 Time Limit: 5 Sec  Memory Limit: 162 MB Submit: 710 ...

3587
来自专栏CreateAMind

互信息 强化学习探索 两篇paper

Hyoungseok Kim, Jaekyeom Kim, Yeonwoo Jeong, Sergey Levine, Hyun Oh Song

943
来自专栏数据结构与算法

BZOJ2005: [Noi2010]能量采集(容斥原理 莫比乌斯反演)

栋栋有一块长方形的地,他在地上种了一种能量植物,这种植物可以采集太阳光的能量。在这些植物采集能量后,

691
来自专栏专知

UAI 2018大会论文接受列表新鲜出炉

【导读】UAI大会全称为Conference on Uncertainty in Artificial Intelligence,立足于不确定性人工智能领域,主...

1715

扫码关注云+社区