Программа Для Определения Выпадения Красного И Белого Казино
Русские придумали гениальный способ обманывать игровые автоматы, от которого казино не могут защититься
В начале июля года бухгалтера из казино Люмьер Плейс [Lumiere Place] в Сент-Луисе обнаружили, что несколько их игровых автоматов сошли с ума на пару дней. Программное обеспечение, одобренное правительством, даёт автоматам фиксированную фору математическими методами, так, чтобы казино были уверены в том, сколько они заработают в долгосрочной перспективе – допустим, 7, центов на каждом долларе. Но 2 и 3 июля несколько автоматов из казино Люмьер выдали гораздо больше денег, чем приняли, несмотря на отсутствие каких-то особенных джекпотов. Такое отклонение на жаргоне индустрии называется отрицательным удержанием. И поскольку ПО не подвержено приступам безумия, единственным объяснением было то, что кто-то жульничает.
Охрана казино подняла архивы видеонаблюдения и обнаружила виновника, тёмноволосого мужчину 30 с чем-то лет в рубашке-поло на молнии с коричневой прямоугольной сумкой. В отличие от большинства мошенников, он вроде бы никак не воздействовал на выбранные им автоматы. Он выбирал только старые модели, изготовленные австралийской компанией Aristocrat Leisure. Он просто играл, нажимая на кнопки игр типа Star Drifter или Pelican Pete, украдкой держа при этом свой iPhone ближе к экрану.
Через несколько минут он отходил от автомата, затем возвращался вновь, чтобы попробовать ещё раз. И тогда ему везло. Он ставил от $20 до $60 и выигрывал порядка $, затем обналичивал выигрыш и переходил к следующей машине, где начинал всё заново. За пару дней он выиграл порядка $ Единственное, что показалось странным в его поведении, это то, как он держал палец над кнопкой «Spin» довольно долгие промежутки времени, а затем резко клацал по ней. Обычные игроки не делают таких пауз между играми.
9 июня Люмьер Плейс поделилась находками с Комиссией азартных игр Миссури, выпустившей предупреждение по всему штату. После этого несколько казино обнаружили, что их обманули точно так же, хотя в некоторых случаях у них играли другие люди. В каждом случае злоумышленник держал мобильник поближе к автомату Aristocrat модели Mark VI незадолго до того, как ему начинало везти.
Изучив данные автопроката, власти Миссури идентифицировали мошенника из Люмьер Плейс как Мурата Блиева [Murat Bliev], летнего русского. Блиев вернулся в Москву 6 июня, но организация, базирующаяся в Санкт-Петербурге, распределяющая десятки своих оперативников для манипулирования игровыми автоматами по всему миру, быстро отправила его обратно в США для работы с другой командой. Решение о повторной отправке Блиева в США станет редкой ошибкой организации, по-тихому зарабатывающей миллионы на взломах самых ценных для игровой индустрии алгоритмов.
Из России с обманом
Россия стала очагом преступлений, связанных с игровыми автоматами, с года, когда в стране практически запретили азартные игры. Владимир Путин, бывший тогда на посту премьер-министра, как говорят, считал, что этот шаг уменьшит возможности грузинской организованной преступности. Из-за запрета всем казино пришлось распродавать автоматы с большими скидками любым покупателям, которых они могли найти. Некоторые из этих автоматов оказались в руках мошенников, хотевших узнать, как загружать новые игры на старые платы. Некоторые, очевидно, попали к хозяевам Мурата Блиева в Санкт-Петербурге, желающим исследовать исходный код машин на уязвимости.
К году казино в центральной и восточной Европе начали регистрировать инциденты, в которых автоматы австрийской компании Novomatic выдавали невероятно большие суммы. Инженеры Novomatic не смогли найти доказательств того, что с их машинами что-то сделали, и они решили, что мошенники придумали, как предсказывать поведение автоматов. «Путём целенаправленного долговременного наблюдения за ходом отдельных игр, а также, вероятно, записями отдельных игр, возможно определить некие „закономерности“ в выпадении игровых результатов», – сообщила компания своим клиентам в феврале
Распознавание этих последовательностей требует больших затрат. Результаты игр автоматов контролируются генераторами псевдослучайных чисел (ГПЧ), которые должны выдавать непредсказуемые значения. Правительственные регуляторы подтверждают работоспособность каждого алгоритма до того, как казино смогут его применять.
Но приставка «псевдо» как бы намекает на не совсем полноценную случайность чисел. Поскольку люди создают их при помощи инструкций в коде, ГПЧ остаются немного детерминированными. Генератор по-настоящему случайных чисел нужно задействовать вместе с каким-либо явлением, не созданным человеком – например, с радиоактивным распадом. ГПЧ берёт начальное число, и проводит его через различные функции, смешивая с такими переменными, как машинное время компьютера – чтобы выдать результат, на первый взгляд непредсказуемый. Но если хакеры смогут определить ингредиенты этой математической похлёбки, они потенциально способны и предсказать вывод ГПЧ. Процесс реверс-инжиниринга становится легче, когда у хакера есть доступ к внутренностям слот-машины.
Но просто разобраться с тайной арифметикой, используемой автоматом для генерации псевдослучайных чисел – это ещё полдела. Входные данные ГПЧ зависят от временного состояния автомата. Начальные значения в разное время разные, поскольку данные поступают из внутренних часов. Так что, даже если понимать работу ГПЧ автомата, хакерам необходимо проанализировать его игру, чтобы вычислить закономерности. Это требует времени и компьютерных мощностей, а работать на своём ноутбуке в казино – прекрасный способ привлечь внимание охраны.
Обман в Люмьер Плейс показал, как Мурат Блиев и его сообщники обошли это препятствие. Узнав, что случилось в Миссури, эксперт по безопасности казино Даррин Хоук, бывший тогда директором службы наблюдения в казино Ляберже дю ла касино резорт в Лейк-Чарльз, штат Луизиана, решил провести расследование масштаба операции взлома. Поговорив с коллегами, сообщавшими о странном поведении автоматов и проанализировав фотографии с камер наблюдения, он выявил 25 потенциальных оперативников, работавших в казино по всему миру, от Калифорнии до Румынии и Макао. Хоук изучил записи регистрационных книг отелей и узнал, что два сообщника Блиева из Сент-Луиса остались в США и отправились на запад в Печанга ресорт касино в городе Темекула в Калифорнии. 14 июля года агенты министерства юстиции калифорнии задержали одного из оперативников в Печанга и изъяли у него четыре мобильника и сумму в $ Обвинения задержанному гражданину России предъявлены не были, и его текущее местонахождение неизвестно.
Мобильники из Печанга вместе с данными расследований в Миссури и в Европе выдали ключевые детали дела. Согласно консультанту по безопасности из казино Лас-Вегаса, Вилли Эллисону, отслеживавшему российских хакеров несколько лет, оперативники используют телефоны для записи пары десятков прогонов той игры, которую они хотят обмануть. Они загружают видео техникам в Санкт-Петербурге, анализирующим видео и подсчитывающим закономерности на основе данных по работе ГПЧ этой модели автомата. Наконец, команда из Санкт-Петербурга передаёт список временных маркеров для специально написанного приложения на телефоне оперативника. Маркеры за четверть секунды до того, как оперативник должен нажать кнопку, передают ему сигнал через вибрацию телефона.
«Скорость реакции человека составляет порядка четверти секунды, поэтому так всё и настроено», – говорит Эллисон, основатель ежегодной международной конференции по защите игр. Временные маркеры не всегда верны, но результатов можно добиться гораздо больше, чем обычно. Отдельные мошенники выигрывают более $ в день. Эллисон отмечает, что оперативники стараются, чтобы выигрыш с одного автомата не превышал $, чтобы не привлекать внимания. Команда из четырёх человек, работая в разных казино, может заработать до $ в неделю.
Многоразовый бизнес
Поскольку автоматов в родной стране Мурата Блиева нет, он не задержался в России, вернувшись из Сент-Луиса. Он ещё дважды летал в США в году, и второй визит начался 3 декабря. Из аэропорта он сразу направился в Сент-Чарльз, где встретился с тремя другими людьми, натренированными обманывать игровые автоматы Mark VI Aristocrat: Иваном Гудаловым, Игорем Лареновым и Евгением Назаровым. Квартет планировал провести следующие несколько дней в атаках на разные казино Миссури и западного Иллинойса.
Блиеву не нужно было возвращаться. 10 декабря, вскоре после того, как его заметили в Казино Голливуд в Сент-Луисе, четырёх мошенников арестовали. Поскольку Блиев с сообщниками работали в нескольких штатах, федеральные власти обвинили их в мошенничестве. Официальные обвинения стали первым серьёзным препятствием в работе Санкт-Петербургской организации. До этого ещё ни одного их оперативника не подвергали суду.
Блиев, Гуданов и Ларенов, граждане России, договорились со следствием и были приговорены к двум годам лишения свободы с последующей депортацией. Назаров, гражданин Казахстана, получивший в США убежище на религиозной почве в году, и теперь являющийся резидентом Флориды, всё ещё ожидает приговора – а значит, сотрудничает с властями. Представители Aristocrat отмечают, что одному из четырёх обвиняемых пока не вынесли приговор, поскольку он «продолжает помогать ФБР в их расследовании».
Информация, которую предоставляет Назаров, может быть безнадёжно устаревшей. Через два года после арестов оперативники из Санкт-Петербургской организации стали более осторожными. Некоторые уловки были вскрыты в прошлом году, когда сингапурские власти поймали и осудили команду: один из её членов, чешский гражданин Радослав Скубник, выдал детали финансовой структуры организации (90% дохода идёт в Санкт-Петербург) и тактику действий. «Они сейчас кладут мобильник в нагрудный карман, и прячут его за сеткой, чтобы его не нужно было держать в руках», – говорит Эллисон. Даррин Хоук говорит, что получал сообщения о передаче видео в Россию через Skype, так что им не нужно отходить от автоматов, чтобы загрузить видео.
Судя по всему, мошенников осудили всего в двух случаях, в Миссури и в Сингапуре, но некоторых также ловили и выдворяли из отдельных казино. Организация из Санкт-Петербурга отправляет своих оперативников всё дальше. В последние месяцы не менее трёх казино в Перу сообщили, что были обмануты русскими игроками, игравшими за старыми автоматами Novomatic Coolfire.
Экономическая реальность игровой индустрии такова, что организация из Петербурга гарантированно будет процветать и далее. Нет простого способа исправить игровые автоматы. Как говорит Хоук, производителям Aristocrat, Novomatic, и всем остальным, чьи ГПЧ подверглись взлому, придётся «отозвать все автоматы и заменить их на что-то другое, а они этим заниматься не будут». Aristocrat заявила, что не смогла «обнаружить дефекты в играх, подвергшихся атаке», и что автоматы «построены и одобрены согласно строгим техническим стандартам». В то же время, большинство казино не могут себе позволить покупать обновлённые игровые автоматы, использующие шифрование ГПЧ для защиты математических секретов. И пока старые, взломанные автоматы, всё ещё пользуются у клиентов популярностью, казино будет выгоднее использовать их и далее, принимая периодические потери в пользу мошенников.
Так что, службам безопасности казино остаётся следить за косвенными признаками мошенничества. Палец, слишком надолго зависший над кнопкой, может стать единственным признаком того, что хакеры из Санкт-Петербурга готовятся к очередному выигрышу.
Решение для 10 Мбайт памяти
Можно найти отсутствующее число, воспользовавшись двойным проходом по данным. Давайте разделим целые числа на блоки некоторого размера (мы еще обсудим, как правильно выбрать размер). Пока предположим, что мы используем блоки размером чисел. Так, blоск0 соответствует числам от 0 до , block1 — — и т.д.
Нам известно, сколько значений может находиться в каждом блоке. Теперь мы анализируем файл и подсчитываем, сколько значений находится в указанном диапазоне: , и т.д. Если в диапазоне оказалось значений, то «дефектный» интервал найден.
На втором проходе мы будем искать в этом диапазоне отсутствующее число. Можно воспользоваться идеей битового вектора, рассмотренного в первой части задачи. Нам ведь не нужны числа, не входящие в конкретный диапазон.
Как же выбрать размер блока? Давайте введем несколько переменных:
Пусть rangeSize — размер диапазонов каждого блока на первом проходе.
Пусть arraySize — число блоков при первом проходе. Обратите внимание, что arraySize = 232/rangeSize.
Нам нужно выбрать значение rangeSize так, чтобы памяти хватило и на первый (массив) и на второй (битовый вектор) проходы.
Первый проход: массив
Массив на первом проходе может вместить 10 Мбайт, или 223 байт, памяти. Поскольку каждый элемент в массиве относится к типу int, а переменная типа int занимает 4 байта, мы можем хранить примерно 221 элементов.
Второй проход: битовый вектор
Нам нужно место, чтобы хранить rangeSize бит. Поскольку в память помещается 223 байт, мы сможем поместить 226 бит в памяти. Таким образом:
Мы получаем достаточно пространства для «маневра», но чем ближе к середине, которую мы выбираем, тем меньше памяти будет использоваться в любой момент времени.
Нижеприведенный код предоставляет одну реализацию для этого алгоритма:
int bitsize = ; // 2^20 bits (2^17 bytes) int blockNum = ; // 2^12 byte[] bitfield = new byte[bitsize/8]; int[] blocks = new int[blockNum]; void findOpenNumber() throws FileNotFoundException { int starting = -1; Scanner in = new Scanner (new FileReader ("goalma.org")); while (goalma.orgtInt()) { int n = goalma.orgt(); blocks[n / (goalma.org * 8)]++; } for (int i = 0; i < goalma.org; i++) { if (blocks[i] < goalma.org * 8) { /* если значение < 2^20, то отсутствует как минимум 1 число * в этой секции. */ starting = i * goalma.org * 8; break; } } in = new Scanner(new FileReader("input_goalma.org")); while (goalma.orgtInt()) { int n = goalma.orgt(); /* Если число внутри блока, в котором отсутствуют числа, * мы записываем его */ if (n >= starting && n < starting + goalma.org * 8) { bitfield[(n - starting) / 8]Introduction
Readymade godard brooklyn, kogi shoreditch hashtag hella shaman kitsch man bun pinterest flexitarian. Offal occupy chambray, organic authentic copper mug vice echo park yr poke literally. Ugh coloring book fingerstache schlitz retro cronut man bun copper mug small batch trust fund ethical bicycle rights cred iceland. Celiac schlitz la croix 3 wolf moon butcher. Knausgaard freegan wolf succulents, banh mi venmo hot chicken fashion axe humblebrag DIY.
Waistcoat gluten-free cronut cred quinoa. Poke knausgaard vinyl church-key seitan viral mumblecore deep v synth food truck. Ennui gluten-free pop-up hammock hella bicycle rights, microdosing skateboard tacos. Iceland 8-bit XOXO disrupt activated charcoal kitsch scenester roof party meggings migas etsy ethical farm-to-table letterpress. Banjo wayfarers chartreuse taiyaki, stumptown prism 8-bit tote bag.
Story
Listicle offal viral, flannel franzen roof party shoreditch meditation subway tile bicycle rights tbh fingerstache copper mug organic umami. Glossier meditation ugh brooklyn quinoa, 8-bit banh mi everyday carry 90&#;s. Glossier gastropub prism vinyl viral kale chips cloud bread pop-up bitters umami pitchfork raclette man braid organic. Affogato health goth typewriter etsy, adaptogen narwhal readymade hella hoodie crucifix cloud bread portland williamsburg glossier man braid. Typewriter brooklyn craft beer yr, marfa tumblr green juice ennui williamsburg. Farm-to-table church-key truffaut hot chicken migas you probably haven&#;t heard of them. Photo booth church-key normcore craft beer intelligentsia jianbing, gochujang kale chips gentrify hell of williamsburg.
Conclusion
Venmo fixie knausgaard readymade. 3 wolf moon blue bottle sartorial blog. Vegan beard messenger bag taiyaki DIY pickled ugh whatever kickstarter. Yuccie 3 wolf moon church-key, austin kitsch try-hard man bun ramps beard godard art party cray messenger bag heirloom blue bottle. Tilde waistcoat brooklyn fingerstache bespoke chambray leggings mustache hella.
Разбор взят из перевода книги Г. Лакман Макдауэлл и предназначен исключительно для ознакомления
Оригинал статьи.
Допустим, вы пишете конвейер, в котором 2 потока, используя общий буфер, обрабатывают данные. Поток-producer эти данные создает, а поток-consumer их обрабатывает (Producer–consumer problem). Следующий код представляет собой самую простую модель: с помощью std::thread мы порождаем поток-consumer, a создавать данные мы будем в главном потоке.
Опустим механизмы синхронизации двух потоков, и обратим внимание на функцию main(). Попробуйте догадаться, что с этим кодом не так, и как его исправить?
void produce() { // создаем задачу и кладем в очередь } void consume() { // читаем данные из очереди и обрабатываем } int main(int , char **) { std::thread thr(consume); // порождаем поток produce(); // создаем данные для обработки goalma.org(); // ждем завершения работы функции consume() return 0; }В С++, если не сказано иного, принято считать, что каждая функция может выбросить исключение.
Допустим, функция бросает исключение. Поскольку это исключение генерируется в дочернем потоке, поймать и обработать его в главном потоке нельзя1 . Если во время развертывания стека дочернего потока не нашлось подходящего обработчика исключения, будет вызвана функция , которая по-умолчанию вызовет функцию . Иными словами, если не обработать исключение в потоке, порожденном объектом , то программа завершит свою работу с ошибкой.
С функцией немного сложнее. Допустим, эта функция генерирует исключение. Первое, что хочется сделать, это обернуть тело в try-catch блок:
try { std::thread thr(consume); produce(); // бросает исключение goalma.org(); } catch () { }Кажется, что проблема решена, но если вы попытаетесь запустить этот код, то программа упадет в любом случае. Почему так происходит? Давайте разбираться.
std::thread
Как вы уже, может быть, догадались, проблема не имеет отношение к конвейеру, а относится к правильному использованию потоков выполнения стандартной библиотеки в принципе. В частности следующая обобщенная функция равнозначна, и имеет те же проблемы:
void run(function<void()> f1, function<void()> f2) { std::thread thr(f1); f2(); goalma.org(); } run(consume, produce);Прежде чем перейти к решению нашей задачи, давайте вкратце вспомним как работает.
1) Конструктор для инициализации:
template <class Fn, class Args> explicit thread (Fn&& fn, Args&& args);При инициализации объекта создается новый поток, в котором запускается функция с возможными аргументами . При успешном его создании, конкретный экземпляр объекта начинает представлять этот поток в родительском потоке, а в свойствах объекта выставляется флаг .
Запомним: ~ объект связан с потоком.
2) Ждем конца выполнения порожденного потока:
void thread::join();Этот метод блокирует дальнейшее выполнение родительского потока, до тех пока не будет завершен дочерний. После успешного выполнения, объект потока перестает его представлять, поскольку нашего потока больше не существует. Флаг сбрасывается.
3) Немедленно “отсоединяем” объект от потока:
void thread::detach();Это неблокирующий метод. Флаг сбрасывается, а дочерний поток предоставлен сам себе и завершит свою работу когда-нибудь позже.
4) Деструктор:
thread::~thread();Деструктор уничтожает объект. При этом если, у этого объекта стоит флаг , то вызывается функция , которая по умолчанию вызовет функцию .
Внимание! Если мы создали объект и поток, но не вызвали или , то программа упадет. В принципе, это логично – если объект до сих пор связан с потоком, то надо что-то с ним делать. А еще лучше – ничего не делать, и завершить программу (по крайней мере так решил комитет по стандарту).
Поэтому при возникновении исключения в функции , мы пытаемся уничтожить объект , который является .
Ограничения
Почему же стандартный комитет решил поступить так и не иначе? Не лучше было бы вызвать в деструкторе или ? Оказывается, не лучше. Давайте разберем оба этих случая.
Допустим, у нас есть класс , который так вызывает в своем деструкторе:
joining_thread::~joining_thread() { join(); }Тогда, прежде чем обработать исключение, мы должны будем подождать завершения работы дочернего потока, поскольку блокирует дальнейшее выполнение программы. А если так получилось, что порожденном потоке оказался в бесконечный цикл?
void consume() { while(1) { } } try { joining_thread thr(consume); throw std::exception(); } catch () { // может случится не скоро, или даже никогда }Хорошо, мы выяснили, что в деструкторе лучше не вызывать (до тех пор пока вы не уверены, что это корректная обработка события), поскольку это блокирующая операция. А что насчет ? Почему бы не вызвать в деструкторе этот неблокирующий метод, дав главному потоку продолжить работу? Допустим у нас есть такой класс .
Но тогда мы можем прийти к такой ситуации, когда порожденный поток пытается использовать ресурс, которого уже нет, как в следующей ситуации:
try { int data; detaching_thread th(consume, &data); // в данном случае consume принимает указатель на int в качестве аргумента throw std::exception() } catch () { // корректно обработаем исключение // consume продолжает исполняться, но ссылается на уже удаленный объект data }Таким образом, создатели стандарта решили переложить ответственность на программиста – в конце концов ему виднее, как программа должна обрабатывать подобные случаи. Исходя из всего этого, получается, что стандартная библиотека противоречит принципу RAII – при создании мы сами должны позаботиться о корректном управлении ресурсами, то есть явно вызвать или . По этой причине некоторые программисты советуют не использовать объекты std::thread. Так же как new и delete, std::thread предоставляет возможность построить на основе них более высокоуровневые инструменты.
Решение
Одним из таких инструментов является класс из библиотеки Boost . Он соответствует нашему в примере выше. Если вы можете позволить себе использовать сторонние библиотеки для работы с потоками, то лучше это сделать.
Другое решение – позаботиться об это самому в RAII-стиле, например так:
class Consumer { public: Consumer() : exit_flag(false) , thr( &Consumer::run, this ) { // после создания потока не делайте тут ничего, что бросает исключение, // поскольку в этом случае не будет вызван деструктор объекта Consumer, // поток не будет завершен, а программа упадет } ~Consumer() { exit_flag = true; // говорим потоку остановиться goalma.org(); } private: std::atomic<bool> exit_flag; // флаг для синхронизации (опционально) std::thread thr; void run() { while (!exit_flag) { // делаем что-нибудь } } };В случае, если вы собираетесь отделить поток от объекта в любом случае, лучше сделать это сразу же:
std::thread(consume).detach(); // создаем поток, и сразу же освобождаем объект, связанный с нимСсылки:
Александр Петров специально для “Типичного программиста”.
Оригинал статьи.
Дано 20 баночек с таблетками. В 19 из них лежат таблетки весом 1 г, а в одной – весом г. Даны весы, показывающие точный вес. Как за одно взвешивание найти банку с тяжелыми таблетками?
Иногда “хитрые” ограничения могут стать подсказкой. В нашем случае подсказка спрятана в информации о том, что весы можно использовать только один раз.
У нас только одно взвешивание, а это значит, что придется одновременно взвешивать много таблеток. Фактически, мы должны одновременно взвесить 19 банок. Если мы пропустим две (или больше) банки, то не сможем их проверить. Не забывайте: только одно взвешивание!
Как же взвесить несколько банок и понять, в какой из них находятся “дефектные” таблетки? Давайте представим, что у нас есть только две банки, в одной из них лежат более тяжелые таблетки. Если взять по одной таблетке из каждой банки и взвесить их одновременно,то общий вес будет г, но при этом мы не узнаем, какая из банок дала дополнительные г. Значит, надо взвешивать как-то иначе.
Если мы возьмем одну таблетку из банки №1 и две таблетки из банки №2, то, что покажут весы? Результат зависит от веса таблеток. Если банка №1 содержит более тяжелые таблетки, то вес будет г. Если с тяжелыми таблетками банка №2 – то грамма. Подход к решению задачи найден.
Можно обобщить наш подход: возьмем одну таблетку из банки №1, две таблетки из банки №2, три таблетки из банки №3 и т.д. Взвесьте этот набор таблеток. Если все таблетки весят 1 г, то результат составит г. “Излишек” внесет банка с тяжелыми таблетками.
Таким образом, номер банки можно узнать по простой формуле: (вес – ) / Если суммарный вес таблеток составляет г, то тяжелые таблетки находились в банке №
Разбор взят из перевода книги Г. Лакман Макдауэлл и предназначен исключительно для ознакомления.
Оригинал статьи.
Дана шахматная доска размером 8×8, из которой были вырезаны два противоположных по диагонали угла, и 31 кость домино; каждая кость домино может закрыть два квадратика на поле. Можно ли вымостить костями всю доску? Дайте обоснование своему ответу.
С первого взгляда кажется, что это возможно. Доска 8?8, следовательно, есть 64 клетки, две мы исключаем, значит остается Вроде бы 31 кость должна поместиться, правильно?
Когда мы попытаемся разложить домино в первом ряду, то в нашем распоряжении только 7 квадратов, одна кость переходит на второй ряд. Затем мы размещаем домино во втором ряду, и опять одна кость переходит на третий ряд.
В каждом ряду всегда будет оставаться одна кость, которую нужно перенести на следующий ряд, не имеет значения сколько вариантов раскладки мы опробуем, у нас никогда не получится разложить все кости.
Шахматная доска делится на 32 черные и 32 белые клетки. Удаляя противоположные углы (обратите внимание, что эти клетки окрашены в один и тот же цвет), мы оставляем 30 клеток одного и 32 клетки другого цвета. Предположим, что теперь у нас есть 30 черных и 32 белых квадрата.
Каждая кость, которую мы будем класть на доску, будет занимать одну черную и одну белую клетку. Поэтому 31 кость домино займет 31 белую и 31 черную клетки. Но на нашей доске всего 30 черных и 32 белых клетки. Поэтому разложить кости невозможно.
Разбор взят из перевода книги Г. Лакман Макдауэлл и предназначен исключительно для ознакомления.
Оригинал статьи.
Дан входной файл, содержащий четыре миллиарда целых битных чисел. Предложите алгоритм, генерирующий число, отсутствующее в файле. Имеется 1 Гбайт памяти для этой задачи. Дополнительно: а что если у вас всего 10 Мбайт? Количество проходов по файлу должно быть минимальным.
В нашем распоряжении 232 (или 4 миллиарда) целых чисел. У нас есть 1 Гбайт памяти, или 8 млрд бит.
8 млрд бит — вполне достаточный объем, чтобы отобразить все целые числа. Что нужно сделать?
Создать битовый вектор с 4 миллиардами бит. Битовый вектор — это массив, хранящий в компактном виде булевы переменные (может использоваться как int, так и другой тип данных). Каждую переменную типа int можно рассматривать как 32 бита или 32 булевых значения.
Инициализировать битовый вектор нулями.
Просканировать все числа (num) из файла и вызвать .
Еще раз просканировать битовый вектор, начиная с индекса 0.
Вернуть индекс первого элемента со значением 0.
Следующий код реализует наш алгоритм:
byte[] bitfield = new byte [0xFFFFFFF/8]; void findOpenNumber2() throws FileNotFoundException { Scanner in = new Scanner(new FileReader("goalma.org")); while (goalma.orgtInt()) { int n = goalma.orgt (); /* Находим соответствующее число в bitfield, используя * оператор OR для установки n-го бита байта * (то есть 10 будет соответствовать 2-му биту индекса 2 * в массиве байтов). */ bitfield [n / 8] = 1 << ((n - starting) % 8); } } for (int i = 0 ; i < goalma.org; i++) { for (int j = 0; j < 8; j++) { /* Получаем отдельные биты каждого байта. Когда бит 0 * найден, находим соответствующее значение. */ if ((bitfield[i] & (1 << j)) == 0) { goalma.orgn(i * 8 + j + starting); return; } } } }А что если вам нужно решить задачу, используя более серьезные ограничения на использование памяти? В этом случае придется сделать несколько проходов. Сначала пройдитесь по «миллионным» блокам, потом по тысячным. Наконец, на третьем проходе можно будет использовать битовый вектор.
Разбор взят из перевода книги Г. Лакман Макдауэлл и предназначен исключительно для ознакомления.
Оригинал статьи.
Предложите алгоритм, генерирующий все корректные комбинации пар круглых скобок. Под корректными комбинациями пар будем понимать правильно открытые и закрытые скобки. На вход подаётся число пар скобок, на выходе должны быть все возможные их комбинации в виде набора строк.
Первая мысль — использовать рекурсивный подход, который строит решение для f(n), добавляя пары круглых скобок в f(n-1). Это, конечно, правильная мысль.
Рассмотрим решение для n = 3:
(()()) ((())) ()(()) (())() ()()()
Как получить это решение из решения для n = 2?
(()) ()()
Можно расставить пары скобок в каждую существующую пару скобок, а также одну пару в начале строки. Другие места, куда мы могли вставить скобки, например в конце строки, получатся сами собой.
Итак, у нас есть следующее:
(()) -> (()()) /* скобки вставлены после первой левой скобки */ -> ((())) /* скобки вставлены после второй левой скобки */ -> ()(()) /* скобки вставлены в начале строки */ ()() -> (())() /* скобки вставлены после первой левой скобки */ -> ()(()) /* скобки вставлены после второй левой скобки */ -> ()()() /* скобки вставлены в начале строки */Но постойте! Некоторые пары дублируются! Строка ()(()) упомянута дважды! Если мы будем использовать данный подход, то нам понадобится проверка дубликатов перед добавлением строки в список. Реализация такого метода выглядит так:
public static SetАлгоритм работает, но не очень эффективно. Мы тратим много времени на дублирующиеся строки.
Избежать проблемы дублирования можно путем построения строки с нуля. Этот подход подразумевает, что мы добавляем левые и правые скобки, пока наше выражение остается правильным.
При каждом рекурсивном вызове мы получаем индекс определенного символа в строке. Теперь нужно выбрать скобку (левую или правую). Когда использовать левую скобку, а когда — правую?
Левая скобка: пока мы не израсходовали все левые скобки, мы можем вставить левую скобку.
Правая скобка: мы можем добавить правую скобку, если добавление не приведет к синтаксической ошибке. Когда появляется синтаксическая ошибка? Тогда, когда правых скобок больше, чем левых.
Таким образом, нам нужно отслеживать количество открывающих и закрывающих скобок. Если в строку можно вставить левую скобку, добавляем ее и продолжаем рекурсию. Если левых скобок больше, чем правых, то вставляем правую скобку и продолжаем рекурсию.
public void addParen(ArrayListПоскольку мы добавляем левые и правые скобки для каждого индекса в строке, индексы не повторяются, и каждая строка гарантированно будет уникальной.
Разбор взят из перевода книги Г. Лакман Макдауэлл и предназначен исключительно для ознакомления.
Оригинал статьи.
Вы поставили стакан воды на диск проигрывателя виниловых пластинок и медленно увеличиваете скорость вращения. Что произойдет раньше: стакан сползет в сторону, стакан опрокинется, вода расплескается?
Этот вопрос задавали ранее на собеседованиях в Apple. При ответе рассмотрите возможные варианты и укажите, от чего зависит ответ, если их несколько.
Этот вопрос задавали ранее в Apple. Большинство людей понимают, что при его анализе необходимо учесть центробежную силу. В равной степени вам нужно знать и силу трения. Оно возникает между дном стакана и вращающимся диском, который приводит стакан в движение.
Чтобы сделать ситуацию более понятной, представьте мир, где трение вообще отсутствует. Каждая вещь становится более скользкой, чем тефлон, причем более скользкой бесконечно. Тогда в эксперименте, описанном в вопросе, не будет никакого влияния на стакан. Диск проигрывателя будет вращаться под стаканом, не оказывая на него никакого влияния, то есть стакан вообще не будет двигаться. Это верно в соответствии с первым законом Ньютона: неподвижные объекты остаются в этом положении до тех пор, пока на них не воздействует какая-то сила. Без силы трения стакан не будет перемещаться.
Теперь представьте противоположный вариант: стакан при помощи очень прочного клея Krazy Glue приклеили к диску, и между двумя поверхностями появилась практически бесконечно высокая сила трения. Стакан и диск в этом случае будут вращаться как единое целое. Увеличьте скорость диска, и стакан будет вращаться быстрее. Это приведет к увеличению центробежной силы. Единственное, что сможет в этих условиях свободно реагировать на эту силу, будет вода. Ведь она-то ко дну стакана не приклеена. Когда стакан будет крутиться с достаточно большой скоростью, вода прольется в сторону, противоположную центру вращения.
В вопросе вас просят рассмотреть вариант, лежащий между предельными ситуациями. Вначале трение будет достаточным, чтобы удерживать стакан на месте. Он будет вращаться вместе с диском, создавая небольшую центробежную силу. По мере увеличения скорости вращения, центробежная сила будет возрастать. Давление, удерживающее стакан на месте, будет оставаться примерно одинаковым. Поэтому должен наступить какой-то момент, когда центробежная сила превысит силу давления.
Те, кто изучал физику или проводил много времени в детских играх, вспомнят, что когда предмет начинает скользить, сила трения становится меньше, чем когда он стоит. На верхней части ледяной горки вы немного «прилипаете», но затем неожиданно начинаете свободно по ней двигаться вниз. То же самое относится и к диску. Вместо того, чтобы все время ускоряться постепенно, стакан вначале удерживается, и только через какое-то время начинает двигаться.
Что случится потом? Ответ здесь таков: это зависит от формы стакана и от того, насколько он заполнен водой. Однако если вы ограничитесь только этим ответом, интервьюер может решить, что вы пытаетесь уйти от вопроса. Вот варианты, которые возможны в реальной жизни.
Заполните стакан водой до краев. Даже самая небольшая центробежная сила приведет к повышению уровня воды над внешним краем стакана. Из-за чего часть воды прольется. Это случится даже тогда, когда стакан «приклеен», то есть до того, как он начнет скользить.
Используйте очень низкий стакан, к примеру, чашку Петри с каплей воды в ней. Если вы выбрали такой сосуд для эксперимента, он не перевернется и не будет двигаться настолько быстро, что единственная капля воды поднимется по его стенке и прольется. Зато чашка Петри с этой каплей просто соскользнет с диска.
Используйте очень высокий стакан, вроде пробирки с плоским днищем. Центробежная сила фактически действует на центр тяжести. Поскольку центр тяжести в данном случае расположен высоко, а вся сила трения прикладывается в самом низу, стеклянная пробирка скорее опрокинется, чем будет скользить.
Важно учесть и поверхность диска. Если она изготовлена из резины, это повысит трение и с большей вероятностью приведет к выплескиванию и опрокидыванию, здесь они в равной мере вероятны. Более скользкая твердая пластиковая поверхность способствует реализации варианта скольжения.
Разбор взят из книжки «Are You Smart Enough to Work at Google?».
Оригинал статьи.
Короткая задачка по С++ в виде вопроса для новичков. Почему деструктор полиморфного базового класса должен объявляться виртуальным? Полиморфным считаем класс, в котором есть хотя бы одна виртуальная функция.
Давайте разберемся, зачем нужны виртуальные методы. Рассмотрим следующий код:
class Foo { public: void f(); }; class Bar : public Foo { public: void f(); } Foo *p = new Bar(); p->f();Вызывая , мы обращаемся к . Это потому, что р — указатель на Foo, a f() — невиртуальная функция.
Чтобы гарантировать, что вызовет нужную реализацию f(), необходимо объявить f() как виртуальную функцию.
Теперь вернемся к деструктору. Деструкторы предназначены для очистки памяти и ресурсов. Если деструктор Foo не является виртуальным, то при уничтожении объект Bar все равно будет вызван деструктор базового класса Foo.
Поэтому деструкторы объявляют виртуальными — это гарантирует, что будет вызван деструктор для производного класса.
Разбор взят из книги Гейл Л. Макдауэлл «Cracking the Coding Interview» (есть в переводе).
Оригинал статьи.
Напишите функцию, меняющую местами значения переменных, не используя временные переменные. Предложите как можно больше вариантов.
Это классическая задача, которую любят предлагать на собеседованиях, и она достаточно проста. Пусть — это исходное значение , а — исходное значение . Обозначим разницу .
Давайте покажем взаимное расположение всех этих значений на числовой оси для случая, когда :
Присвоим значение . Если сложить значение и , то мы получим (результат следует сохранить в ). Теперь у нас и . Все, что нам остается сделать, — присвоить значение , а это значение представляет собой .
Приведенный далее код реализует этот алгоритм:
public static void swap(int a, int b) { // Пример для a = 9, b = 4 a = a - b; // a = 9 - 4 = 5 b = a + b; // b = 5 + 4 = 9 a = b - a; // a = 9 - 5 goalma.orgn("a: " + a); goalma.orgn("b: " + b); }Можно решить эту задачу с помощью битовой манипуляции. Такой подход позволит нам работать с разными типами данных, а не только с .
public static void swap_opt(int a, int b) { //Пример для a = (в двоичной системе) и b = a = a ^ b; // a = ^ = b = a ^ b; // b = ^ = a = a ^ b; // a = ^ = goalma.orgn("a: " + a); goalma.orgn("b: " + b); }Этот код использует операцию . Проще всего понять, как работает код, взглянув на два бита — и . Давайте обозначим как и исходные значения.
Если мы сможем поменять местами два бита, то алгоритм будет работать правильно. Давайте рассмотрим работу алгоритма пошагово:
p = p0^q0 /* 0 если р0 = q0, 1 если р0 != q0 */
q = p^q0 /* равно значению р0 */
p = p^q /* равно значению q0 */
В строке 1 выполняется операция , результатом которой будет 0, если , и 1, если .
В строке 2 выполняется операция . Давайте проанализируем оба возможных значения p. Так как мы хотим поменять местами значения p и q, в результате должен получиться 0:
: в этом случае , так как нам нужно вернуть или . любого значения с 0 всегда дает исходное значение, поэтому результатом этой операции будет (или ).
: в этом случае . Нам нужно получить 1, если , и 0, если . Именно такой результат получается при операции любого значения с 1.
В строке 3 выполняется операция . Давайте рассмотрим оба значения . В результате мы хотим получить . Обратите внимание, что в настоящий момент равно , поэтому на самом деле выполняется операция .
: так как , мы хотим вернуть или . Выполняя , мы вернем .
: выполняется операция . В результате мы получаем инверсию , что нам и нужно, так как .
Остается только присвоить значение , a — значение . Мы удостоверились, что наш алгоритме корректно меняет местами каждый бит, а значит, результат будет правильным.
Разбор взят из перевода книги Г. Лакман Макдауэлл и предназначен исключительно для ознакомления.
Оригинал статьи.
Предложите алгоритм поиска в односвязном списке k-го элемента с конца. Список реализован вручную, есть только операция получения следующего элемента и указатель на первый элемент. Алгоритм, по возможности, должен быть оптимален по времени и памяти.
Данный алгоритм можно реализовать рекурсивным и нерекурсивным способом. Рекурсивные решения обычно более понятны, но менее оптимальны. Например, рекурсивная реализация этой задачи почти в два раза короче нерекурсивной, но занимает O(n) пространства, где n – количество элементов связного списка.
При решение данной задачи помните, что можно выбрать значение k так, что при передаче k = 1 мы получим последний элемент, 2 – предпоследний и т.д. Или выбрать k так, чтобы k = 0 соответствовало последнему элементу.
Решение 1. Размер связного списка известен
Если размер связного списка известен, k-й элемент с конца легко вычислить (длина – k). Нужно пройтись по списку и найти этот элемент.
Решение 2. Рекурсивное решение
Такой алгоритм рекурсивно проходит связный список. По достижении последнего элемента алгоритм начинает обратный отсчет, и счетчик сбрасывается в 0. Каждый шаг инкрементирует счетчик на 1. Когда счетчик достигнет k, искомый элемент будет найден.
Реализация этого алгоритма коротка и проста – достаточно передать назад целое значение через стек. К сожалению, оператор return не может вернуть значение узла. Так как же обойти эту трудность?
Подход А: не возвращайте элемент
Можно не возвращать элемент, достаточно вывести его сразу, как только он будет найден. А в операторе return вернуть значение счетчика.
public static int nthToLast(LinkedListNode head, int k) { if (head == null) { return 0; } int i = nthToLast(goalma.org, k) + 1; if (i == k) { goalma.orgn(goalma.org); } return i; }Решение верно, но можно пойти другим путем.
Подход Б: используйте C++
Второй способ – использование С++ и передача значения по ссылке. Такой подход позволяет не только вернуть значение узла, но и обновить счетчик путем передачи указателя на него.
node* nthToLast(node* head, int k, int& i) { if (head == NULL) { return NULL; } node* nd = nthToLast(head->next, k, i); i = i + 1; if (i == k) { return head; } return nd; }Решение 3. Итерационное решение
Итерационное решение будет более сложным, но и более оптимальным. Можно использовать два указателя – p1 и p2. Сначала оба указателя указывают на начало списка. Затем перемещаем p2 на k узлов вперед. Теперь мы начинаем перемещать оба указателя одновременно. Когда p2 дойдет до конца списка, p1 будет указывать на нужный нам элемент.
LinkedListNode nthToLast(LinkedListNode head, int k) { if (k <= 0) return 0; LinkedListNode p1 = head; LinkedListNode p2 = head; for (int i = 0; i < k - 1; i++) { if (p2 == null) return null; p2 = goalma.org; } if (p2 == null) return null; while (goalma.org != null) { p1 = goalma.org; p2 = goalma.org; } return p1; }Разбор взят из перевода книги Г. Лакман Макдауэлл и предназначен исключительно для ознакомления.
Оригинал статьи.
Напишите функцию, определяющую количество битов, которые необходимо изменить, чтобы из целого числа А получить целое число B. Числа, допустим, битные, язык любой.
Это одна из типичных задач на работу с битами, которые любят давать на собеседовании. Если вы никогда с ними не сталкивались, вам будет сложно сразу решить задачу с учётом стрессовой ситуации, поэтому запомните использованные при решении трюки.
На первый взгляд кажется, что задача сложная, но фактически она очень проста. Чтобы решить ее, задайте себе вопрос: “Как узнать, какие биты в двух числах различаются?”. Ответ прост – с помощью операции XOR.
Каждая единица результирующего числа соответствует биту, который не совпадает в числах A и B. Поэтому расчет количества несовпадающих битов в числах А и В сводится к подсчету число единиц в числе A XOR B:
int bitSwapRequired(int a, int b) { int count = 0; for (int c = a ^ b; c != 0; c = c >> 1) { count += c & 1; } return count; }Этот код хорош, но можно сделать его еще лучше. Вместо многократного сдвига для проверки значащего бита достаточно будет инвертировать младший ненулевой разряд и подсчитывать, сколько раз понадобится проделать эту операцию, пока число не станет равным нулю. Операция очищает младший ненулевой бит числа c.
Приведенный далее код реализует данный метод:
public static int bitSwapRequired(int a, int b) { int count = 0; for (int c = a ^ b; c != 0; c = c & (c - 1)) { count++; } return count; }Это одна из типичных задач на работу с битами, которые любят давать на собеседовании. Если вы никогда с ними не сталкивались, вам будет сложно сразу решить задачу, поэтому запомните использованные здесь трюки.
Разбор взят из перевода книги Г. Лакман Макдауэлл и предназначен исключительно для ознакомления.
Оригинал статьи.
В книге N страниц, пронумерованных как обычно от 1 до N. Если сложить количество цифр, содержащихся в каждом номере страницы, будет Сколько страниц в книге?
У каждого числа, обозначающего страницу, имеется цифра на месте единиц. При N страниц имеется N цифр, стоящих на месте единиц.
У всех, за исключением первых 9 страниц, числа являются как минимум двухзначными. Поэтому добавим еще N-9 цифр.
У всех, за исключением первых 99 страниц, числа являются трехзначными, что добавляет еще N цифр.
Я мог бы продолжать действовать так же и дальше, но лишь у небольшого числа книг количество страниц превышает По крайней мере книга с общим числом цифр, равным , к категории толстых не относится.
Из сказанного следует, что должно равняться:
N + (N - 9) + (N - 99).
Это равенство можно привести к более простой форме:
= 3N -
Из этого следует, что 3N = или N =
Поэтому ответ таков: в книге страница.
Разбор взят из книжки «Are You Smart Enough to Work at Google?».
Оригинал статьи.
Задачка по С++, которая, тем не менее, будет полезна и для других языков. Сопоставьте хэш-таблицу и mар из стандартной библиотеки шаблонов (STL). Как организована хэш-таблица? Какая структура данных будет оптимальной для небольших объемов данных?
В хэш-таблицу значение попадает при вызове хэш-функции с ключом. Сами значения хранятся в неотсортированном порядке. Так как хэш-таблица использует ключ для индексации элементов, вставка или поиск данных занимает O(1) времени (с учетом минимального количества коллизий в хэш-таблицах). В хэш-таблице также нужно обрабатывать потенциальные коллизии. Для этого используется цепочка — связный список всех значений, ключи которых отображаются в конкретный индекс.
map(STL) вставляет пары ключ/значение в дерево двоичного поиска, основанное на ключах. При этом не требуется обрабатывать коллизии, а так как дерево сбалансировано, время вставки и поиска составляет O(log N).
Как реализована хэш-таблица?
Хэш-таблица реализуется как массив связных списков. Когда мы хотим вставить пару ключ/значение, то, используя хеш-функцию, отображаем ключ в индекс массива. При этом значение попадает в указанную позицию связного списка.
Нельзя сказать, что элементы связного списка с определенным индексом массива имеют один и тот же ключ. Скорее, функция hashFunction(key) для этих значений совпадает. Поэтому, чтобы получить значение, соответствующее ключу, мы должны хранить в каждом узле и ключ и значение.
Подведем итог: хэш-таблица реализуется как массив связных списков, где каждый узел списка содержит два компонента: значение и исходный ключ. Давайте перечислим особенности реализации хэш-таблиц:
Нужно использовать хорошую хеш-функцию, чтобы гарантировать, что ключи были правильно распределены. Если ключи будут плохо распределены, то возникнет множество коллизий и скорость нахождения элемента снизится.
Независимо от того, насколько хороша наша хеш-функция, коллизии будут возникать, и мы будем нуждаться в их обработке. Это подразумевает использование цепочек связных списков (или другой метод решения проблемы).
Можно реализовать методы динамического увеличения или уменьшения размера хэш-таблицы. Например, когда отношение количества элементов к размеру таблицы превышает определенное значение, следует увеличить размер хэш-таблицы. Это означает, что нам потребуется создать новую хэш-таблицу и передать в нее записи из старой. Поскольку это очень трудоемкий процесс, нужно сделать все возможное, чтобы размер таблицы не менялся слишком часто.
Что может заменить хэш-таблицу при работе с небольшими объемами данных?
Можно использовать mар (из STL) или бинарное дерево. Хотя это потребует O(log(n)) времени, объем данных не велик, поэтому временные затраты будут незначительными.
В чём преимущество map?
У дерева есть по крайней мере одно заметное преимущество по сравнению с хеш-таблицей. В map можно пройтись итератором по возрастанию или убыванию ключей и сделать это быстро. Хеш-таблица в этом плане проигрывает.
Разбор взят из перевода книги Г. Лакман Макдауэлл и предназначен исключительно для ознакомления.
Оригинал статьи.
Разработайте класс, обеспечивающий блокировку так, чтобы предотвратить возникновение мертвой блокировки.
Существует несколько общих способов предотвратить мертвые блокировки. Один из самых популярных — обязать процесс явно объявлять, в какой блокировке он нуждается. Тогда мы можем проверить, будет ли созданная блокировка мертвой, и если так, можно прекратить работу.
Давайте разберемся, как обнаружить мертвую блокировку. Предположим, что мы запрашиваем следующий порядок блокировок:
А = {1, 2, 3, 4}
В = {1, 3, 5}
С = {7, 5, 9, 2}
Это приведет к мертвой блокировке, потому что:
А блокирует 2, ждет 3
В блокирует 3, ждет 5
С блокирует 5, ждет 2
Можно представить этот сценарий в виде графа, где 2 соединено с 3, а 3 соединено с 5, а 5 соединено с 2. Мертвая блокировка описывается циклом. Ребро существует в графе, если процесс объявляет, что он запрашивает блокировку немедленно после блокировки . В предыдущем примере в графе будут существовать следующие ребра:
(1, 2), (2, 3), (3, 4), (1, 3), (3, 5), (7, 5), (5, 9), (9, 2).
«Владелец» ребра не имеет значения.
Этот класс будет нуждаться в методе , который использует потоки и процессы для объявления порядка, в котором будут запрашиваться ресурсы. Метод будет проверять порядок объявления, добавляя каждую непрерывную пару элементов к графу. Впоследствии он проверит, не появилось ли циклов. Если возник цикл, он удалит добавленное ребро из графика и выйдет.
Нам нужно обсудить только один нюанс. Как мы обнаружим цикл? Мы можем обнаружить цикл с помощью поиска в глубину через каждый связанный элемент (то есть через каждый компонент графа). Существуют сложные компоненты, позволяющие выбрать все соединенные компоненты графа, но наша задача не настолько сложна.
Мы знаем, что если возникает петля, то виновато одно из ребер. Таким образом, если поиск в глубину затрагивает эти ребра, мы обнаружим петлю.
Псевдокод для этого обнаружения петли примерно следующий:
boolean checkForCycle(locks[] locks) { touchedNodes = hash table(lock -> boolean) //инициализировать touchedNodes, установив в false каждый lock в locks for each (lock x in goalma.org) { if (touchedNodes[x] == false) { if (hasCycle(x, touchedNodes)) { return true; } } } return false; } boolean hasCycle(node x, touchedNodes) { touchedNodes[r] = true; if (goalma.org == VISITING) { return true; } else if (goalma.org == FRESH) { //(см. полный код ниже) } }В данном коде можно сделать несколько поисков в глубину, но нужно инициализировать только один раз. Мы выполняем итерации, пока все значения в равны .
Приведенный далее код более подробен. Для простоты мы предполагаем, что все блокировки и процессы (владельцы) последовательно упорядочены.
public class LockFactory { private static LockFactory instance; private int numberOfLocks = 5; /* по умолчанию */ private LockNode[] locks; /* Отображаем процесс (владельца) в порядок, * в котором владелец требовал блокировку */ private HashtableРазбор взят из перевода книги Г. Лакман Макдауэлл и предназначен исключительно для ознакомления.
Оригинал статьи.
Напишите функцию на С++, выводящую в стандартный поток вывода K последних строк файла. При этом файл очень большой, допустим 50 ГБ, длина каждой строки не превышает символов, а число K <
Можно действовать прямо — подсчитать количество строк (N) и вывести строки с N-K до N. Для этого понадобится дважды прочитать файл, что очень неэффективно. Давайте найдем решение, которое потребует прочитать файл только один раз и выведет последние K строк.
Можно создать массив для K строк и прочитать последние K строк. В нашем массиве там будут храниться строки от 1 до K, затем от 2 до K+1, затем от 3 до K+2 и т.д. Каждый раз, считывая новую строку, мы будем удалять самую старую строку из массива.
Вы можете удивиться: разве может быть эффективным решение, требующее постоянного сдвига элементов в массиве? Это решение станет эффективным, если мы правильно реализуем сдвиг. Вместо того чтобы каждый раз выполнять сдвиг массива, можно «закольцевать» массив.
Используя такой массив, читая новую строку, мы всегда будем заменять самый старый элемент. Самый старый элемент будет храниться в отдельной переменной, которая будет меняться при добавлении новых элементов.
Пример использования закольцованного массива:
шаг 1 (исходное состояние): массив = {a, b, с, d, е, f}. р = 0 шаг 2 (вставка g): массив = {g, b, с, d, е, f}. р = 1 шаг 3 (вставка h): массив = {g, h, с, d, е, f}. р = 2 шаг 4 (вставка i): массив = {g, h, i, d, e, f}. p = 3Приведенный далее код реализует этот алгоритм:
void printLast10Lines(char* fileName) { const int K = 10; ifstream file (fileName); string L[K]; int size = 0; /* читаем файл построчно в круговой массив */ while (goalma.org()) { getline(file, L[size % K]); size++; } /* вычисляем начало кругового массива и его размер */ int start = size > K ? (size % K) : 0; int count = min(K, size); /* выводим элементы в порядке чтения */ for (int i = 0; i < count; i++) { cout << L[(start + i) % K] << endl; } }Мы считываем весь файл, но в памяти хранится только 10 строк.
Разбор взят из перевода книги Г. Лакман Макдауэлл и предназначен исключительно для ознакомления.
Оригинал статьи.
Дан кусок сыра в форме куба и нож. Какое минимальное количество разрезов потребуется сделать, чтобы разделить этот кусок на 27 одинаковых кубиков? А на 64 кубика? После каждого разреза части можно компоновать как угодно.
Такую задачку раньше часто давали на собеседованиях, а придумана она была ещё в году.
Чтобы получить 27 маленьких кубиков, вам нужно разрезать каждую из трех граней куба на три части. Для получения трех частей нужны два разреза. Очевидный ответ — сделать эти разрезы параллельно друг другу по всем трем осям, для чего вам потребуется всего шесть разрезов.
НО! При подобных вопросах первый ответ, который появляется у вас в голове, обычно не является лучшим. Можно ли усовершенствовать ответ? Вспомните, что вы можете передвигать кусочки после каждого разреза (как это часто делают повара, когда режут лук). Это в значительной степени повышает число возможных вариантов, и тогда вы, может быть, отыщете тот, на который вначале не обратили внимания.