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>
226 lines
5.9 KiB
C
226 lines
5.9 KiB
C
#include "array_report.h"
|
|
#include <limits.h>
|
|
|
|
static long long total(const ra_cell *cells, size_t size)
|
|
{
|
|
long long result = 0;
|
|
for (size_t index = 0; index < size; ++index) {
|
|
result += cells[index].value;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static long long absolute_total(const ra_cell *cells, size_t size)
|
|
{
|
|
long long result = 0;
|
|
for (size_t index = 0; index < size; ++index) {
|
|
long long value = cells[index].value;
|
|
result += value < 0 ? -value : value;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static long long square_total(const ra_cell *cells, size_t size)
|
|
{
|
|
long long result = 0;
|
|
for (size_t index = 0; index < size; ++index) {
|
|
long long value = cells[index].value;
|
|
result += value * value;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static long long position_total(const ra_cell *cells, size_t size)
|
|
{
|
|
long long result = 0;
|
|
for (size_t index = 0; index < size; ++index) {
|
|
long long weight = cells[index].position + 1;
|
|
result += weight * cells[index].value;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static void extremes(const ra_cell *cells, size_t size, ra_report *report)
|
|
{
|
|
if (size == 0) {
|
|
return;
|
|
}
|
|
int lower = cells[0].value;
|
|
int upper = cells[0].value;
|
|
unsigned low_position = cells[0].position;
|
|
unsigned high_position = cells[0].position;
|
|
for (size_t index = 1; index < size; ++index) {
|
|
int value = cells[index].value;
|
|
if (value < lower) {
|
|
lower = value;
|
|
low_position = cells[index].position;
|
|
}
|
|
if (value > upper) {
|
|
upper = value;
|
|
high_position = cells[index].position;
|
|
}
|
|
}
|
|
report->v[7] = lower;
|
|
report->v[8] = upper;
|
|
report->v[9] = low_position;
|
|
report->v[10] = high_position;
|
|
}
|
|
|
|
static void signs(const ra_cell *cells, size_t size, ra_report *report)
|
|
{
|
|
long long negative = 0;
|
|
long long positive = 0;
|
|
long long zero = 0;
|
|
for (size_t index = 0; index < size; ++index) {
|
|
int value = cells[index].value;
|
|
if (value < 0) {
|
|
negative += 1;
|
|
} else if (value > 0) {
|
|
positive += 1;
|
|
} else {
|
|
zero += 1;
|
|
}
|
|
}
|
|
report->v[11] = negative;
|
|
report->v[12] = zero;
|
|
report->v[13] = positive;
|
|
}
|
|
|
|
static void parity(const ra_cell *cells, size_t size, ra_report *report)
|
|
{
|
|
long long even = 0;
|
|
long long odd = 0;
|
|
for (size_t index = 0; index < size; ++index) {
|
|
if (cells[index].value % 2 == 0) {
|
|
even += cells[index].value;
|
|
} else {
|
|
odd += cells[index].value;
|
|
}
|
|
}
|
|
report->v[14] = even;
|
|
report->v[15] = odd;
|
|
}
|
|
|
|
static size_t increasing_run(const ra_cell *cells, size_t size)
|
|
{
|
|
size_t best = size == 0 ? 0 : 1;
|
|
size_t current = best;
|
|
for (size_t index = 1; index < size; ++index) {
|
|
if (cells[index].value >= cells[index - 1].value) {
|
|
current += 1;
|
|
} else {
|
|
current = 1;
|
|
}
|
|
if (current > best) {
|
|
best = current;
|
|
}
|
|
}
|
|
return best;
|
|
}
|
|
|
|
static size_t decreasing_run(const ra_cell *cells, size_t size)
|
|
{
|
|
size_t best = size == 0 ? 0 : 1;
|
|
size_t current = best;
|
|
for (size_t index = 1; index < size; ++index) {
|
|
if (cells[index].value <= cells[index - 1].value) {
|
|
current += 1;
|
|
} else {
|
|
current = 1;
|
|
}
|
|
if (current > best) {
|
|
best = current;
|
|
}
|
|
}
|
|
return best;
|
|
}
|
|
|
|
static long long variation(const ra_cell *cells, size_t size)
|
|
{
|
|
long long result = 0;
|
|
for (size_t index = 1; index < size; ++index) {
|
|
long long delta = (long long)cells[index].value - cells[index - 1].value;
|
|
result += delta < 0 ? -delta : delta;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static void windows(const ra_request *request, const ra_cell *cells,
|
|
size_t size, ra_report *report)
|
|
{
|
|
size_t width = (size_t)request->window;
|
|
if (size == 0) {
|
|
return;
|
|
}
|
|
if (width > size) {
|
|
width = size;
|
|
}
|
|
long long current = 0;
|
|
for (size_t index = 0; index < width; ++index) {
|
|
current += cells[index].value;
|
|
}
|
|
long long best = current;
|
|
size_t first = 0;
|
|
for (size_t index = width; index < size; ++index) {
|
|
current += cells[index].value;
|
|
current -= cells[index - width].value;
|
|
if (current > best) {
|
|
best = current;
|
|
first = index - width + 1;
|
|
}
|
|
}
|
|
report->v[19] = best;
|
|
report->v[20] = (long long)first;
|
|
}
|
|
|
|
static long long best_segment(const ra_cell *cells, size_t size)
|
|
{
|
|
if (size == 0) {
|
|
return 0;
|
|
}
|
|
long long current = cells[0].value;
|
|
long long best = current;
|
|
for (size_t index = 1; index < size; ++index) {
|
|
long long value = cells[index].value;
|
|
if (current < 0) {
|
|
current = value;
|
|
} else {
|
|
current += value;
|
|
}
|
|
if (current > best) {
|
|
best = current;
|
|
}
|
|
}
|
|
return best;
|
|
}
|
|
|
|
static long long checksum(const ra_cell *cells, size_t size)
|
|
{
|
|
uint32_t result = UINT32_C(2166136261);
|
|
for (size_t index = 0; index < size; ++index) {
|
|
result ^= (uint32_t)cells[index].value;
|
|
result *= UINT32_C(16777619);
|
|
result ^= cells[index].position;
|
|
result *= UINT32_C(16777619);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void ra_analyse(const ra_request *request, const ra_cell *cells,
|
|
size_t size, ra_report *report)
|
|
{
|
|
report->v[3] = total(cells, size);
|
|
report->v[4] = absolute_total(cells, size);
|
|
report->v[5] = square_total(cells, size);
|
|
report->v[6] = position_total(cells, size);
|
|
extremes(cells, size, report);
|
|
signs(cells, size, report);
|
|
parity(cells, size, report);
|
|
report->v[16] = (long long)increasing_run(cells, size);
|
|
report->v[17] = (long long)decreasing_run(cells, size);
|
|
report->v[18] = variation(cells, size);
|
|
windows(request, cells, size, report);
|
|
report->v[21] = best_segment(cells, size);
|
|
report->v[22] = checksum(cells, size);
|
|
}
|