Програмиране с Ruby

Курс във Факултета по Математика и Информатика към СУ

Решение на Втора задача от Никола Таушанов

Обратно към всички решения

Към профила на Никола Таушанов

Резултати

  • 6 точки от тестове
  • 0 бонус точки
  • 6 точки общо
  • 11 успешни тест(а)
  • 0 неуспешни тест(а)

Код

class Criteria
attr_reader :match
def initialize(match)
@match = match
end
def self.name(name)
Criteria.new lambda { |song| song.name == name }
end
def self.artist(artist)
Criteria.new lambda { |song| song.artist == artist }
end
def self.album(album)
Criteria.new lambda { |song| song.album == album }
end
def |(criteria)
Criteria.new lambda { |song| match.(song) | criteria.match.(song) }
end
def &(criteria)
Criteria.new lambda { |song| match.(song) & criteria.match.(song) }
end
def !
Criteria.new lambda { |song| !match.(song) }
end
end
class Song
attr_reader :name, :artist, :album
def initialize(name, artist, album)
@name, @artist, @album = name, artist, album
end
end
class Collection
include Enumerable
def initialize(songs = [])
@songs = songs
end
def names
map(&:name).uniq
end
def artists
map(&:artist).uniq
end
def albums
map(&:album).uniq
end
def each
@songs.each { |song| yield song }
end
def filter(criteria)
Collection.new select(&criteria.match)
end
def self.parse(text)
lines = text.split("\n")
songs = lines.each_slice(4).map do |name, artist, album|
Song.new name, artist, album
end
Collection.new songs
end
def adjoin(collection)
array = to_a.concat collection.reject { |x| member? x }
Collection.new array
end
end

Лог от изпълнението

...........

Finished in 0.01023 seconds
11 examples, 0 failures

История (8 версии и 3 коментара)

Никола обнови решението на 26.10.2012 11:52 (преди над 12 години)

+class Criteria
+ attr_reader :match
+
+ def initialize match
+ @match = match
+ end
+
+ def self.name name
+ Criteria.new lambda { |song| song.name == name }
+ end
+
+ def self.artist artist
+ Criteria.new lambda { |song| song.artist == artist }
+ end
+
+ def self.album album
+ Criteria.new lambda { |song| song.album == album }
+ end
+
+ def | criteria
+ Criteria.new lambda { |song| match.(song) | criteria.match.(song) }
+ end
+
+ def & criteria
+ Criteria.new lambda { |song| @match.(song) & criteria.match.(song) }
+ end
+
+ def !
+ Criteria.new lambda { |song| !@match.(song) }
+ end
+end
+
+class Song
+ attr_reader :name, :artist, :album
+
+ def initialize name, artist, album
+ @name, @artist, @album = name, artist, album
+ end
+end
+
+class Collection
+ include Enumerable
+ attr_reader :songs
+
+ def initialize
+ @songs = []
+ end
+ private :initialize
+
+ def names
+ map(&:name).uniq
+ end
+
+ def artists
+ map(&:artist).uniq
+ end
+
+ def albums
+ map(&:album).uniq
+ end
+
+ def each
+ @songs.each do |song|
+ yield song
+ end
+ end
+
+ def filter criteria
+ Collection.from_a select(&criteria.match)
+ end
+
+ def self.parse text
+ result = Collection.new
+
+ text.split("\n").each_slice 4 do |name, artist, album|
+ result.songs << Song.new(name, artist, album)
+ end
+
+ result
+ end
+
+ def adjoin collection
+ collection = collection.reject { |x| member? x }
+ Collection.from_a to_a.concat collection
+ end
+
+ def self.from_a array
+ array.each_with_object(Collection.new) do |song, result|
+ result.songs << song
+ end
+ end
+end

Никола обнови решението на 26.10.2012 11:53 (преди над 12 години)

class Criteria
attr_reader :match
def initialize match
@match = match
end
def self.name name
Criteria.new lambda { |song| song.name == name }
end
def self.artist artist
Criteria.new lambda { |song| song.artist == artist }
end
def self.album album
Criteria.new lambda { |song| song.album == album }
end
def | criteria
Criteria.new lambda { |song| match.(song) | criteria.match.(song) }
end
def & criteria
- Criteria.new lambda { |song| @match.(song) & criteria.match.(song) }
+ Criteria.new lambda { |song| match.(song) & criteria.match.(song) }
end
def !
- Criteria.new lambda { |song| !@match.(song) }
+ Criteria.new lambda { |song| !match.(song) }
end
end
class Song
attr_reader :name, :artist, :album
def initialize name, artist, album
@name, @artist, @album = name, artist, album
end
end
class Collection
include Enumerable
attr_reader :songs
def initialize
@songs = []
end
private :initialize
def names
map(&:name).uniq
end
def artists
map(&:artist).uniq
end
def albums
map(&:album).uniq
end
def each
@songs.each do |song|
yield song
end
end
def filter criteria
Collection.from_a select(&criteria.match)
end
def self.parse text
result = Collection.new
text.split("\n").each_slice 4 do |name, artist, album|
result.songs << Song.new(name, artist, album)
end
result
end
def adjoin collection
collection = collection.reject { |x| member? x }
Collection.from_a to_a.concat collection
end
def self.from_a array
array.each_with_object(Collection.new) do |song, result|
result.songs << song
end
end
end

Никола обнови решението на 26.10.2012 12:05 (преди над 12 години)

class Criteria
attr_reader :match
def initialize match
@match = match
end
def self.name name
Criteria.new lambda { |song| song.name == name }
end
def self.artist artist
Criteria.new lambda { |song| song.artist == artist }
end
def self.album album
Criteria.new lambda { |song| song.album == album }
end
def | criteria
Criteria.new lambda { |song| match.(song) | criteria.match.(song) }
end
def & criteria
Criteria.new lambda { |song| match.(song) & criteria.match.(song) }
end
def !
Criteria.new lambda { |song| !match.(song) }
end
end
class Song
attr_reader :name, :artist, :album
def initialize name, artist, album
@name, @artist, @album = name, artist, album
end
end
class Collection
include Enumerable
attr_reader :songs
def initialize
@songs = []
end
- private :initialize
def names
map(&:name).uniq
end
def artists
map(&:artist).uniq
end
def albums
map(&:album).uniq
end
def each
@songs.each do |song|
yield song
end
end
def filter criteria
Collection.from_a select(&criteria.match)
end
def self.parse text
result = Collection.new
text.split("\n").each_slice 4 do |name, artist, album|
result.songs << Song.new(name, artist, album)
end
result
end
def adjoin collection
collection = collection.reject { |x| member? x }
Collection.from_a to_a.concat collection
end
def self.from_a array
array.each_with_object(Collection.new) do |song, result|
result.songs << song
end
end
end

Никола обнови решението на 26.10.2012 12:14 (преди над 12 години)

class Criteria
attr_reader :match
def initialize match
@match = match
end
def self.name name
Criteria.new lambda { |song| song.name == name }
end
def self.artist artist
Criteria.new lambda { |song| song.artist == artist }
end
def self.album album
Criteria.new lambda { |song| song.album == album }
end
def | criteria
Criteria.new lambda { |song| match.(song) | criteria.match.(song) }
end
def & criteria
Criteria.new lambda { |song| match.(song) & criteria.match.(song) }
end
def !
Criteria.new lambda { |song| !match.(song) }
end
end
class Song
attr_reader :name, :artist, :album
def initialize name, artist, album
@name, @artist, @album = name, artist, album
end
end
class Collection
include Enumerable
attr_reader :songs
def initialize
@songs = []
end
def names
map(&:name).uniq
end
def artists
map(&:artist).uniq
end
def albums
map(&:album).uniq
end
def each
- @songs.each do |song|
- yield song
- end
+ songs.each { |song| yield song }
end
def filter criteria
Collection.from_a select(&criteria.match)
end
def self.parse text
result = Collection.new
text.split("\n").each_slice 4 do |name, artist, album|
result.songs << Song.new(name, artist, album)
end
result
end
def adjoin collection
collection = collection.reject { |x| member? x }
Collection.from_a to_a.concat collection
end
def self.from_a array
array.each_with_object(Collection.new) do |song, result|
result.songs << song
end
end
end

Никола обнови решението на 26.10.2012 12:22 (преди над 12 години)

class Criteria
attr_reader :match
def initialize match
@match = match
end
def self.name name
Criteria.new lambda { |song| song.name == name }
end
def self.artist artist
Criteria.new lambda { |song| song.artist == artist }
end
def self.album album
Criteria.new lambda { |song| song.album == album }
end
def | criteria
Criteria.new lambda { |song| match.(song) | criteria.match.(song) }
end
def & criteria
Criteria.new lambda { |song| match.(song) & criteria.match.(song) }
end
def !
Criteria.new lambda { |song| !match.(song) }
end
end
class Song
attr_reader :name, :artist, :album
def initialize name, artist, album
@name, @artist, @album = name, artist, album
end
end
class Collection
include Enumerable
attr_reader :songs
def initialize
@songs = []
end
def names
map(&:name).uniq
end
def artists
map(&:artist).uniq
end
def albums
map(&:album).uniq
end
def each
songs.each { |song| yield song }
end
def filter criteria
Collection.from_a select(&criteria.match)
end
def self.parse text
result = Collection.new
text.split("\n").each_slice 4 do |name, artist, album|
result.songs << Song.new(name, artist, album)
end
result
end
def adjoin collection
- collection = collection.reject { |x| member? x }
- Collection.from_a to_a.concat collection
+ array = to_a.concat collection.reject { |x| member? x }
+ Collection.from_a array
end
def self.from_a array
array.each_with_object(Collection.new) do |song, result|
result.songs << song
end
end
end

Никола обнови решението на 26.10.2012 14:04 (преди над 12 години)

class Criteria
attr_reader :match
def initialize match
@match = match
end
def self.name name
Criteria.new lambda { |song| song.name == name }
end
def self.artist artist
Criteria.new lambda { |song| song.artist == artist }
end
def self.album album
Criteria.new lambda { |song| song.album == album }
end
def | criteria
Criteria.new lambda { |song| match.(song) | criteria.match.(song) }
end
def & criteria
Criteria.new lambda { |song| match.(song) & criteria.match.(song) }
end
def !
Criteria.new lambda { |song| !match.(song) }
end
end
class Song
attr_reader :name, :artist, :album
def initialize name, artist, album
@name, @artist, @album = name, artist, album
end
end
class Collection
include Enumerable
attr_reader :songs
- def initialize
- @songs = []
+ def initialize array = []
+ array.each_with_object(@songs = []) do |song, result|
+ songs << song
+ end
end
def names
map(&:name).uniq
end
def artists
map(&:artist).uniq
end
def albums
map(&:album).uniq
end
def each
songs.each { |song| yield song }
end
def filter criteria
- Collection.from_a select(&criteria.match)
+ Collection.new select(&criteria.match)
end
def self.parse text
- result = Collection.new
-
- text.split("\n").each_slice 4 do |name, artist, album|
- result.songs << Song.new(name, artist, album)
+ songs = text.split("\n").each_slice(4).map do |name, artist, album|
+ Song.new name, artist, album
end
- result
+ Collection.new songs
end
def adjoin collection
array = to_a.concat collection.reject { |x| member? x }
- Collection.from_a array
+ Collection.new array
end
-
- def self.from_a array
+end
- array.each_with_object(Collection.new) do |song, result|
- result.songs << song
- end
- end
-end

Никола обнови решението на 26.10.2012 14:14 (преди над 12 години)

class Criteria
attr_reader :match
- def initialize match
+ def initialize(match)
@match = match
end
- def self.name name
+ def self.name(name)
Criteria.new lambda { |song| song.name == name }
end
- def self.artist artist
+ def self.artist(artist)
Criteria.new lambda { |song| song.artist == artist }
end
- def self.album album
+ def self.album(album)
Criteria.new lambda { |song| song.album == album }
end
- def | criteria
+ def | (criteria)
Criteria.new lambda { |song| match.(song) | criteria.match.(song) }
end
- def & criteria
+ def & (criteria)
Criteria.new lambda { |song| match.(song) & criteria.match.(song) }
end
def !
Criteria.new lambda { |song| !match.(song) }
end
end
class Song
attr_reader :name, :artist, :album
- def initialize name, artist, album
+ def initialize(name, artist, album)
@name, @artist, @album = name, artist, album
end
end
class Collection
include Enumerable
- attr_reader :songs
- def initialize array = []
- array.each_with_object(@songs = []) do |song, result|
- songs << song
+ def initialize(array = [])
+ array.each_with_object(@songs = []) do |song, result|
+ @songs << song
end
end
def names
map(&:name).uniq
end
def artists
map(&:artist).uniq
end
def albums
map(&:album).uniq
end
def each
- songs.each { |song| yield song }
+ @songs.each { |song| yield song }
end
- def filter criteria
+ def filter(criteria)
Collection.new select(&criteria.match)
end
- def self.parse text
+ def self.parse(text)
songs = text.split("\n").each_slice(4).map do |name, artist, album|
Song.new name, artist, album
end
Collection.new songs
end
- def adjoin collection
+ def adjoin(collection)
array = to_a.concat collection.reject { |x| member? x }
Collection.new array
end
-end
+end

Никола обнови решението на 26.10.2012 14:45 (преди над 12 години)

class Criteria
attr_reader :match
def initialize(match)
@match = match
end
def self.name(name)
Criteria.new lambda { |song| song.name == name }
end
def self.artist(artist)
Criteria.new lambda { |song| song.artist == artist }
end
def self.album(album)
Criteria.new lambda { |song| song.album == album }
end
- def | (criteria)
+ def |(criteria)
Criteria.new lambda { |song| match.(song) | criteria.match.(song) }
end
- def & (criteria)
+ def &(criteria)
Criteria.new lambda { |song| match.(song) & criteria.match.(song) }
end
def !
Criteria.new lambda { |song| !match.(song) }
end
end
class Song
attr_reader :name, :artist, :album
def initialize(name, artist, album)
@name, @artist, @album = name, artist, album
end
end
class Collection
include Enumerable
- def initialize(array = [])
- array.each_with_object(@songs = []) do |song, result|
- @songs << song
- end
+ def initialize(songs = [])
+ @songs = songs
end
def names
map(&:name).uniq
end
def artists
map(&:artist).uniq
end
def albums
map(&:album).uniq
end
def each
@songs.each { |song| yield song }
end
def filter(criteria)
Collection.new select(&criteria.match)
end
def self.parse(text)
- songs = text.split("\n").each_slice(4).map do |name, artist, album|
+ lines = text.split("\n")
+ songs = lines.each_slice(4).map do |name, artist, album|
Song.new name, artist, album
end
Collection.new songs
end
def adjoin(collection)
array = to_a.concat collection.reject { |x| member? x }
Collection.new array
end
end