Optimize this ruby loop structure

Depending if you count a sort as a loop this might suffice.

Since hash access is cheap we can say it's O(1) and sorting is O(n*log(n)). The following implementation would have O(n + n*log(n)) which is the same as O(n*log(n)). That is less than O(n + n^2) ~ O(n^2) of your example.

This also meant that the data is accessed fewer times than in your example.

sorted_facts = @facts.sort_by(:real?).reverse!
author_invalidity = {}

sorted_facts.select do |fact|
  author_invalidity[fact.speaker] ||= !fact.real?
  fact.real? && !author_invalidity[fact.speaker]
end

A quick explanation of the idea.

We try to build a hash map of author validity to remove the nested loop from your example. By sorting the facts by truthfulness, so that the false ones come first, we can guarantee that by the time we iterate over the first true fact we have all the invalid authors in our hash map. Then by checking the hash and the fact we can build a list of valid facts in the same iteration we build the hash.

Note that the author_invalidity and double ! are confusing but required in order to utilize ||=. If instead author_validity would be stored (e.g. author_validity[fact.speaker] ||= fact.real?) then the check would always return true after the first valid author is processed. Therefore the logic has to be negative. As outlined in other answers, instead of a Hash a Set can be utilized. Then the logic would be positive.

Hope this gets you thinking in the right direction.

I suggest you write it as follows.

class Fact
  def initialize (fact)
     @fact = fact
  end
  def fact
    @fact[:fact]
  end
  def is_real?
     @fact[:real]
  end
  def speaker
     @fact[:speaker]
  end
end

Create some instances.

facts = [["grass is green", true, "Bob"], ["bears are orange", false, "Sue"],
         ["cats say 'woof'", false, "Bob"], ["dogs are delightful", true, "Hal"]].
          map { |f,t,s| Fact.new(fact: f, real: t, speaker: s) }
  #=> [#<Fact:0x007fd363e4bcc0 @fact=
  #      {:fact=>"grass is green", :real=>true, :speaker=>"Bob"}>,
  #    #<Fact:0x007fd363e4bc20 @fact=
  #      {:fact=>"bears are orange", :real=>false, :speaker=>"Sue"}>,
  #    #<Fact:0x007fd363e4bb80 @fact=
  #      {:fact=>"cats say 'woof'", :real=>false, :speaker=>"Bob"}>,
  #    #<Fact:0x007fd363e4bae0 @fact=
  #      {:fact=>"dogs are delightful", :real=>true, :speaker=>"Sue"}>
  #   ] 

Partition facts into passing_facts and alternative_facts.

passing_facts, alternative_facts = facts.partition(&:is_real?)
  #=> [[#<Fact:0x007fd363e4bcc0 @fact=
  #       {:fact=>"grass is green", :real=>true, :speaker=>"Bob"}>,
  #     #<Fact:0x007fd363e4bae0 @fact=
  #       {:fact=>"dogs are delightful", :real=>true, :speaker=>"Hal"}>
  #    ],
  #    [#<Fact:0x007fd363e4bc20 @fact=
  #       {:fact=>"bears are orange", :real=>false, :speaker=>"Sue"}>,
  #     #<Fact:0x007fd363e4bb80 @fact=
  #       {:fact=>"cats say 'woof'", :real=>false, :speaker=>"Bob"}>
  #    ]
  #   ] 
passing_facts
  #=> [#<Fact:0x007fd363e4bcc0 @fact=
  #      {:fact=>"grass is green", :real=>true, :speaker=>"Bob"}>,
  #    #<Fact:0x007fd363e4bae0 @fact=
  #      {:fact=>"dogs are delightful", :real=>true, :speaker=>"Hal"}>
  #   ]
alternative_facts
  #   [#<Fact:0x007fd363e4bc20 @fact=
  #      {:fact=>"bears are orange", :real=>false, :speaker=>"Sue"}>,
  #    #<Fact:0x007fd363e4bb80 @fact=
  #      {:fact=>"cats say 'woof'", :real=>false, :speaker=>"Bob"}>
  #   ]

Compile list of speakers for alternative_facts.

alternative_speakers = alternative_facts.map { |f| f.speaker }
  #=> ["Sue", "Bob"]

Reject elements of passing_facts for which the value of the key :speaker is a member of alternative_speakers, then map those remaining to the name of the fact.

passing_facts.reject { |f| alternative_speakers.include?(f.speaker) }.
              map { |f| f.fact }
  #=> ["dogs are delightful"]

Note

passing_facts.reject { |f| alternative_speakers.include?(f.speaker) }
  #=> [#<Fact:0x007fd364a38e70 @fact=
  #     {:fact=>"dogs are delightful", :real=>true, :speaker=>"Hal"}>
  #   ] 

If there are large number of "facts", efficiency could be improved by adding require 'set' and tack .to_set to the end of the expression that computes facts.