бери просто https://doc.rust-lang.org/std/io/trait.Read.html#tymethod.read
с буфером же полюбому будет быстрее
Anonymous
分解物質
сделай вектор что-бы в него сразу весь ввод поместился и за один read его заполни
потом простым циклом по нему пройтись и всё что нужно сделай
分解物質
分解物質
сделай вектор что-бы в него сразу весь ввод поместился и за один read его заполни
потом простым циклом по нему пройтись и всё что нужно сделай
и за одну итерацию в цикле не по одному байту обробатывать а сразу всю строку
Anonymous
сделай вектор что-бы в него сразу весь ввод поместился и за один read его заполни
потом простым циклом по нему пройтись и всё что нужно сделай
но ведь эффективнее при чтении разделять
Anonymous
потому что для алгоритма нужно разделение
Anonymous
чем сначала весь ввод куда-то ложить
分解物質
под "при чтении разделять" ты имеешь в виду readv?
分解物質
или BufReader?
Anonymous
нет
Anonymous
посмотри на оригинальный код
Anonymous
нам нужно часть до пробела положить в один массив
Anonymous
а после пробела в другой
分解物質
один сискол с io в 10000 раз дороже чем перемещение пяти байтов
分解物質
поэтому тут быстрее забрать всё за один сискол а потом циклом всё разфасовать
Anonymous
тогда bufreader вообще не нужен?
分解物質
или BufReader?
а в случае с BufReader:
он читает по некоторому чанку свой буффер
отдает отдельно каждый байт из своего буфера тебе
ты по одному байту записывешь в свой буфер acc
потом из acc копируешь в suf и pre
Anonymous
м
Anonymous
а дальше как эффективнее всего траверсить массив?
分解物質
итерировать по шесть байтов копируя пять
分解物質
дальше llvm всё схватит
分解物質
объеденить копирование по байтам в копирование по нескольку байтам за раз и правельно развернуть цикл его работа в которой он (должен быть) умнее смертных
Anonymous
бля, чет непонятно как итерировать по количеству байтов
Anonymous
без лишних переменных
分解物質
int8 src[120000], pre[50000], suf[50000];
int8 *p = pre, *s = suf;
for (i = 0; i < 120000;) {
*p++ = src[i++];
*p++ = src[i++];
*p++ = src[i++];
*p++ = src[i++];
*p++ = src[i++];
i++;
*s++ = src[i++];
*s++ = src[i++];
*s++ = src[i++];
*s++ = src[i++];
*s++ = src[i++];
i++;
}
Anonymous
лол
andrei
Alex
分解物質
меня попросили самый эффективный способ
Anonymous
int8 src[120000], pre[50000], suf[50000];
int8 *p = pre, *s = suf;
for (i = 0; i < 120000;) {
*p++ = src[i++];
*p++ = src[i++];
*p++ = src[i++];
*p++ = src[i++];
*p++ = src[i++];
i++;
*s++ = src[i++];
*s++ = src[i++];
*s++ = src[i++];
*s++ = src[i++];
*s++ = src[i++];
i++;
}
а разве у нас не будет начинаться со второго элемента массив
Anonymous
с таким кодом
Loyd
нет
Loyd
А что за магия с промежуточным "i++"?
分解物質
int8 src[120000], pre[50000], suf[50000];
int8 *p = pre, *s = suf;
for (i = 0; i < 120000;) {
*p++ = src[i++];
*p++ = src[i++];
*p++ = src[i++];
*p++ = src[i++];
*p++ = src[i++];
i++;
*s++ = src[i++];
*s++ = src[i++];
*s++ = src[i++];
*s++ = src[i++];
*s++ = src[i++];
i++;
}
int8 src[120000], pre[50000], suf[50000];
int8 *p = pre, *s = suf;
for (i = 0; i < 120000;) {
for (int n = 5; n--;)
*p++ = src[i++];
i++;
for (int n = 5; n--;)
*s++ = src[i++];
i++;
}
分解物質
А что за магия с промежуточным "i++"?
там в одном случае пробел, во втором '\n'
их нужно пропустить
Anonymous
м, а потом тоже собрать в массив перед принтом?
分解物質
они уже в массиве
Anonymous
ну
Anonymous
а нам нужен другой результат в stdout
Anonymous
вот я и спрашиваю, эффективнее ли один массив запилить и отправить в stdout или по нужде отправлять
分解物質
м, а потом тоже собрать в массив перед принтом?
просто принтить участки pre и suf в нужном порядке
Anonymous
но ведь
Anonymous
один сискол с io в 10000 раз дороже чем перемещение пяти байтов
分解物質
ну можно так
分解物質
просто принтить участки pre и suf в нужном порядке
только тогда зачем вообще их было фасовать по разным массивам
Anonymous
я делаю все по твоим советам
Anonymous
😫
分解物質
ты спрашивал не как задачу целиком оптимально сделать а как разделить по массивам
分解物質
там время выполнения программы проверять будут?
Anonymous
да
Anonymous
ориг код медленнее хаскеля
Anonymous
чет надоело байтоебить
分解物質
char buf[10000][2][6];
int main() {
read(0, buf, sizeof buf);
for (int i = 0; i < 10000; i++) {
for (int j = 0; j < 10000; j++) {
write(1, buf[i][0], 5);
write(1, buf[j][1], 6);
}
}
}
Anonymous
лол
Anonymous
перепиши на раст
Anonymous
кстати фигня
分解物質
fn main() {
let buf[u8; 12000];
stdin().read(&buf);
for i in 0..10000 {
for j in 0..10000 {
stdout().write(&buf[i*12..i*12+5]);
stdout().write(&buf[j*12+6..j*12+12]);
}
}
}
наверно так
Anonymous
./memes < ./meme/a > /dev/null 4.03s user 16.72s system 99% cpu 20.807 total
Anonymous
chrono ~/meme ‹master*› » time ./target/release/meme < ./a > /dev/null
./target/release/meme < ./a > /dev/null 2.30s user 0.02s system 99% cpu 2.334 total
分解物質
./memes < ./meme/a > /dev/null 4.03s user 16.72s system 99% cpu 20.807 total
значит буфферизировать вывод
Anonymous
можешь сделать?
Anonymous
分解物質
для C?
Anonymous
да
Anonymous
Ofast же лучше O3?
分解物質
char buf[10000][2][6];
int main() {
read(0, buf, sizeof buf);
for (int i = 0; i < 10000; i++) {
for (int j = 0; j < 10000; j++) {
write(1, buf[i][0], 5);
write(1, buf[j][1], 6);
}
}
}
#include <stdio.h>
char buf[10000][2][6];
int main() {
fread(buf, sizeof buf, 1, stdin);
for (int i = 0; i < 10000; i++) {
for (int j = 0; j < 10000; j++) {
fwrite(buf[i][0], 5, 1, stdout);
fwrite(buf[j][1], 6, 1, stdout);
}
}
}
Anonymous
о