fix

Author: vtm9

apps/codebattle/lib/codebattle/tournament/strategy/top200.ex

@@ -216,17 +216,22 @@ defmodule Codebattle.Tournament.Top200 do
     end
   end
 
-  # Финал турнира. Места 9..N уже корректны: ранжирование после раунда 7 расставило
-  # игроков по сумме очков, а вылетевшие после 5-го раунда (раунд 4) плей-офф не играли,
-  # поэтому их сумма = очки за 5 раундов и они стоят на 9..N. Полный пересчёт результатов
-  # (reset+rebuild) не нужен — переставляем ТОЛЬКО топ-8: их места задаёт сетка финалов.
+  # Финал турнира. Полный пересчёт результатов (reset+rebuild) не нужен — расставляем места
+  # в два шага:
+  #   1) топ-8 по сетке финалов получают места 1..8 (assign_final_bracket_places);
+  #   2) всем остальным проставляем места 9..N по сумме очков (assign_eliminated_places).
+  #
+  # Шаг 2 ОБЯЗАТЕЛЕН: set_ranking перед этим нумерует ВСЁ поле (1..N) по сумме очков, и эти
+  # места вылетевших пересекаются с 1..8 из сетки → в лидерборде появляются дубли мест
+  # (топ-8 vs вылетевшие). Поэтому вылетевших надо перенумеровать ровно с 9.
   #
   # Результаты раунда 7 здесь уже в TournamentResult: на любом пути завершения их пишет
   # finish_tournament (base) через upsert_results перед вызовом compute_final_standings.
   # Поэтому assign_final_bracket_places определяет победителей пар по реальным очкам.
   def compute_final_standings(tournament) do
     tournament
     |> assign_final_bracket_places()
+    |> assign_eliminated_places()
     |> recalculate_player_wins_count()
   end
 
@@ -262,6 +267,38 @@ defmodule Codebattle.Tournament.Top200 do
     tournament
   end
 
+  # Все, кроме топ-8 финалистов, получают места 9..N по сумме очков (тай-брейк: меньшее
+  # общее время, затем меньший id — как в set_ranking). Без этого вылетевшие сохраняют
+  # места из set_ranking по всему полю (1..N), пересекающиеся с 1..8 сетки → дубли в
+  # лидерборде. Перенумеровываем ровно тех, кого попадёт в tournament_user_results
+  # (не-боты, не-читеры), чтобы места шли подряд без дыр; читеров доставляет upsert.
+  defp assign_eliminated_places(tournament) do
+    bracket_ids = final_bracket_ids(tournament)
+    cheater_ids = MapSet.new(tournament.cheater_ids || [])
+    start_place = MapSet.size(bracket_ids) + 1
+
+    tournament
+    |> get_players()
+    |> Enum.reject(&(&1.is_bot || MapSet.member?(bracket_ids, &1.id) || MapSet.member?(cheater_ids, &1.id)))
+    |> Enum.sort_by(fn p -> {-score_value(p.score), p.total_duration_sec || 0, p.id} end)
+    |> Enum.with_index(start_place)
+    |> Enum.each(fn {player, place} ->
+      Tournament.Players.put_player(tournament, %{player | place: place})
+    end)
+
+    tournament
+  end
+
+  # id восьми финалистов плей-офф (пары раунда 7) — те, кому assign_final_bracket_places
+  # уже выдал места 1..8. Если раунд 7 не доигран, пар нет → пустое множество, и тогда
+  # assign_eliminated_places честно перенумеровывает всё поле с 1.
+  defp final_bracket_ids(tournament) do
+    case round_player_pairs(tournament, 7) do
+      [_, _, _, _] = pairs -> pairs |> List.flatten() |> MapSet.new()
+      _ -> MapSet.new()
+    end
+  end
+
   # Финальное место в плей-офф задаёт И place, И draw_index = 9 - place. Так 1-е место
   # получает уникальный максимум draw_index (8), и подсветка «живых» (draw_index == max)
   # оставляет ровно чемпиона. Места 2..8 идут по убыванию, как и положено сетке.

apps/codebattle/test/codebattle/tournament/entire/top200_test.exs

@@ -350,6 +350,69 @@ defmodule Codebattle.Tournament.Entire.Top200Test do
       assert Tournament.Players.get_player(tournament, 2).score == 10
       assert Tournament.Players.get_player(tournament, 9).score == 50
     end
+
+    test "вылетевшие перенумеровываются в 9..N — нет дублей мест с топ-8 сетки" do
+      # Регрессия: set_ranking нумерует ВСЁ поле (1..N) по сумме очков, поэтому вылетевшие
+      # приходят в compute_final_standings с местами, пересекающимися с 1..8 сетки (на проде
+      # это давало дубли мест 3..8 у топ-8 в лидерборде). Должны стать 9..N без коллизий.
+      tournament = insert_top200_tournament()
+      players_table = Tournament.Players.create_table(tournament.id)
+
+      finals =
+        inline_matches([
+          %Match{id: 1, player_ids: [1, 2], round_position: 7, state: "game_over"},
+          %Match{id: 2, player_ids: [3, 4], round_position: 7, state: "game_over"},
+          %Match{id: 3, player_ids: [5, 6], round_position: 7, state: "game_over"},
+          %Match{id: 4, player_ids: [7, 8], round_position: 7, state: "game_over"}
+        ])
+
+      tournament = %{tournament | players_table: players_table, current_round_position: 7, matches: finals}
+
+      # Победители финалов по очкам раунда 7: 1, 3, 5, 7.
+      record_scores(tournament.id, 7, [
+        {1, 100},
+        {2, 10},
+        {3, 100},
+        {4, 10},
+        {5, 100},
+        {6, 10},
+        {7, 100},
+        {8, 10}
+      ])
+
+      Enum.each(1..8, fn id ->
+        Tournament.Players.put_player(
+          tournament,
+          Player.new!(%{id: id, name: "p#{id}", state: "active", score: 0, place: 0})
+        )
+      end)
+
+      # Вылетевшие 9..14: НАРОЧНО с местами 3..8 (как их пронумеровал set_ranking по полю) —
+      # ровно те, что пересекаются с сеткой. Сумма очков убывает с id → ожидаемый порядок 9..14.
+      Enum.each([{9, 60, 3}, {10, 50, 4}, {11, 40, 5}, {12, 30, 6}, {13, 20, 7}, {14, 10, 8}], fn {id, score, place} ->
+        Tournament.Players.put_player(
+          tournament,
+          Player.new!(%{id: id, name: "p#{id}", state: "active", score: score, place: place})
+        )
+      end)
+
+      Top200.compute_final_standings(tournament)
+
+      place_of = fn id -> Tournament.Players.get_player(tournament, id).place end
+
+      # Топ-8 — по сетке финалов (победитель пары — лучшее место).
+      assert place_of.(1) == 1
+      assert place_of.(3) == 3
+      assert place_of.(5) == 5
+      assert place_of.(7) == 7
+
+      # Вылетевшие — строго 9..14 по убыванию суммы очков, БЕЗ пересечения с 1..8.
+      assert Enum.map(9..14, place_of) == [9, 10, 11, 12, 13, 14]
+
+      # Главное: места всего поля уникальны и образуют ровно 1..14 — дублей нет.
+      all_places = Enum.map(1..14, place_of)
+      assert Enum.sort(all_places) == Enum.to_list(1..14)
+    end
   end
 
   describe "TournamentUserResult.upsert_results/1 — top200 (регрессия на потерю рейтинга)" do