ПЯТЬ ВРАГОВ БЫСТРОГО ЧТЕНИЯ
Естественно, причины, по которым ребенок медленно читает, те же, что и причины того, почему читают медленно взрослые (если, конечно, вы не владеете навыком скорочтения). Ну а тем, кто является счастливым обладателем навыка скорочтения, также будет интересно прочитать эту главу и понять, в чем их отличие от большинства людей.Враг № 1 - АРТИКУЛЯЦИЯ
Что это такое?
Движения губ, языка, у кого-то челюсти, других органов, которые участвуют в процессе чтения. Обратите внимание на ребенка при чтении, и вы заметите, как двигаются его губы, он как бы проговаривает слова про себя. Под артикуляцией понимается не только это движение, но и сам внутренний монолог, происходящий в голове, т. е. проговаривание слов про себя.
В чем же вред артикуляции?
Проблема в том, что скорость движения речевого аппарата не превышает 220–250 слов в минуту. 300 слов - это уже чемпионский максимум.
Полностью избавиться от артикуляции, конечно, нельзя, но можно свести ее к минимуму.
Существуют методы, подавляющие артикуляцию, их мы используем в нашем тренинге.
Вы, наверное, недоумеваете: как можно не проговаривать слова и понимать прочитанное?
Проводились научные эксперименты, которые доказали, что понимание при чтении без артикуляции в 2–3 раза выше.
Враг № 2 - РЕГРЕСИИ
Регресия - возвратное движение глаз при чтении.
Каким бы удивительным это ни казалось, но наши глаза при медленном чтении несколько раз возвращаются, перечитывая одно и то же. У некоторых людей регресии происходят настолько часто, что они фактически перечитывают одни и те же слова по 5–8 раз.
Во время экспериментов под контролем специальной аппаратуры следили за движением глаз читающего.
При этом было выявлено, что в среднем при прочтении одной строки у среднестатистического школьника регрессия происходит порядка 20 раз.
То есть при чтении одной строки, содержащей в среднем 8–9 слов, ребенок более двух раз прочитывает один и тот же текст.
Можете провести небольшой эксперимент либо с собой, либо со своим ребенком.
Нужно читать с помощью указки или пальца, ведя ими под строкой, а глазами читая этот текст.
Замерьте свою скорость чтения без указки и с указкой. Она будет разительно отличаться.
Враг № 3 - «МАЛО ВИЖУ – МЕДЛЕННО ЧИТАЮ»
Ребенок, который читает медленно, видит за один взгляд от 8 до 12 символов (букв).
Владеющий скорочтением видит несколько слов (от 20 символов) и воспринимает их сразу.
Вот очень хороший пример.
Простая фраза «КОТ ПИЛ МОЛОКО».
Когда вы видите и воспринимаете эту фразу сразу, целиком, у вас в голове появляется ясный образ кота, пьющего молоко.
Если же читаете по словам, то сначала вы читаете КОТ, и в голове появляется образ кота. У кого-то кот черный, у кого-то серый, у кого-то он спит на диване, у кого-то «гуляет сам по себе».
Далее вы видите слово ПЬЕТ, и мозгу необходимо слово КОТ и слово ПЬЕТ соединить в один образ - и вот уже в голове множество образов кота, который пьет.
Но, конечно, пить кот может что угодно: у кого-то кот пьет молоко, а у кого-то валерьянку, а у кого-то воду.
На последнем этапе вы видите слово МОЛОКО, и у вас выстраивается ясный образ (кота, пьющего молоко).
Теперь представьте, какое количество операций произошло в мозгу, а ведь они не происходят мгновенно. Сколько тратится времени и усилий на весь этот перебор?
А у ребенка, обладающего воображением намного лучше вашего, и количество образов соответствующее.
Пятно ясного видения можно увеличить, именно это мы и делаем на нашем тренинге.
Взгляд среднестатистического 9-летнего ребенка останавливается на строке 15–20 раз.
Если учесть регресии, ребенок делит строку на 10 блоков восприятия информации (в среднем по одному слову).
Ребенок, владеющий скорочтением, делит строку на блоки по 2–5 слов.
Наш мозг воспринимает информацию целостными смысловыми блоками, и чем крупнее эти блоки, тем больше, а главное - информация будет усваиваться лучше.
Враг № 4 - СЛАБОЕ ВНИМАНИЕ
Мозг работает намного быстрее, чем человек читает. Проблема с мозгом в том, что его невозможно «поставить на паузу». Когда он воспринял информацию, ему нужно заняться чем-то, чтобы постоянно находиться в рабочем состоянии.
Работает он следующим образом: начинает отвлекаться, начинает видеть, например, муху, которая летает в комнате, или вспоминает, что есть какое-то неотложное дело, и уходит в дебри, или вспоминает, как чудесно отдыхалось прошлым летом, или о том, что задали сегодня по математике, или не написала ли мне Ленка «ВКонтакте».
Фактически получается так, ребенок и книжку прочитанную не понимает и не помнит, и тем делом, о котором вспомнил, он тоже не занимается.
Пустая трата времени и усилий.
Чем быстрее мы читаем, тем пропорционально скорости чтения лучше грузим наш мозг.
Результаты научных экспериментов доказывают: чем выше скорость чтения - тем выше понимание.
Лучшей конструкцией было бы:
$ /usr/bin/time program_to_benchmark < big_file
В этом выражении это оболочка, которая открывает файл big_file, передавая его в вашу программу (ну, собственно, на «время», которое затем выполняет вашу программу как подпроцесс) как уже открытый файловый дескриптор. 100% чтения файла строго зависит от программы, которую вы пытаетесь сравнить. Это дает вам реальное представление о его производительности без ложных осложнений.
Я упомянул два возможных, но на самом деле неправильных «исправления», которые также можно было бы рассмотреть (но я «их» по-разному, поскольку это не то, что было неправильно в исходном сообщении):
О. Вы можете «исправить» это по времени только своей программой:
$ cat big_file | /usr/bin/time program_to_benchmark
B. или по времени для всего трубопровода:
$ /usr/bin/time sh -c "cat big_file | program_to_benchmark"
Они ошибочны по тем же причинам, что и # 2: они все еще используют `cat` без необходимости. Я упоминаю их по нескольким причинам:
они более «естественны» для людей, которые не совсем устраивают объекты перенаправления ввода-вывода оболочки POSIX
могут быть случаи, когда требуется «кошка» (например: для чтения файла требуется какая-то привилегия для доступа, и вы не хотите предоставлять эту привилегию программе для сравнения: `sudo cat / dev / sda | / usr / bin / time my_compression_test –no-output`)
на практике , на современных машинах, добавленный «кот» в трубопроводе, вероятно, не имеет реальных последствий
Но я говорю это последнее с некоторым колебанием. Если мы рассмотрим последний результат в «Редактировании 5» –
$ /usr/bin/time cat temp_big_file | wc -l 0.01user 1.34system 0:01.83elapsed 74%CPU ...
– это утверждает, что «кошка» потребляла 74% ЦП во время теста; и действительно 1,34 / 1,83 составляет около 74%. Возможно, запуск:
$ /usr/bin/time wc -l < temp_big_file
потребовалось бы всего лишь 0,49 секунды! Вероятно, нет: «cat» здесь должен был заплатить за системные вызовы read () (или эквивалентные), которые перенесли файл с «диска» (фактически буферный кеш), а также на запись в канале, чтобы доставить их на `wc`. Правильный тест все равно должен был бы выполнять эти вызовы read (); только вызовы write-to-pipe и read-from-pipe были бы сохранены, и они должны быть довольно дешевыми.
Тем не менее, я предсказываю, что вы сможете измерить разницу между `cat file | wc -l` и `wc -l <файл` и найдите заметную (2-значную процентную) разницу. Каждый из более медленных тестов будет платить аналогичное наказание в абсолютном времени; который, однако, будет составлять меньшую часть его большего общего времени.
На самом деле, я сделал несколько быстрых тестов с файлом мусора размером 1,5 гигабайта в системе Linux 3.13 (Ubuntu 14.04), получив эти результаты (это, на самом деле, «лучшие из 3» результатов, конечно, после правильного кэширования):
$ time wc -l < /tmp/junk real 0.280s user 0.156s sys 0.124s (total cpu 0.280s) $ time cat /tmp/junk | wc -l real 0.407s user 0.157s sys 0.618s (total cpu 0.775s) $ time sh -c "cat /tmp/junk | wc -l" real 0.411s user 0.118s sys 0.660s (total cpu 0.778s)
Обратите внимание, что результаты двух конвейеров утверждают, что они потребовали больше времени процессора (пользователь + sys), чем в реальном времени. Это связано с тем, что я использую встроенную команду «время» оболочки (Bash), которая понимает конвейер; и я на многоядерной машине, где отдельные процессы в конвейере могут использовать отдельные ядра, накапливая время процессора быстрее, чем в реальном времени. Используя / usr / bin / time, я вижу меньшее время процессора, чем в реальном времени, – показывая, что он может использовать только один элемент конвейера, переданный ему в командной строке. Кроме того, вывод оболочки дает миллисекунды, в то время как / usr / bin / time дает только hundreths секунды.
Таким образом, на уровне эффективности `wc -l`,` cat` имеет огромное значение: 409/283 = 1.453 или 45.3% больше в реальном времени, а 775/280 = 2,768 или колоссальный 177% больше используемого ЦП! На моем случайном ящике-есть-в-время-тест.
Я должен добавить, что существует по меньшей мере еще одно существенное различие между этими стилями тестирования, и я не могу сказать, является ли это выгодой или недостатком; вы должны сами решить это:
Когда вы запускаете `cat big_file | / usr / bin / time my_program`, ваша программа получает входные данные из канала, точно в темпе, отправленном `cat`, и в кусках, не больших, чем написано` cat`.
Когда вы запускаете `/ usr / bin / time my_program
Конечно, это интересный результат теста, если одна и та же программа выполняет существенно разные отношения между этими двумя случаями. Это показывает, что, действительно, программа или библиотеки ввода-вывода делают что-то интересное, например, используя mmap (). Поэтому на практике может быть полезно запустить тесты в обоих направлениях; возможно, дисконтируя результат `cat` каким-то небольшим фактором, чтобы« простить »стоимость запуска самой« кошки ».
Getline, stream operatoes, scanf, могут быть удобными, если вам не важно время загрузки файлов или загрузка небольших текстовых файлов … но если производительность – это то, о чем вы заботитесь, вы должны просто просто загрузить весь файл в память (при условии, что он подойдет). Вот пример:
//open file in binary mode std::fstream file(filename, std::ios::in|::std::ios::binary); if(!file) return NULL; //read the size... file.seekg(0, std::ios::end); size_t length = (size_t)file.tellg(); file.seekg(0, std::ios::beg); //read into memory buffer, then close it. char *filebuf = new char; file.read(filebuf, length); filebuf = "\0"; //make it null-terminated file.close();
Если вы хотите, вы можете обернуть поток вокруг этого буфера для более удобного доступа, например:
Std::istrstream header(&buffer, length);
Кроме того, если вы контролируете файл, рассмотрите возможность использования плоского двоичного формата данных вместо текста. Это более надёжно читать и писать, потому что вам не нужно иметь дело со всеми двусмысленностями пробелов. Он также меньше и намного быстрее разбирается.
Кстати, причина, по которой количество строк для версии C ++ больше, чем число для версии Python, заключается в том, что флаг eof устанавливается только тогда, когда делается попытка прочитать за пределами eof. Таким образом, правильный цикл будет:
While (cin) { getline(cin, input_line); if (!cin.eof()) line_count++; };
В вашем втором примере (с scanf ()) причина, по которой это еще медленнее, может быть вызвана тем, что scanf («% s») анализирует строку и ищет любой пробел (пробел, табуляция, новая строка).
Кроме того, да, CPython делает некоторое кэширование, чтобы избежать чтения жесткого диска.
Первый элемент ответа:
#include
Следующий код был быстрее для меня, чем другой код, размещенный здесь до сих пор: (Visual Studio 2013, 64-битный, 500 МБ файл с длиной строки равномерно в }
