Potwierdzam

Jest też ta opcja, że wysyłamy zgłoszenie, ale chwilę potem orientujemy się, że na pewno jest złe i nie ma sensu go odsłaniać – dzięki temu mamy nieco szersze pole manewru :)

Podmianka w generatorze:
>>>
uint32_t state;
uint32_t xorshift(){
state ^= state >> 7;
state ^= state << 9;
state ^= state >> 13;
return state;
}
int random_int(int a, int b) { return a + xorshift() % (b - a + 1); }
<<<
i wczytujemy w mainie zmienną state zamiast seed. Skrypt testujący (./script.sh <sciezka do rozwiazania>):
>>>
> output
for i in {1..100}
do
echo "TEST $i"
echo "$i 10 2 300 1000000" | ./generator >input
$1 <input >>output
done
cat output | tr -d " \t\n\r" | md5sum
<<<
Mi wyszło 256c83900ca0efe678687e79ba073983

Mogłoby, ale pewnie jest część uczestników, która lubi ten dreszczyk emocji oczekiwania na ostateczne wyniki po północy i dlatego nie jest to włączone z automatu :)
Wydaje mi się też, że organizatorzy po prostu testują tę funkcjonalność i stąd takie a nie inne jej działanie.

Potwierdzam.

Trochę jest to dla mnie niejasne - odsłonić można każde swoje zgłoszenie, więc właściwie równie dobrze mogłoby się odsłaniać samo, tak?

Ciekawe testy, potwierdzam poprawność.

Potwierdzam

Potwierdzam obie paki. Moja sprawdzaczka wygląda tak (plik Makefile, \t to tabulator):

------8<------
TARGET = $(basename $(wildcard *.cpp))

.PHONY: all clean test check %.check

all: $(TARGET)

%: %.cpp
\tg++ -std=c++17 -static -O3 $< -lm -Wall -o $@

clean:
\t-rm $(TARGET)

test: $(addsuffix .out,$(basename $(shell ls -v *.in 2>/dev/null)))

%.out: %.in $(TARGET)
\t./$(TARGET) < $< > $@

check: $(addsuffix .check,$(basename $(shell ls -v *.out 2>/dev/null)))

%.check: %.in $(TARGET)
\t./$(TARGET) < $< | diff - $(addsuffix .out,$(basename $@)) || true

time: $(addsuffix .time,$(basename $(shell ls -v *.in 2>/dev/null)))

%.time: %.in $(TARGET)
#\ttime -f%U ./$(TARGET) < $< > /dev/null
\tsh -c "time ./$(TARGET) < $< > /dev/null" 2>&1 | grep user

%.in: %
\t./$< > $@
------8<------

Uruchamianie:
make # kompilacja
make clean # usunięcie skompilowanych programów
make check # sprawdzenie testów (uruchomienie dla *.in i porównanie wyników z *.out)
make test # utworzenie wyników *.out na podstawie *.in
make time # test wydajnościowy (zmierzenie czasów wykonania dla wszystkich *.in)

potwierdzam

Potwierdzam

To ja też wrzucę swoją sprawdzaczkę do testów:

#!/bin/bash
PROG_OUT=out

if [ $# == 0 ] ; then
echo "using: $0 PROG [PROG_test]"
exit
fi
if [ $# == 1 ] ; then
PROG=$1
FILES="${PROG}_test"
else
PROG=$1
FILES=$2
fi

echo "Program name: $PROG"
echo "Test folder: $FILES"
echo "Processing..."

let good=0
let bad=0

FILES="${FILES}/*.in"

for INPUT in $FILES
do
OUTPUT=${INPUT/%.in/.out}

./$PROG < $INPUT > $PROG_OUT
if diff $OUTPUT $PROG_OUT --ignore-trailing-space --ignore-space-change &>/dev/null ; then
let good++
else
let bad++
echo "błąd: $INPUT"
fi
done

echo "Test passed: $good"
echo "Test failed: $bad"

To ja też potwierdzam :)

Potwierdzam

Potwierdzam obydwie paczki