如何计算 ruby 中 txt 文件中的唯一名称

Question

How do I find the unique count of full names from a.txt file, with unique names only found once in Ruby?

This is the first 10 lines from the.txt file:

    Smith, Kim -- ut
    Voluptatem ipsam et at.
    Marv, Gardens -- non
    Facere et necessitatibus animi.
    McLoughlin, Matt -- consequatur
    Eveniet temporibus ducimus amet eaque.
    Smith, Jen -- pariatur
    Unde voluptas sit fugit.
    Brad, Nick -- et
    Maiores ab officia sed.

Answer 1

If you only care about unique items then what you want is a Set .

For example:

names = Set.new(File.readlines('names.txt').map(&:chomp))

Where that takes the "chomped" version of each line (minus linefeed character) and puts it into the Set.

Now you can get them all back:

names.sort.each do |name|
  puts name
end

Answer 2

I've assumed that it is the last names that must be unique.

Let's first create the file.

text =<<~END
Smith, Kim
ut Voluptatem ipsam et at.
Marv, Gardens
non Facere et necessitatibus animi.
McLoughlin, Matt
consequatur Eveniet temporibus ducimus amet eaque.
Smith, Jen
pariatur Unde voluptas sit fugit.
Brad, Nick
et Maiores ab officia sed.
END

FName = "test.txt"

File.write(FName, text)
  #=> 239

See IO::write ¹ . We now read the file and calculate the number of unique last names.

require 'set'

File.foreach(FName).with_index.with_object(Set.new) do |(line, idx),set|
  set << line[/.+(?=,)/] if idx.even?
end.size
  #=> 4

The steps are as follows.

enum1 = File.foreach(FName)
  #=> #<Enumerator: File:foreach("test.txt")> 
enum2 = enum1.with_index
  #=> #<Enumerator: #<Enumerator: File:foreach("test.txt")>:with_index> 
enum3 = enum2.with_object(Set.new)
  #=> #<Enumerator: #<Enumerator: #<Enumerator: 
  #      File:foreach("test.txt")>:with_index>:with_object(#<Set: {}>)> 

See IO::foreach , Enumerator#with_index , Enumerator#with_object and Set::new . Notice that enum2 and enum3 can be thought of as compound enumerators .

The first element is generated by enum3 , passed to the block and the block variables are assigned values:

(line, idx),set = enum3.next
  #=> [["Smith, Kim\n", 0], #<Set: {}>] 
line
  #=> "Smith, Kim\n" 
idx
  #=> 0 
set
  #=> #<Set: {}> 

line , idx and set are the block variables . The process of breaking enum3.next into its three components is called array decomposition . See this article for a fuller discussion of this important technique.

The block calculation is now perfomed:

idx.even?
  #=> true 
s = line[/.+(?=,)/]
  #=> "Smith" 
set << s
  #=> #<Set: {"Smith"}> 

See Integer#even? and Set#<< . In calculating s , the (third form of the) method Sting#[] is used with the regular expression /.+(?=,)/ , which reads, "match one or more characters follow by a comma, (?=,) being a positive lookahead .

The second element is generated by enum3 , passed to the block, the block variables are assigned values and block calculation is performed:

(line, idx),set = enum3.next
  #=> [["ut Voluptatem ipsam et at.\n", 1], #<Set: {"Smith"}>] 
line
  #=> "ut Voluptatem ipsam et at.\n" 
idx
  #=> 1 
set
  #=> #<Set: {"Smith"}> 
idx.even?
  #=> false 

Since idx.even? #=> false idx.even? #=> false we skip this line. (Indeed, the only reason for including with_index is to determine which lines have even indices.) The third element is generated by enum3 , passed to the block, the block variables are assigned values and block calculation is performed:

(line, idx),set = enum3.next
  #=> [["Marv, Gardens\n", 2], #<Set: {"Smith"}>] 
line
  #=> "Marv, Gardens\n" 
idx
  #=> 2 
set
  #=> #<Set: {"Smith"}> 
idx.even?
  #=> true 
s = line[/.+(?=,)/]
  #=> "Marv" 
set << s
  #=> #<Set: {"Smith", "Marv"}> 

and so on, until we obtain:

arr = File.foreach(FName).with_index.with_object(Set.new) do |(line, idx),set|
  set << line[/.+(?=,)/] if idx.even?
end
  #=> #<Set: {"Smith", "Marv", "McLoughlin", "Brad"}>

Notice that, since sets contain unique values, "Smith" was not added to the set when processing "Smith, Jen" . We now perform the final step:

arr.size
  #=> 4

^{1 Even though write is a method of IO , it is customary to write it (and other IO methods) with File as its receiver. This is permissible because File is a subclass of IO , and therefore inherits the latter's methods. The two colons in IO::write signifies that write is a class method . By contrast, the pound sign in IO#gets indicates that gets is an instance method .}

Answer 3

You first would have to find out what is a name and not. Then you could push the names into an array based on if the array already has that name.

array.push(name) unless array.include?(name)

Then just do a count on the array

array.count