8 (495) 988-61-60

Без выходных
Пн-Вск с 9-00 до 21-00

Кодекс оператора грм


Права и обязанности Оператора ГРМ / Харьковгаз

Отношения между Оператором ГРМ и потребителями природного газа регулируются Кодексом газораспределительных систем, утвержденным постановлением НКРЭКУ от 30.09.2015 № 2494 и Договором распределения природного газа, утвержденным постановлением НКРЭКУ от 30.09.2015 №2498. Поиск утечки газа бригадой САВР Чугуевского филиала ФОТО: ПАО "Харьковгаз"

Оператор ГРМ обязуется: 

  • размещать на сайте действующие тарифы за услуги по распределению природного газа и текущую редакцию текста Договора распределения природного газа (далее - Договор) и Кодекса газораспределител

Временной код (2000) - IMDb

Списки пользователей

Связанные списки от пользователей IMDb

список из 40 наименований
создано 27 октября 2012 г.

список из 27 наименований
создано 14 октября 2013 г.

список из 26 наименований
создано 28 ноя 2018

список из 35 наименований
создано 13 янв.2019 г.

список из 36 наименований
создано 17 апр 2017

.

8.16 - Время вашего кода

Автор Alex, 4 января 2018 г. | последнее изменение: nascardriver: 22 сентября 2020 г.

При написании кода иногда встречаются случаи, когда вы не уверены, будет ли тот или иной метод более производительным. Так как же сказать?

Один из простых способов - это рассчитать время кода, чтобы узнать, сколько времени потребуется для выполнения. Для этого в C ++ 11 есть некоторые функции библиотеки chrono. Однако использование библиотеки chrono немного непонятно.Хорошая новость заключается в том, что мы можем легко инкапсулировать все необходимые функции синхронизации в класс, который затем можем использовать в наших собственных программах.

Вот класс:

1

2

3

4

5

6

7

8

9

10

11

12

13

140002

14

18

19

20

21

22

23

24

25

26

#include // для функций std :: chrono

class Timer

{

private:

// Введите псевдонимы для облегчения доступа к вложенному типу

using clock_t = std :: chrono: : high_resolution_clock;

с использованием second_t = std :: chrono :: duration >;

std :: chrono :: time_point m_beg;

public:

Timer (): m_beg (clock_t :: now ())

{

}

void reset ()

{

m_beg = clock_t :: now ();

}

double elapsed () const

{

return std :: chrono :: duration_cast (clock_t :: now () - m_beg).count ();

}

};

Вот и все! Чтобы использовать его, мы создаем экземпляр объекта Timer в верхней части нашей основной функции (или там, где мы хотим начать отсчет времени), а затем вызываем функцию-член elapsed () всякий раз, когда мы хотим знать, сколько времени потребовалось программе для выполнения до этой точки. .

int main ()

{

Таймер t;

// Здесь идет код времени

std :: cout << "Истекло время:" << t.elapsed () << "секунды \ п";

возврат 0;

}

Теперь давайте воспользуемся этим в реальном примере, где мы сортируем массив из 10000 элементов. Во-первых, давайте воспользуемся алгоритмом сортировки выбора, который мы разработали в предыдущей главе:

1

2

3

4

5

6

7

8

9

10

11

12

13

140002

14

18

19

20

21

22

23

24

25

26

27

28

29

30

000

34

35

36

37

38

39

40

41

42

43

44

45

46

49

0002 47

00030002 47

0003

51

52

53

54

55

56

57

58

59

60

61

62

63

9 0002 64

65

66

67

68

69

70

71

72

73

74

75

#include

#include // для функций std :: chrono

#include // для std :: size_t

#include

#include // для std :: iota

.

Код Морзе Время

Основы

Время в азбуке Морзе основано на длине одной точки (или точки, если хотите). Из длины dit мы можем определить длину «dah» (или «тире») и различных пауз:

  • Dit: 1 шт.
  • Дах: 3 шт.
  • Внутрисимвольный интервал (промежуток между точками и точками внутри символа): 1 единица
  • Межсимвольный интервал (пробел между символами слова): 3 единицы
  • Слово пробел (разрыв между двумя словами): 7 единиц

слов в минуту

Уровень владения азбукой Морзе измеряется тем, сколько слов в минуту кто-то может отправить или получить.Это кажется сложной задачей, учитывая, что вы можете отправлять больше коротких слов в минуту, чем длинных. Обходной путь состоит в том, чтобы стандартизировать слово «ПАРИЖ» в качестве стандартного слова, поэтому, если Морзе отправляется со скоростью 20 слов в минуту (или «20 слов в минуту»), тогда слово «ПАРИЖ» (или, точнее, «ПАРИЖ» с пробелом в конце) можно было отправлять 20 раз в минуту.

"ПАРИЖ" хорош тем, что он хорош, даже 50 штук. Это переводится как ".--. .- .-. .. ... /", так что есть:

  • 10 точек: 10 шт .;
  • 4 даха: 12 шт .;
  • 9 внутрисимвольных пробелов: 9 единиц;
  • 4 межсимвольных пробела: 12 единиц;
  • 1 слово: 7 единиц.

Итого 10 + 12 + 9 + 12 + 7 = 50 единиц.

Учитывая это (и тот факт, что в минуте 60 секунд), мы можем составить формулу для нахождения длины точки $ t_ {dit} $ в секундах для заданной скорости wpm, $ s_ {wpm} $ :

\ begin {align} \ text {слов в минуту} & = s_ {wpm} \ nonumber \\ \ text {минут на слово} & = {1 \ over s_ {wpm}} \ nonumber \\ \ text {секунд на слово} & = {60 \ over s_ {wpm}} \ nonumber \\ \ text {точек на слово} & = 50 \ nonumber \\ \ text {секунд на dit} = t_ {dit} & = {60 \ более 50 s_ {wpm}} \ label {tdit} \ end {align}

Понятно, что в этом есть смысл: мы знаем, что для 1 слова в минуту (т.е.е. $ s_ {wpm} = 1 $) вы должны уместить 50 точек в минуту, а формула говорит, что $ t_ {dit} = 60/50 $. По мере увеличения скорости ($ s_ {wpm} $) длина $ t_ {dit} $ уменьшается (они «обратно пропорциональны»), что также имеет смысл.

Фарнсворт Тайминг

Люди, изучающие азбуку Морзе, часто используют так называемое «время Фарнсворта», чтобы облегчить распознавание звуковых паттернов. Вместо того, чтобы замедлять весь звук, лучше держать звуки персонажей на умеренно высокой скорости и просто увеличивать промежутки между символами и словами, чтобы дать больше времени на распознавание.Скорость символов определяется нормальной скоростью WPM ($ s_ {wpm} $), но скорость Фарнсворта ($ s_ {fwpm} $) определяет фактическое количество слов в минуту. То есть:

  • Dit: 1 единица (или $ t_ {dit} $)
  • Dah: 3 единицы (или 3t_ {dit} $)
  • Внутрисимвольный интервал: 1 единица (или $ t_ {dit} $)
  • Межсимвольный интервал: 3 единицы Фарнсворта (или 3t_ {fdit} $)
  • Пространство слова: длиннее 7 единиц Фарнсворта (или 7t_ {fdit} $)

, где одна единица Фарнсворта длиннее базовой.Как же вычислить межсимвольное пространство и пространство слов?

Возвращаясь к разбивке "ПАРИЖ" выше, мы видим, что, учитывая, что символы остаются на скорости $ s_ {wpm} $, нам нужно растянуть 4 межсимвольных пробела и 1 пробел для слова. (19 единиц), а часть, которая должна оставаться на той же скорости, составляет 31 стандартную единицу $ t_ {dit} $.

Таким образом, длина точки такая же, как и раньше (см. \ Eqref {tdit}):

$$ t_ {dit} = {60 \ более 50 s_ {wpm}} \ nonumber $$

Для длины слова «ПАРИЖ» мы используем более медленную скорость передачи слов Фарнсворта в минуту, или $ s_ {fwpm} $.Одно слово ("ПАРИЖ") должно занимать столько секунд:

$$ \ text {время для передачи `PARIS '} = {60 \ over s_ {fwpm}} \ text {секунды} \ label {paris} $$

Время для 31 стандартной единицы в "ПАРИЖЕ" должно составлять столько секунд:

$$ \ text {время для 31 стандартной единицы в `ПАРИЖЕ '} = 31 \ times t_ {dit} \ text {секунды} \ label {paris31} $$

Вычитание \ eqref {paris31} из \ eqref {paris} оставляет количество секунд для межсимвольных пробелов и слова:

$$ \ text {время для 19 единиц Фарнсворта} = {60 \ over s_ {fwpm}} - 31 t_ {dit} \ text {секунды} \ nonumber $$

Есть 19 единиц Фарнсворта, поэтому каждая занимает столько секунд:

$$ \ text {время для 1 единицы Фарнсворта} = t_ {fdit} = {(60 / s_ {fwpm}) - 31 t_ {dit} \ более 19} \ text {секунд} \ label {tfdit} $$

Используя \ eqref {tfdit}, мы можем затем посмотреть на соотношение $ t_ {fdit} / t_ {dit} $

\ begin {align} {t_ {fdit} \ over t_ {dit}} & = {(60 / s_ {fwpm}) - 31 t_ {dit} \ over 19 t_ {dit}} \ nonumber \\ & = {60 / s_ {fwpm} \ более 19 t_ {dit}} - {31 t_ {dit} \ более 19 t_ {dit}} \ nonumber \\ & = {60 \ более 19 с_ {fwpm} t_ {dit}} - {31 \ более 19} \ label {ratio} \ end {align}

Подставляя \ eqref {tdit} в \ eqref {ratio}:

\ begin {align} {t_ {fdit} \ over t_ {dit}} & = {60 \ times 50 s_ {wpm} \ over 19 s_ {fwpm} \ times 60} - {31 \ over 19} \ nonumber \\ & = {50 \ более 19} \ cdot {s_ {wpm} \ over s_ {fwpm}} - {31 \ более 19} \ nonumber \\ & = {50s_ {wpm} - 31s_ {fwpm} \ over 19s_ {fwpm}} \ label {ratio2} \ end {align}

Легко проверить, что если $ s_ {fwpm} = s_ {wpm} $, то, используя \ eqref {ratio2}, мы видим $ t_ {fdit} / t_ {dit} = 1 $, что имеет смысл.

В качестве альтернативы мы можем заменить \ eqref {tdit} на \ eqref {tfdit}, чтобы получить выражение для $ t_ {fdit} $ в терминах двух скоростей:

\ begin {align} t_ {fdit} & = {{60 \ over s_ {fwpm}} - 31 t_ {dit} \ over 19} \ nonumber \\ & = {{60 \ over s_ {fwpm}} - {31 \ times {60 \ over 50 s_ {wpm}}} \ over 19} \ nonumber \\ & = {60 \ times 50 s_ {wpm} - 31 \ times 60 s_ {fwpm} \ более 19 \ times 50 s_ {wpm} s_ {fwpm}} \ nonumber \\ & = {300 s_ {wpm} - 186 s_ {fwpm} \ более 95 s_ {wpm} s_ {fwpm}} \ text {секунды} \ label {tfdit2} \ end {align}

Мы можем проверить, что если $ s_ {fwpm} = s_ {wpm} $, то \ eqref {tfdit2} работает так же, как \ eqref {tdit}.

Хотя этот вывод немного отличается, вы обнаружите, что он выходит так же, как уравнения, описанные Джоном Бумом (KE3Z) в статье ARRL, на которую мне указал Рональд Л. и которая настолько точна, насколько я могу найти. ARRL - национальная ассоциация любительского радио (США).

.Код времени

- разработчик TI-Basic

Эта статья является частью стадии доработки цикла разработки.

На этой странице документируется скорость некоторых команд в TI-83 Basic. Хотя время, указанное здесь, будет варьироваться от модели к модели и даже от калькулятора к калькулятору (из-за уровня заряда батареи, свободной памяти и других факторов), одна вещь, которая не меняется, - это относительная скорость команд. Итак, если вы придете сюда, чтобы узнать, работает ли цикл For (быстрее, чем цикл While, эта информация будет полезна на любом калькуляторе.

В другом месте на этом сайте вы можете встретить утверждения вроде «foo () быстрее, чем bar ()» без каких-либо причин или доказательств. Информация на этой странице является их причиной и доказательством.

Чтобы иметь возможность сравнивать результаты скорости между командами, должен быть общий формат, который используется для всех тестов. Однако на самом деле есть два разных формата, которые вы можете использовать в зависимости от того, какой у вас калькулятор на основе TI-83.

Первый формат предназначен для тех, у кого есть TI-83, TI-83 + или TI-83 + SE, и это просто цикл For (, который выполняется заданное количество раз по команде:

 : для (n, 1, [число] : <команда (ы) для тестирования> : Конец  

Вы измеряете время, беря секундомер и пытаясь оценить, сколько раз индикатор бега двигался.Индикатор выполнения - это небольшая полоска шириной в один пиксель в правом верхнем углу калькулятора, которая перемещается при запуске программы. Каждый индикатор завершенного прогона вы считаете за восемь, а затем любые оставшиеся пиксели просто добавляете к общему количеству.

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

Второй формат предназначен для тех, у кого есть TI-84 + или TI-84 + SE, и он включает использование встроенных команд startTmr и checkTmr (. Сначала вы сохраняете startTmr в переменной (обычно реальной переменной), а затем запустите свою команду внутри цикла For (. Затем вы проверяете время с помощью команды checkTmr (с использованием переменной, которая была до того, как startTmr был сохранен в.

Вот базовый шаблон для использования:

 : startTmr → T : Для (n, 1, [число] : <команда (ы) для тестирования> :Конец : checkTmr (T) / [номер]  

Переменную n можно найти, нажав [2ND] [0] [LOG].У этой переменной есть статический адрес памяти, поэтому она не повлияет на точность таймингов.

Увеличение [числа] увеличивает точность, но требует больше времени. Кроме того, не изменяйте переменные n или T внутри цикла For (loop.

Хотя этот формат исключает человеческую ошибку при подсчете, он подвержен собственным ошибкам. Основным из них является то, что startTmr и checkTmr (всегда возвращают целые числа, но время непрерывно. В зависимости от того, насколько близко были начало и конец цикла к тиканью часов, количество секунд может отличаться на одну секунду в любом направление.Эта ошибка значительно уменьшается за счет проведения большего количества испытаний: ошибка ± 1 секунда уменьшается до ± 0,001 секунды на испытание при выполнении 1000 испытаний.

Если есть необходимость использовать одну или несколько переменных во время теста, вы должны инициализировать переменные известным значением перед запуском теста. Вы можете сделать это либо на главном экране, либо перед кодом формата (в этом случае вы также должны поставить паузу, чтобы отделить инициализацию переменной от теста кода). Если тестируемый код содержит оператор и If в первой строке, настоятельно рекомендуется добавить закрывающую скобку в цикл For (.

Не стесняйтесь экспериментировать с таймингом кода и размещать свои результаты на этой странице. Однако не забудьте указать модель калькулятора и версию ОС (находится в меню «О программе»), которую вы использовали! Если не указано иное, все тесты на этой странице были выполнены на TI-83 + и версии ОС 1.19.

Вот и все подробности и пояснения. А теперь пришло время!

Если заявления

К этому самому первому разделу сложно подойти, потому что на него влияет характер нашего метода тестирования.Оказывается, что команда For (, если после нее нет закрывающей круглой скобки, замедляет выполнение операторов If с ложным условием внутри цикла. Это не влияет на скорость других команд (кроме IS> ( и DS <(которые используются редко), а также этот эффект не происходит ни с истинным условием, ни с блоками If-Then-End (только с одним If и следующей за ним командой). Эти два фрагмента кода будут затронуты, например (второй будет намного быстрее):

 : Для (I, 1,100) : Если 0: : Конец  

В следующей таблице приведены все эти эффекты.Было бы слишком громоздко поддерживать тот же формат, что и где-либо еще, поэтому число - это просто общее количество пикселей.

Условный вид Для (A, 0,2000 Для (A, 0,2000)
Если 0: 1520 79
Если 1: 79 82
Если 0: то: конец 80 83
Если 1: То: Конец 89 91

Заключение: Ситуация с закрывающими круглыми скобками, когда применимо , является основным фактором, замедляющим выполнение оператора почти в 20 раз.По этой причине я предлагаю, чтобы, если есть хоть какой-то шанс, что условие ложно (что всегда так, иначе почему вы в первую очередь проверяете его?), Оставить скобку в цикле For (. Of конечно, это не влияет на команды If-Then-End.

Долгое время считалось, из-за неправильного понимания этого эффекта, что команды If были медленнее, чем If-Then-End (предыдущие версии этой страницы также не были полностью невиновными). Как видите, это не так, если вам известен эффект, показанный выше.Хотя есть небольшие различия во времени, они настолько малы, что вы можете их игнорировать.

Операторы отношения

Во всех программах есть много шансов, что вы увидите реляционные операторы, используемые для определения того, что делать. Но будет ли каждый из них работать в одно и то же время?
Формат Бары пикселей Всего
= 10 4 84
10 5 85
> 10 5 85
10 5 85
< 10 5 85
10 6 86
и 10 6 86
или 10 6 86
нет ( 8 6 70
xor 10 5 85

Заключение: Если вы можете отменить свои операции, сделайте это, чтобы сэкономить время.

int (по сравнению с параметром iPart (

Как вы, наверное, знаете, int (и iPart (имеют одинаковое использование, по крайней мере, для положительных чисел. В программах, где вы храните более одной переменной в одном числе, вы обычно используете int (или iPart (, но что лучше один использовать?

Формат Бары пикселей Всего
iPart (1 10 1 81
iPart (1.643759 10 1 81
внутр (1 8 7 71
внутр (1.643759 10 2 82

Заключение: Если нет 6 или более десятичных знаков, вам следует рассмотреть возможность использования int (из-за его скорости, но с несколькими десятичными знаками iPart (остается неизменным, поэтому идет быстрее.

Функция getKey

Надеюсь, вы все знаете функцию getKey, она, вероятно, наиболее часто используется в играх и пользовательских меню. На это нужно время, но мы еще не знаем, быстро ли это…

Формат Бары пикселей Всего
Getkey 7 5 61
Getkey → B 11 0 88

Заключение: getKey работает довольно быстро, но сохранение в переменной занимает много времени.Итак, если вам не нужно нажимать значение клавиши, не сохраняйте его и используйте вместо этого специальную переменную Ans.

Циклы For (, Repeat и While)

Существует много типов циклов, о которых вы уже должны знать: For (, Repeat и While loop). Но если у нас есть выбор, какой из них быстрее?

 : Для (A, 0,2000 : Пока 0: Конец : Конец  

12 полосок +2 пикселя (98 пикселей)

Также обратите внимание на то, что с реализацией циклов For (A, B, C можно выполнить оператор If:

Если B≤C, то C + 1 → C (в конце)
Если B> C, сохранить B в A

 : Для (A, 0,2000 : Для (B, 1,0 :Конец : Конец  

12 полосок (96 пикселей)
 : Для (A, 0,2000 : Повторить 1 :Конец : Конец  

13 полос +2 пикселя (106 пикселей)

Вывод: Есть один цикл, который лучше всего.Используйте правильный цикл для задачи, которую вам нужно выполнить.


4 полосы +4 пикселя (36 пикселей)
 : Делвар А : Пока A≤2000 : A + 1 → A; Нет использования Ans, потому что в цикле должен быть другой код, который испортит Ans ... : Конец  

23 полосы (184 пикселя)
 : Делвар А : Повторить A> 2000 : A + 1 → A; Нет использования Ans, потому что в цикле должен быть другой код, который испортит Ans ... : Конец  

22 полосы +7 пикселей (183 пикселя)

Заключение: Для того же использования используйте For (цикл…

pxl-Test (функция

Многие программисты TI-BASIC сообщали о проблемах, когда pxl-Test (является условным, он занимает до 40% больше времени.

Формат Бары пикселей Всего
pxl-Test (15,15; пиксель выключен 12 1 97
pxl-Test (15,15; пиксель включен 12 1 97
Если pxl-Test (15,15: Then: (пустая строка): End; пиксель включен 20 0 160
Если pxl-Test (15,15: Then: (пустая строка): End; пиксель выключен 18 6 150
pxl-Test (15,15: Then: (пустая строка): End; пиксель включен 24 2 194
pxl-Test (15,15: Then: (пустая строка): End; пиксель выключен 22 7 183

Заключение: По крайней мере, для моего калькулятора он не дал мне ошибок, о которых сообщали другие.Поэтому не используйте pxl-Test (: если отвечает, но если pxl-Test (, он работает быстрее и занимает на байт меньше. Кроме того, не имеет значения, включен пиксель или нет.

Изменение пикселей и точек

Цель создания игр на 83+ в основном состоит в том, что у него хорошая графика и развлекательный контент. Вот почему нам нужно открывать или закрывать пиксели, чтобы рисовать. Я провел свой тест с размером окна: Xmin = 0, Ymin = -62, Ymax = 0, Xmax = 94

Формат Бары пикселей Всего
Pt-On (15, -15 14 0 112
Pt-On (15, -15,2 20 1 161
Pt-On (15, -15,3 18 2 146
Pt-Off (15, -15 14 0 112
Pt-Off (15, -15,2 20 1 161
Pt-Off (15, -15,3 18 2 146

Вывод: Итак, как мы видим, Pt-On / Off - это то же время выполнения.

Формат Бары пикселей Всего
Pt-Change (15, -15 14 0 112
Pxl-On (15,15 9 4 76
Pxl-Off (15,15 9 4 76
Pxl-Change (15,15 9 4 76
Линия (15, -15,16, -15 16 2 130
Линия (15, -15,30, -15 32 6 262
Линия (15, -15,30, -15,0 34 6 178
Горизонтальный -15 82 5 661
Вертикальный 15 60 3 483

Заключение: Line (, Horizontal и Vertical все медленные, но они могут экономить байты.Если необходимо включить менее 4 или 5 пикселей, Pxl-On (работает намного быстрее, чем любой из них. Однако, если у вас есть много пикселей для включения / выключения, гораздо лучше использовать их, чем Pxl- / Pt- команды. Кроме того, Pt-Change (имеет ту же скорость, что и Pt-On / Off.

Текст (против вывода (против Disp (

Во всех ваших программах, вероятно, есть что-то, что отображает текст на экране. Есть много способов сделать это, поэтому я посмотрю, какой из них быстрее. В кодах будет отображаться одна и та же строка «Я УМЕР!», Чтобы я мог дать вам ценные тайминги.Чтобы узнать время отображения, ClrHome находится после всех команд.
Формат Бары пикселей Всего
Текст (-1,16,12, «Я УМЕР!» 54 4 436
Текст (16,12, «Я УМЕР!» 41 1 329
Выход (3,2, «Я УМЕР!» 37 6 302
Disp "Я УМЕР! 51 2 410

Заключение: Для неподвижного текста, если вам нужно быть большим, вы должны использовать Output (но если вам это нужно в графическом экране, подумайте о времени, которое потребуется ...

Формат Бары пикселей Всего
Выход (3,2, A 16 6 134
Текст (-1,16,12, A 36 7 295
Текст (16,12, A 27 0 216

Вывод: Для значений переменных действует то же самое.

Круглые скобки и цитаты

Обычно вы не должны закрывать круглые скобки и кавычки для сохранения байта. Я проверю, пойдет ли быстрее.

Формат Бары пикселей Всего
Выход (3,2, «Я УМЕР!» 20 6 166
Выход (3,2, «Я УМЕР!» 20 6 166
(5 + 6) → В 13 6 110
(5 + 6 → В 13 5 109
5 + 6 → В 13 2 106

Заключение: Единственная причина, по которой вам нужно убирать кавычки, состоит в том, что вы экономите 1 байт, вы не получаете быстрее.Кроме того, удаление закрывающих скобок происходит быстрее. Однако будет лучше, если вы сможете полностью избавиться от скобок.

Умножение, деление и сложение

Большинство программистов на TI-BASIC советуют вам не ставить знак умножения *, но знают ли они, что это происходит быстрее?
Формат Бары пикселей Всего
А * В 13 4 108
AB 13 2 106

Вывод: Если умножать, не ставьте знак *.

Формат Бары пикселей Всего
Если AB: Then: (пустая строка): End; условие истинно 20 5 165
Если A и B: То: (пустая строка): Конец; условие истинно 20 5 165
Если AB: Then: (пустая строка): End; Condition false 18 7 151
Если A и B: То: (пустая строка): Конец; Условие ложно 19 2 154

Тогда вы могли бы использовать формат AB, потому что там на 1 байт меньше и нет потери скорости, и если условие в основном ложное, AB идет быстрее…

Формат Бары пикселей Всего
Если C + B: Then: (пустая строка): End; Условие истинно 20 6 166
Если C или B: То: (пустая строка): Конец; Условие истинно 20 6 166
Если C + B: Then: (пустая строка): End; Condition false 19 3 155
Если C или B: То: (пустая строка): Конец; Условие ложно 19 7 159

То же, что и в предыдущих тестах, но без экономии места.

Формат Бары пикселей Всего
Если A (C + B: Then: (пустая строка): End; условие истинно 25 4 204
Если A и (C или B: Then: (пустая строка): End; условие истинно 25 1 201
Если A (C + B: Then: (пустая строка): End; Condition false 23 4 188
Если A и (C или B: Then: (пустая строка): End; Condition false 23 7 191

Заключение: Итак, как мы видим, в нескольких условиях, где это должно быть верно много времени, вы должны использовать операторы и и или вместо умножения и сложения.-1 операция вместо деления от 1.

Переменные

Некоторые типы переменных предположительно быстрее других. Давай выясним!

Формат:
1 → _
ClockOn
startTmr → C
Для (T, 1 , E 5
_
End
Disp checktmr (C) / E 5

Переменная Время
N 0,00275
Xмин 0,00275
0.0321
Ответ 0,0321
[А] (1,1 0,00328
L 1 (1 0,00385
Str1 0,00385
Ответ (1 0,00482

Заключение: Используйте финансовые вары! Хотя это ваш выбор: 2-байтовая, очень быстрая переменная (т.е. финансовые переменные) или 1-байтовая, медленная переменная (т.е. реальные переменные).Кроме того, то, что Ans не был быстрее, не означает, что вы не должны его использовать! Это может сделать ваш код намного меньше, а в некоторых ситуациях может быть быстрее.

Вызов списков

Как вы знаете, списки - это массивы переменных, которые вы можете изменять, одну за другой. Вы можете использовать предопределенные списки, такие как ∟1, ∟2,…, ∟6, и определенные пользователем списки, LXXXXX, где X представляет любую букву или цифру или вообще ничего (кроме первого символа). Чтобы вызвать элемент, нужно время, но сколько?

Формат Бары пикселей Всего
\ L1 \ 13 6 110
\ L1 \ (1 15 0 120
\ L \ A 15 3 123
\ L \ A (1 16 6 134
\ L \ AA 15 5 125
\ L \ AAA 15 4 124
\ L \ AAAA 16 2 130
\ L \ AAAAA 16 2 130
А 9 6 78

Заключение: Если вы можете использовать предварительно определенные списки в качестве временного буфера, но не для длительного хранения, его так легко изменить в математическом классе.И если вы можете, используйте реальные переменные вместо списков, если у вас очень мало элементов и что хранение данных не является долгосрочным.

Мнимые и десятичные числа

Если вы просмотрели некоторые руководства, они говорят о том, что в одной переменной содержится много разных переменных, с использованием либо мнимых чисел в прямоугольной форме (A + B i ), либо десятичных знаков (XX.YYMMDDNNIIJJ). Это экономит место для отслеживания сохраненных игр, а иногда и время, если вы используете его правильно. Но какие способы самые быстрые?

Формат Бары пикселей Всего
вещественное (4 + 4i) + изображение (4 + 4i 23 4 188
реальный (4 + 4i 14 6 112
изображений (4 + 4i 14 6 112
внутр (4.4) + 10fPart (4.4 15 2 116
внутр (4,4 8 6 70
10fPart (4.4 11 1 89

Заключение: Если можете, постарайтесь не использовать воображаемые прямоугольники, они медленнее, чем их int (и fPart (эквивалентно, и они хранят точно такое же количество данных. Кроме того, сложная переменная вдвое больше, чем реальная переменная, и если вы используете ее в списке, даже реальные элементы увеличатся вдвое.9), но намного медленнее для больших аргументов. Конечно, нужно учитывать и размер, поэтому команда кажется довольно безопасным вариантом.

IS> (по сравнению с командой

Вот что произошло, когда я сравнил IS> (с условными выражениями If:

Формат Бары пикселей Всего
IS> (B, 10): Disp 24 2 194
Если B> 10: B + 1 → B: Disp 34 3 275

Заключение: IS> (работает быстрее, но его недостатки могут не сделать его очень полезным.

подпрограммы getKey

Это два разных метода перемещения X на рабочем столе.
Альтернативный метод Darkstone Knight. (123 байта, 12 полосок, 7 пикселей, всего 103 пикселя)

 : ClrHome : 1.01 → А : Для (D, 0,200) : getKey : Если ответ : Выход (параметрический ряд (A), (smallcapitalE) 2fPart (A), "/ один пробел / : A + (Ans = 34 и A <8) - (Ans = 25 и A≥2) + sub ((Ans = 26 и fPart (A) <. 16) - (Ans = 24 и fPart (A)> sub ( 1 → А : Выход (параметрический ряд (A), (smallcapitalE) 2fPart (A), "X : Конец  

и оригинальный метод с использованием кусочных выражений.(109 байт, 13 полос, всего 104 пикселя)
 : ClrHome : 1 → А : 1 → B : Для (D, 0,200) : getKey → C : Если C : Вывод (A, B, "/ один пробел / : A + (C = 34 и A <8) - (C = 25 и A> 1 → A : B + (C = 26 и B <16) - (C = 24 и B> 1 ​​→ B : Выход (A, B, "X Конец  

Итак, какой из них вы будете использовать, зависит от вашего значения 1/200 пикселя на итерацию по сравнению с размером 14 байтов.

.

Смотрите также