Ruby reorder an array based on the contents of a subset array

I know this sounds weird, but trust me, there is a very good reason for it.

Sorry, no can do. I think you chose the wrong structure for your hashes to begin with. I can't think of any reason why you would create hashes which have different keys for each person's name. When you are having trouble manipulating the data structure that you initially chose, then you should think about restructuring your data.

teams = { 
  Bill: {group: "a", points: 4},
  Will: {group: "b", points: 3},
  Gill: {group: "c", points: 2},
  Pill: {group: "d", points: 1},
}

teams_subset = {
  Gill: {group: "c", points: 3}, 
  Will: {group: "b", points: 2}, 
  Bill: {group: "a", points: 1},
}

subset_names =  teams_subset.keys
new_teams = {}

teams.each do |team, stats|
  if teams_subset.include? team
    next_subset_name = subset_names.shift
    new_teams[next_subset_name] = teams[next_subset_name]
  else 
    new_teams[team] = stats
  end
end 

p new_teams

--output:--
{:Gill=>{:group=>"c", :points=>2}, :Will=>{:group=>"b", :points=>3}, :Bill=>{:group=>"a", :points=>4}, :Pill=>{:group=>"d", :points=>1}}

Or even:

teams =  [
  {name: 'Bill', stats: {group: "a", points: 4}},
  {name: 'Will', stats: {group: "b", points: 3}},
  {name: 'Gill', stats: {group: "c", points: 2}},
  {name: 'Pill', stats: {group: "d", points: 1}},
]

Based on your new revelations, I would just use a quasi Schwarzian Transform to convert your data to this form:

"Bill"=>{:name=>"Bill", :points=>4}

...then apply code similar to what I posted above, like this:

require 'set'

teams =  [
  {name: 'Bill', points: 4},
  {name: 'Will', points: 3},
  {name: 'Gill', points: 2},
  {name: 'Pill', points: 1},
]

remapped_teams = {}

teams.each do |hash|
  name = hash[:name]
  remapped_teams[name] = hash
end

p remapped_teams

#--output:--
#{"Bill"=>{:name=>"Bill", :points=>4}, "Will"=>{:name=>"Will", :points=>3}, "Gill"=>{:name=>"Gill", :points=>2}, "Pill"=>{:name=>"Pill", :points=>1}}

teams_subset = [
  {name: 'Gill', points: 3}, 
  {name: 'Will', points: 2}, 
  {name: 'Bill', points: 1},
]

subset_names = teams_subset.map do |hash|
  hash[:name]
end
subset_names_lookup = Set.new(subset_names)

new_team_order = remapped_teams.map do |(name, hash)|
  if subset_names_lookup.include? name
    remapped_teams[subset_names.shift]
  else 
    hash
  end
end 

p new_team_order

--output:--
[{:name=>"Gill", :points=>2}, {:name=>"Will", :points=>3}, {:name=>"Bill", :points=>4}, {:name=>"Pill", :points=>1}]

Here's another way to do it. This is based on the understanding that each hash in original and in subset contain the same two keys: :name (say) and :points.

Code

def reorder(original, subset)
  orig_hash = original.each_with_object({}) { |h,g| g[h[:name]] = h }
  subset_names = subset.map { |h| h[:name] }
  orig_hash.map { |k,v|
    subset_names.include?(k) ? orig_hash[subset_names.rotate!.last] : v }
end

Examples

original = [{name: "Bill", points: 4}, {name: "Will", points: 3},
            {name: "Gill", points: 2}, {name: "Pill", points: 1}]

#1

subset   = [{name: "Gill", points: 2}, {name: "Will", points: 1}]
reorder(original, subset)
  #=> [{:name=>"Bill", :points=>4}, {:name=>"Gill", :points=>2},
  #    {:name=>"Will", :points=>3}, {:name=>"Pill", :points=>

#2

subset   = [{name: "Gill", points: 3}, {name: "Will", points: 2},
            {name: "Bill", points: 1}]

reorder(original, subset)
  #=> [{:name=>"Gill", :points=>2}, {:name=>"Will", :points=>3},
  #    {:name=>"Bill", :points=>4}, {:name=>"Pill", :points=>1}]

Explanation

The following calculations are performed for original above and

subset = [{c: "Gill", points: 2}, {b: "Will", points: 1}]

Construct this hash from original:

orig_hash = original.each_with_object({}) { |h,g| g[h[:name]] = h }
  #=> {"Bill"=>{:name=>"Bill", :points=>4}, "Will"=>{:name=>"Will", :points=>3},
      "Gill"=>{:name=>"Gill", :points=>2}, "Pill"=>{:name=>"Pill", :points=>1}}

and an array of the values of :name from subsets:

subset_names = subset.map { |h| h[:name] }
  #=> ["Gill", "Will"]

All that remains is to map each k=>v element of orig_hash to either v (if subset_names does not have the key k) or to the first element of subset_names. As we cannot delete the latter from subset_names, I have chosen to rotate the array by +1 and then retrieve that value from the last position. That way, the next key in subset_names will then be positioned properly, at the beginning of the array.

orig_hash.map { |k,v| subset_names.include?(k) ? orig_hash[subset_names.rotate!.last] : v }
  #=> [{:name=>"Bill", :points=>4}, {:name=>"Gill", :points=>2},
  #    {:name=>"Will", :points=>3}, {:name=>"Pill", :points=>1}]