amos 9d633e9e67 Batch 15 (20261023-C-hwe-scale-15): 320 HWE-derived repair tasks
One user-space repair task per eligible HWE debug-diag / compile-deploy base
ID: 320 admitted (C 218, C++ 97, build scripts 5), 1 skipped by the content
filter. Each ships a public spec with a check-to-basis table, at least two
defects with single-fix fixtures, a symptom-masking fixture and an alternative
correct implementation. Claude re-checked all 320: structure, the HWE quality
items and trace6 Docker calibration receipts against current digests
(320/320 USABLE). Difficulty is unmeasured. Known follow-up: 212 tasks use 120
ad-hoc family names; the next batch maps them to the canonical list.
The batch's 1,256-line progress log stays in its factory report and the
36-local branch batch15-hwe.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 01:55:56 +08:00

204 lines
5.9 KiB
C

#include "array_report.h"
static void prefix_extremes(const ra_cell *cells, size_t size, ra_report *report)
{
long long prefix = 0;
long long lower = 0;
long long upper = 0;
for (size_t index = 0; index < size; ++index) {
prefix += cells[index].value;
if (prefix < lower) {
lower = prefix;
}
if (prefix > upper) {
upper = prefix;
}
}
report->v[36] = lower;
report->v[37] = upper;
}
static void sign_segments(const ra_cell *cells, size_t size, ra_report *report)
{
size_t positive_runs = 0;
size_t negative_runs = 0;
size_t positive_longest = 0;
size_t negative_longest = 0;
size_t positive_length = 0;
size_t negative_length = 0;
for (size_t index = 0; index < size; ++index) {
int value = cells[index].value;
if (value > 0) {
if (positive_length == 0) {
positive_runs += 1;
}
positive_length += 1;
negative_length = 0;
} else if (value < 0) {
if (negative_length == 0) {
negative_runs += 1;
}
negative_length += 1;
positive_length = 0;
} else {
positive_length = 0;
negative_length = 0;
}
if (positive_length > positive_longest) {
positive_longest = positive_length;
}
if (negative_length > negative_longest) {
negative_longest = negative_length;
}
}
report->v[38] = (long long)positive_runs;
report->v[39] = (long long)negative_runs;
report->v[40] = (long long)positive_longest;
report->v[41] = (long long)negative_longest;
}
static void neighbour_shape(const ra_cell *cells, size_t size, ra_report *report)
{
long long peaks = 0;
long long valleys = 0;
long long equal_pairs = 0;
long long correlation = 0;
for (size_t index = 1; index < size; ++index) {
long long previous = cells[index - 1].value;
long long current = cells[index].value;
correlation += previous * current;
if (previous == current) {
equal_pairs += 1;
}
if (index + 1 < size) {
long long next = cells[index + 1].value;
if (current > previous && current > next) {
peaks += 1;
}
if (current < previous && current < next) {
valleys += 1;
}
}
}
report->v[42] = peaks;
report->v[43] = valleys;
report->v[44] = equal_pairs;
report->v[45] = correlation;
}
static void position_gaps(const ra_cell *cells, size_t size, ra_report *report)
{
long long largest = 0;
long long missing = 0;
for (size_t index = 1; index < size; ++index) {
long long gap = (long long)cells[index].position - cells[index - 1].position - 1;
missing += gap;
if (gap > largest) {
largest = gap;
}
}
report->v[46] = largest;
report->v[47] = missing;
}
static size_t subsequence(const ra_cell *cells, size_t size, int descending)
{
size_t lengths[RA_LIMIT];
size_t best = 0;
for (size_t end = 0; end < size; ++end) {
size_t length = 1;
for (size_t previous = 0; previous < end; ++previous) {
int earlier = cells[previous].value;
int later = cells[end].value;
int follows = descending ? earlier > later : earlier < later;
if (follows && lengths[previous] + 1 > length) {
length = lengths[previous] + 1;
}
}
lengths[end] = length;
if (length > best) {
best = length;
}
}
return best;
}
static void frequent_value(const ra_cell *cells, size_t size, ra_report *report)
{
size_t best_count = 0;
int best_value = 0;
long long pairs = 0;
for (size_t index = 0; index < size; ++index) {
size_t count = 0;
for (size_t other = 0; other < size; ++other) {
if (cells[other].value == cells[index].value) {
count += 1;
if (other > index) {
pairs += 1;
}
}
}
if (count > best_count) {
best_count = count;
best_value = cells[index].value;
}
}
report->v[50] = best_value;
report->v[51] = (long long)best_count;
report->v[52] = pairs;
}
static long long alternating_sum(const ra_cell *cells, size_t size)
{
long long result = 0;
for (size_t index = 0; index < size; ++index) {
if (index % 2 == 0) {
result += cells[index].value;
} else {
result -= cells[index].value;
}
}
return result;
}
static void crossing_plateau(const ra_cell *cells, size_t size, ra_report *report)
{
long long changes = 0;
int previous_sign = 0;
size_t plateau = 0;
size_t longest = 0;
for (size_t index = 0; index < size; ++index) {
int value = cells[index].value;
int sign = (value > 0) - (value < 0);
if (sign != 0) {
if (previous_sign != 0 && previous_sign != sign) {
changes += 1;
}
previous_sign = sign;
}
if (index != 0 && value == cells[index - 1].value) {
plateau += 1;
} else {
plateau = 1;
}
if (plateau > longest) {
longest = plateau;
}
}
report->v[54] = changes;
report->v[55] = (long long)longest;
}
void ra_trends(const ra_cell *cells, size_t size, ra_report *report)
{
crossing_plateau(cells, size, report);
prefix_extremes(cells, size, report);
sign_segments(cells, size, report);
neighbour_shape(cells, size, report);
position_gaps(cells, size, report);
report->v[48] = (long long)subsequence(cells, size, 0);
report->v[49] = (long long)subsequence(cells, size, 1);
frequent_value(cells, size, report);
report->v[53] = alternating_sum(cells, size);
}