Доверил работу ИИ-агенту, и вот что вышло. Большой тест топовых моделей ChatGPT 6.1 Sol и 6.0 Astra, задачи серьёзные

ПРЕТЕНЗИЯ
об устранении недостатков выполненных работ

Кому: [наименование / Ф. И. О. подрядчика]
От: [Ф. И. О. заказчика]
Адрес объекта: [адрес квартиры]
Договор: № [номер] от [дата]

В соответствии с указанным договором вами были выполнены работы по капитальному ремонту квартиры по адресу: [адрес]. Стоимость работ оплачена мной в полном объёме.

После завершения ремонта были обнаружены следующие недостатки:

1. Протекают скрытые трубы.
2. Нагреваются электрические розетки.
3. Плитка на кухне отходит от основания пола.
4. Вода просачивается из встроенных в стены элементов душевой.
5. Вентиляция работает в обратном направлении.

Перечисленные недостатки свидетельствуют о ненадлежащем качестве выполненных работ и препятствуют нормальной и безопасной эксплуатации квартиры. Несмотря на обращения с моей стороны, их устранение затягивается.

На основании условий договора, предусматривающих качественное выполнение работ, требую:

1. Бесплатно устранить все перечисленные недостатки в полном объёме.
2. Согласовать со мной конкретные даты начала и окончания работ по каждому недостатку.
3. До начала исправлений сообщить порядок проведения работ и обеспечить их выполнение без необоснованных задержек.
4. После завершения работ провести совместную проверку результата и оформить подтверждение устранения недостатков.

Прошу не позднее [дата / количество рабочих дней] с момента получения настоящей претензии направить письменный ответ и предложить график устранения недостатков.

Я готов(а) обеспечить доступ в квартиру в предварительно согласованные даты и время.

Рассчитываю на оперативное и добросовестное выполнение обязательств по договору.

Приложения при наличии:
1. Копия договора.
2. Документы, подтверждающие оплату.
3. Фотографии и видеозаписи обнаруженных недостатков.
4. Копии переписки и обращений к подрядчику.

Дата: «» __________ 20 г.

Подпись: __________________ / [Ф. И. О.]
Контактный телефон: [номер]
Электронная почта: [адрес]

Подрядчику: [наименование / Ф. И. О.]
От заказчика: [Ф. И. О.]
Контактные данные: [телефон, электронная почта]

ПРЕТЕНЗИЯ
об устранении недостатков капитального ремонта квартиры

Между нами заключён договор [номер и дата] на выполнение капитального ремонта квартиры по адресу: [адрес]. Работы по договору полностью оплачены.

После проведения ремонта обнаружены следующие недостатки:

1. Протекают скрытые трубы.
2. Нагреваются розетки.
3. Плитка на кухне отходит от основания пола.
4. Вода просачивается из встроенных стенок душа.
5. Вентиляция работает в обратную сторону.

Перечисленные недостатки не соответствуют предусмотренному договором требованию о качественном оказании услуг. Несмотря на обращения по вопросу их устранения, исправления затягиваются, недостатки остаются неустранёнными.

Требую без дополнительной оплаты устранить все пять недостатков, включая необходимые для этого работы и материалы, а также восстановить отделку, затронутую при исправлении. Устранение должно охватывать причины недостатков, а не только их внешние проявления.

Прошу в течение [количество] рабочих дней с даты получения настоящей претензии направить письменный ответ и согласовать со мной:

* дату осмотра квартиры;
* перечень работ по каждому недостатку;
* конкретные даты начала и завершения исправлений;
* порядок проверки результата и приёмки выполненных работ.

Прошу уделить первоочередное внимание протечкам скрытых труб и нагреву розеток.

Готов(а) предоставить доступ в квартиру в предварительно согласованное время. Ожидаю конкретного графика устранения всех недостатков и его соблюдения. Дальнейшее затягивание исправлений считаю неприемлемым.

Ответ прошу направить по адресу: [электронная почта / почтовый адрес].

Дата: [дата]
Подпись: _____________ / [Ф. И. О.]

import math
import random
import time

def solve(points, time_limit=2.0, seed=0):
“””
Возвращает циклический маршрут как перестановку индексов, начинающуюся с 0.
Возвращение из последней точки в точку 0 подразумевается.
“””
started = time.perf_counter()
limit = max(0.0, float(time_limit))
# Небольшой запас снижает вероятность выхода за лимит из-за последней итерации.
deadline = started + max(0.0, limit – min(0.003, limit * 0.0125))

n = len(points)
if n <= 1: return list(range(n)) xs = [float(p[0]) for p in points] ys = [float(p[1]) for p in points] hypot = math.hypot # Полная матрица расстояний: при n <= 500 она ускоряет все последующие # локальные преобразования маршрута. dist = [[0.0] * n for _ in range(n)] for i in range(n): xi, yi = xs[i], ys[i] row_i = dist[i] for j in range(i): value = hypot(xi - xs[j], yi - ys[j]) row_i[j] = value dist[j][i] = value def route_length(route): total = dist[route[-1]][route[0]] for i in range(n - 1): total += dist[route[i]][route[i + 1]] return total def nearest_neighbor(start): unused = bytearray(b"\x01") * n unused[start] = 0 route = [start] current = start for _ in range(n - 1): row = dist[current] best = -1 best_d = math.inf for j in range(n): if unused[j] and row[j] < best_d: best_d = row[j] best = j unused[best] = 0 route.append(best) current = best return route def convex_hull(): order = sorted(range(n), key=lambda i: (xs[i], ys[i], i)) def cross(a, b, c): return ((xs[b] - xs[a]) * (ys[c] - ys[a]) - (ys[b] - ys[a]) * (xs[c] - xs[a])) lower = [] for p in order: while len(lower) >= 2 and cross(lower[-2], lower[-1], p) <= 0.0: lower.pop() lower.append(p) upper = [] for p in reversed(order): while len(upper) >= 2 and cross(upper[-2], upper[-1], p) <= 0.0: upper.pop() upper.append(p) hull = lower[:-1] + upper[:-1] if not hull: return [0] # При совпадающих координатах удаляем возможные повторы индексов. seen = bytearray(n) result = [] for p in hull: if not seen[p]: seen[p] = 1 result.append(p) return result def farthest_insertion(): route = convex_hull() inside = bytearray(n) for p in route: inside[p] = 1 if len(route) == 1: # Чтобы на каждом шаге существовало обычное ребро цикла. q = max(range(n), key=dist[route[0]].__getitem__) if q != route[0]: route.append(q) inside[q] = 1 nearest = [math.inf] * n for p in range(n): if not inside[p]: nearest[p] = min(dist[p][q] for q in route) while len(route) < n: selected = -1 farthest = -1.0 for p in range(n): if not inside[p] and nearest[p] > farthest:
farthest = nearest[p]
selected = p

best_pos = 0
best_delta = math.inf
m = len(route)
for i in range(m):
a = route[i]
b = route[(i + 1) % m]
delta = dist[a][selected] + dist[selected][b] – dist[a][b]
if delta < best_delta: best_delta = delta best_pos = i + 1 route.insert(best_pos, selected) inside[selected] = 1 nearest[selected] = 0.0 row = dist[selected] for p in range(n): if not inside[p] and row[p] < nearest[p]: nearest[p] = row[p] return route # Два существенно разных конструктивных алгоритма. route_a = farthest_insertion() route_b = nearest_neighbor(0) if route_length(route_b) < route_length(route_a): best_route = route_b else: best_route = route_a # Дополнительный NN-старт полезен для кластерных данных. if n <= 320 or time.perf_counter() < deadline - 0.025: farthest_from_zero = max(range(n), key=dist[0].__getitem__) route_c = nearest_neighbor(farthest_from_zero) if route_length(route_c) < route_length(best_route): best_route = route_c if time.perf_counter() >= deadline:
zero = best_route.index(0)
return best_route[zero:] + best_route[:zero]

# Ближайшие соседи используются как набор перспективных ребер.
candidate_count = 24 if n <= 180 else (20 if n <= 350 else 16) candidates = [] for i in range(n): ordered = sorted(range(n), key=dist[i].__getitem__) candidates.append([j for j in ordered if j != i][:candidate_count]) def make_positions(route): pos = [0] * n for i, p in enumerate(route): pos[p] = i return pos def reverse_segment(route, pos, left, right): route[left:right + 1] = reversed(route[left:right + 1]) for k in range(left, right + 1): pos[route[k]] = k def try_two_opt(route, pos): """Один первый улучшающий 2-opt ход по кандидатным ребрам.""" checks = 0 for i in range(n): a = route[i] b = route[(i + 1) % n] old_ab = dist[a][b] # В первой фазе коротким кандидатным ребром является a-c. for c in candidates[a]: j = pos[c] d = route[(j + 1) % n] if c == b or d == a: continue old = old_ab + dist[c][d] gain = old - dist[a][c] - dist[b][d] if gain > 1e-12 * (1.0 + old):
if i < j: reverse_segment(route, pos, i + 1, j) else: reverse_segment(route, pos, j + 1, i) return True checks += 1 if (checks & 255) == 0 and time.perf_counter() >= deadline:
return False

# Во второй фазе коротким кандидатным ребром является b-d.
for d in candidates[b]:
j = (pos[d] – 1) % n
c = route[j]

if c == a or c == b or d == a:
continue

old = old_ab + dist[c][d]
gain = old – dist[a][c] – dist[b][d]
if gain > 1e-12 * (1.0 + old):
if i < j: reverse_segment(route, pos, i + 1, j) else: reverse_segment(route, pos, j + 1, i) return True checks += 1 if (checks & 255) == 0 and time.perf_counter() >= deadline:
return False

return False

def try_relocate(route, pos):
“””Перенос одной точки в более выгодное место.”””
checks = 0

for i in range(n):
a = route[i]
prev_a = route[(i – 1) % n]
next_a = route[(i + 1) % n]
removal = dist[prev_a][a] + dist[a][next_a] – dist[prev_a][next_a]

# Рассматриваем вставку как после близкой точки, так и перед ней.
for near in candidates[a]:
near_pos = pos[near]
after_nodes = (near, route[(near_pos – 1) % n])

for c in after_nodes:
if c == a or c == prev_a:
continue
j = pos[c]
d = route[(j + 1) % n]
if d == a:
continue

insertion = dist[c][a] + dist[a][d] – dist[c][d]
old_scale = removal + dist[c][d]
if removal – insertion > 1e-12 * (1.0 + old_scale):
route.pop(i)
if i < j: j -= 1 route.insert(j + 1, a) for k, p in enumerate(route): pos[p] = k return True checks += 1 if (checks & 255) == 0 and time.perf_counter() >= deadline:
return False
return False

def try_full_two_opt(route, pos):
“””Редкая полная проверка: находит улучшения вне списка соседей.”””
checks = 0
for i in range(n – 2):
a = route[i]
b = route[i + 1]
old_ab = dist[a][b]

upper = n if i != 0 else n – 1
for j in range(i + 2, upper):
c = route[j]
d = route[(j + 1) % n]
old = old_ab + dist[c][d]
gain = old – dist[a][c] – dist[b][d]

if gain > 1e-12 * (1.0 + old):
reverse_segment(route, pos, i + 1, j)
return True

checks += 1
if (checks & 511) == 0 and time.perf_counter() >= deadline:
return False
return False

def local_search(route, allow_full=False):
pos = make_positions(route)

while time.perf_counter() < deadline: while time.perf_counter() < deadline and try_two_opt(route, pos): pass if time.perf_counter() >= deadline:
break

if try_relocate(route, pos):
continue

if allow_full and try_full_two_opt(route, pos):
continue

break

return route

# Основной спуск к локальному минимуму.
best_route = local_search(best_route, allow_full=True)
best_length = route_length(best_route)

# Iterated local search: несколько сильных 4-opt встрясок с последующим
# повторным локальным поиском. Лучший маршрут всегда сохраняется.
rng = random.Random(seed)

while n >= 8 and time.perf_counter() < deadline: cuts = sorted(rng.sample(range(1, n), 4)) a, b, c, d = cuts trial = ( best_route[:a] + best_route[c:d] + best_route[b:c] + best_route[a:b] + best_route[d:] ) local_search(trial, allow_full=False) trial_length = route_length(trial) if trial_length < best_length: best_route = trial best_length = trial_length zero = best_route.index(0) return best_route[zero:] + best_route[:zero]

from math import hypot
from random import Random
from time import perf_counter

def solve(points, time_limit=2.0, seed=0):
start = perf_counter()
# Запас на сборку результата и освобождение памяти.
reserve = min(0.008, time_limit * 0.03)
deadline = start + max(0.0, time_limit – reserve)

fallback = list(range(len(points)))
if len(points) < 3: return fallback # Совпадающие точки выгодно посещать подряд. ids = {} coords = [] groups = [] for i, (x, y) in enumerate(points): key = (x, y) v = ids.get(key) if v is None: ids[key] = len(coords) coords.append(key) groups.append([i]) else: groups[v].append(i) n = len(coords) def finish(t): z = t.index(0) return [i for v in t[z:] + t[:z] for i in groups[v]] if n < 3: return finish(list(range(n))) rng = Random(seed) # Симметричная матрица расстояний. dist = [[0.0] * n for _ in range(n)] for i in range(n): x, y = coords[i] row = dist[i] for j in range(i): xj, yj = coords[j] value = hypot(x - xj, y - yj) row[j] = value dist[j][i] = value if perf_counter() >= deadline:
return fallback

# Начальный маршрут: вставка наиболее удалённой от цикла точки.
far = max(range(1, n), key=dist[0].__getitem__)
if dist[0][far] == 0.0:
return fallback

tour = [0, far]
remaining = [i for i in range(1, n) if i != far]
near = [min(dist[0][i], dist[far][i]) for i in range(n)]

while remaining:
v = max(remaining, key=near.__getitem__)
row = dist[v]
best_cost = float(“inf”)
place = 0
a = tour[-1]
for pos, b in enumerate(tour):
cost = row[a] + row[b] – dist[a][b]
if cost < best_cost: best_cost, place = cost, pos a = b tour.insert(place, v) remaining.remove(v) for u in remaining: if row[u] < near[u]: near[u] = row[u] if perf_counter() >= deadline:
tour.extend(remaining)
return finish(tour)

if n <= 3: return finish(tour) def length(t): return sum(dist[t[i - 1]][t[i]] for i in range(n)) best = tour[:] best_length = length(best) eps = best_length * 1e-13 / n # Короткие списки кандидатов для основного локального поиска. k = min(24, n - 1) candidates = [] for i, row in enumerate(dist): neighbors = sorted(range(n), key=row.__getitem__) candidates.append([j for j in neighbors if j != i][:k]) if perf_counter() >= deadline:
return finish(best)

# Двусвязный цикл: перенос короткой цепочки занимает O(1).
nxt = [0] * n
prv = [0] * n
order = list(range(n))
rng.shuffle(order)

def load(t):
for i, a in enumerate(t):
b = t[(i + 1) % n]
nxt[a] = b
prv[b] = a

def extract():
t = [0]
a = nxt[0]
while a != 0:
t.append(a)
a = nxt[a]
return t

def reverse(a, b, c, d):
# Заменить рёбра a-b, c-d на a-c, b-d.
u = b
while True:
v = nxt[u]
nxt[u], prv[u] = prv[u], v
if u == c:
break
u = v
nxt[a], prv[c] = c, a
nxt[b], prv[d] = d, b

def improve():
active = bytearray(b”\x01″) * n
changed = True

while changed:
changed = False
for v in order:
if perf_counter() >= deadline:
return
if not active[v]:
continue

active[v] = 0
p, b = prv[v], nxt[v]
dv = dist[v]
found = False

# 2-opt: проверяем обе ориентации рёбер.
for w in candidates[v]:
c, q = nxt[w], prv[w]

if w != b and c != v:
gain = (
dv[b] + dist[w][c]
– dv[w] – dist[b][c]
)
if gain > eps:
reverse(v, b, w, c)
active[v] = active[b] = 1
active[w] = active[c] = 1
found = True
break

if w != p and q != v:
gain = (
dist[p][v] + dist[q][w]
– dist[p][q] – dv[w]
)
if gain > eps:
reverse(p, v, q, w)
active[p] = active[v] = 1
active[q] = active[w] = 1
found = True
break

if found:
changed = True
continue

# Перенос цепочек длины 1–3, включая их разворот.
segment = []
e = v
for _ in range(3):
segment.append(e)
r = nxt[e]
if r == p:
break

de = dist[e]
saving = dist[p][v] + de[r] – dist[p][r]

for w in candidates[v]:
if w in segment:
continue
c, q = nxt[w], prv[w]

# Вставить v…e после w без разворота.
if w != p:
gain = (
saving + dist[w][c]
– dv[w] – de[c]
)
if gain > eps:
nxt[p], prv[r] = r, p
nxt[w], prv[v] = v, w
nxt[e], prv[c] = c, e

active[p] = active[r] = 1
active[w] = active[c] = 1
for u in segment:
active[u] = 1
found = True
break

# Вставить e…v перед w с разворотом.
if w != r:
gain = (
saving + dist[q][w]
– de[q] – dv[w]
)
if gain > eps:
nxt[p], prv[r] = r, p
for u in segment:
nxt[u], prv[u] = prv[u], nxt[u]
nxt[q], prv[e] = e, q
nxt[v], prv[w] = w, v

active[p] = active[r] = 1
active[q] = active[w] = 1
for u in segment:
active[u] = 1
found = True
break

if found:
break
e = r

if found:
changed = True

def full_two_opt():
# Полный проход нужен, в частности, для далёких скоплений:
# соединяющие их рёбра могут отсутствовать в кандидатах.
t = extract()
best_gain = eps
move = None

for i in range(n – 2):
if perf_counter() >= deadline:
break

a, b = t[i], t[i + 1]
da, db = dist[a], dist[b]
ab = da[b]

for j in range(i + 2, n):
c, d = t[j], t[(j + 1) % n]
gain = ab + dist[c][d] – da[c] – db[d]
if gain > best_gain:
best_gain = gain
move = (a, b, c, d)

if move is None:
return False
reverse(*move)
return True

load(tour)
failures = 0
iteration = 0

while perf_counter() < deadline: improve() if iteration == 0 or iteration % 8 == 0: while perf_counter() < deadline and full_two_opt(): improve() tour = extract() value = length(tour) if value < best_length: best, best_length = tour[:], value failures = 0 else: failures += 1 if perf_counter() >= deadline:
break

# Double-bridge: разрываем четыре ребра и переставляем
# части цикла, затем снова запускаем локальный поиск.
tour = best[:]
strength = 1 + min(4, failures // 6)
for _ in range(strength):
a, b, c, d = sorted(rng.sample(range(n), 4))
tour = (
tour[:a]
+ tour[c:d]
+ tour[b:c]
+ tour[a:b]
+ tour[d:]
)

load(tour)
iteration += 1

return finish(best)