>>46870

>Math.min.apply, Math.max.apply

Была такая мысль. Ну вот челик с Хотару (кстати, из-за неё думал, что это ты) сделал через reduce, мой вариант тоже делает всё в один проход.

>>46863
https://ideone.com/DS9Kez
Указатели — прекрасная штука, хотя и очень опасная и мешает оптимизации компилятора (см. ниже).

Оперативная память как бы побайтово занумерована от 0 до 2^{битность}−1. Если int занимает 4 байта, то переменная
int x;
может лежать, например, в байтах 1000–1003. Номер первого байта — 1000 — называется её адресом.

Разыменование указателя оператором «звёздочка слева» (^＊) выполняет доступ по данному адресу. Это может быть как чтение, так и запись.
Например, ^＊((int^＊)1000) = 25 — интерпретирует 1000 как указатель на int и записывает по нему int(25), то есть в байты 1000–1003.
(Обычно с указателями не работают как с числами, но я сделаю это для наглядности.)

Адрес переменной можно спросить оператором &.
В C++ определён целый тип uintptr_t, гарантированно вмещающий значение указателя.
Так, мы можем увидеть численное значение указателя — тот самый номер байта в памяти, явно приведя указатель к uintptr_t:
cout << (uintptr_t)&x;

Вот такая структура:
struct ivec3 { int x, y, z; }
ivec3 v;
займёт 12 байт — XXXXYYYYZZZZ.

Отсюда, если мы прибавим 4 к численному адресу v, интерпретируем результат как указатель на int и что-нибудь по нему запишем — мы изменим v.y:
^＊(int^＊)((uintptr_t)&v + 4) = 22;
— эквивалентно v.y = 22.
Конечно, адрес v.y можно спросить и по-человечески: &v.y.

Среди прочего указатели позволяют имитировать out-параметры функций. Например, функция
void get_last_digit(int x, int^＊ ld) { ^＊ld = x % 10; }
записывает по указателю ld последнюю десятичную цифру x:
int x;
get_last_digit(125, &x);
cout << x; // 5

Указатель на тип можно интерпретировать как (указатель на) массив значений этого типа: например,
int xs_storage[] = {1, 2, 3};
int^＊ xs = &xs_storage[0];
— сам по себе указывает на int(3), но за ним в памяти лежат int(5) и int(91):
333355559191
и к элементам можно обратиться как xs[0], xs[1], xs[2].
Или вот char^＊ часто интерпретируется как указатель на строку-массив символов, длина которой определяется договорённостью извне, будь то заключительный '\0' или явная size_t length.

К указателю можно прибавить (или вычесть) число. Это сдвинет его не побайтово, а поэлементно: xs + 2 эквивалентно (int^＊)((uintptr_t)xs + 2×4), где 4 — размер подлежащего типа (int).
То есть xs указывает на 3, xs + 1 — на 5, xs + 2 — на 91.
Через это и работают массивы; код xs[1] = 6 эквивалентен ^＊(xs + 1) = 6, и вообще int[] эквивалентен int^＊ вплоть до совместимости по присваиванию: вместо xs = &xs_storage[0] можно было прямо написать xs = xs_storage.

Также можно вычесть два указателя одного типа, получив, опять же, не побайтовую разность между ними, а поэлементную:
&xs[2] − &xs[0] == 2.
Вся эта арифметика указателей поддерживается только для случая, когда элементы реально лежат в памяти одним сплошным массивом. (Иначе она как бы и смысла не имеет: взаимное положение в памяти разных переменных, не объединённых в структуру или массив, не определено.)

Так, в своём решении выше я использовал char^＊ вместо индексов для навигации по строке: начало текущего слова запоминается в XXX_start, а по окончании слова (встрече пробела или конца строки) его длина восстанавливается как разность указателей sp − XXX_start.

malloc/new и free/delete позволяют выделять и освобождать блоки памяти динамически, опять же, идентифицируя их указателями на начало.

>мешают оптимизации компилятора

Существование указателей означает, что с момента, когда на что-то взят адрес, оно потенциально может измениться извне в любой момент.
Поэтому, например, компилятор не имеет права соптимизировать функцию
void add(int^＊ a, int^＊ b)
{
　　^＊a += ^＊b;
　　^＊a += ＊b;
}
до ＊a += 2×＊b: это выражение даст другой результат, если указатели ＊a и ＊b указывают на одну и ту же переменную.

Кроме того, хотя вся эта модная арифметика позволяет не думать о байтах, этого недостаточно: работа с указателями очень ошибкоопасна.

Если, скажем, на самом деле в «массиве», на который указывает xs, только один элемент, а мы обращаемся к xs[9] — программа, в лучшем случае, упадёт, в среднем и худшем — не упадёт, а тихо прочитает неизвестно что неизвестно откуда / запишет неизвестно что неизвестно куда, и эта ошибка проявится далеко от места своего возникновения. То же самое произойдёт, если переменная, на которую указывает xs, уничтожена — в частности, для new'нутого объекта уже выполнена delete.

Поэтому часто вместо голых указателей используются, для массивов — контейнеры (vector/array), для динамически выделяемых переменных — указатели с подсчётом ссылок (shared_ptr). Контейнеры в отладочных билдах проверяют обращения вне диапазона; подсчёт ссылок гарантирует, что объект будет существовать, пока существуют ссылки на него, и, наоборот, автоматически delete'ает объект по исчезновении последней ссылки.