PascalABC.NET официальный канал

Находим главных героев в тексте произведения "Война и мир"

Можно ли установить главных героев, не читая произведение "Война и мир"?

Да, надо выдать частоту встречаемости имен.

Мы видим, что наиболее часто встречаются имена собственные Андрей, Ростов, Пьер и Анна.

faststring - новый тип в PascalABC.NET 3.10.3

На самом деле faststring - это просто синоним StringBuilder с немного дополненной функциональностью (методами Replace и IndexOf и операцией in)

Однако faststring работает действительно быстро: в примере на скрине, предложенном @tpehep33, метод PascalABC.NET опережает аналогичную функцию Python, написанную на C++, в 2 раза.

// 6.0 sec PascalABC.NET vs 11.4 sec Python
begin
  var mx := 0;
  for var n := 4 to 9999 do
  begin
    var s: faststring := '4' + '1' * n;

    while ('411' in s) or ('1111' in s) do
      s.Replace('411', '14', 1)
       .Replace('1111', '1', 1);
    
    mx := max(mx, s.ToString.Sum(d -> d.todigit));
  end;
  print(mx, Milliseconds / 1000);
end.

#новое

Алгоритм Дейкстры на Rosetta Code

Алгоритм полностью сгенерирован ChatGPT по коду на Python с минимальными правками.

https://rosettacode.org/wiki/Dijkstra%27s_algorithm#PascalABC.NET

Ну а мы в Rosetta Code уже на 67 месте с 553 задачами благодаря стараниям тайного друга. Позади Elixir, Erlang, PowerShell и Groovy.

type
  Edge = auto class
    start, &end: char;
    cost: real;
  end;

  Graph = auto class
    edges: array of Edge;
    vertices: HashSet<char>;
    
    constructor(params edges: array of (char, char, real));
    begin
      Self.edges := edges.Select(e -> new Edge(e[0], e[1], e[2])).ToArray;
      Self.vertices := new HashSet<char>(
        Self.edges.Select(e -> e.start) + Self.edges.Select(e -> e.end)
      );
    end;
    
    function Dijkstra(source, dest: char): sequence of char;
    begin
      assert(vertices.Contains(source));
      
      var inf := real.MaxValue;
      var dist := Dict(vertices.Select(v -> (v, inf)));
      var previous := Dict(vertices.Select(v -> (v, ' ')));
      dist[source] := 0;
      
      var q := vertices.ToHashSet;
      var neighbours := Dict(vertices.Select(v -> (v, new HashSet<(char, real)>)));
      
      foreach var edge in edges do
      begin
        neighbours[edge.start].Add((edge.end, edge.cost));
        neighbours[edge.end].Add((edge.start, edge.cost));
      end;
      
      while q.Count > 0 do
      begin
        var u := q.MinBy(v -> dist[v]);
        q.Remove(u);
        
        if (dist[u] = inf) or (u = dest) then
          break;
        
        foreach var (v, cost) in neighbours[u] do
        begin
          var alt := dist[u] + cost;
          if alt < dist[v] then
          begin
            dist[v] := alt;
            previous[v] := u;
          end;
        end;
      end;
      
      var s := new List<char>;
      var u := dest;
      
      while previous[u] <> ' ' do
      begin
        s.Insert(0, u);
        u := previous[u];
      end;
      
      s.Insert(0, u);
      Result := s;
    end;
  end;

begin
  var gr := new Graph(
    ('a', 'b', 7.0), ('a', 'c', 9.0), ('a', 'f', 14.0),
    ('b', 'c', 10.0), ('b', 'd', 15.0), ('c', 'd', 11.0),
    ('c', 'f', 2.0), ('d', 'e', 6.0), ('e', 'f', 9.0)
  );

  gr.Dijkstra('a', 'e').Println;  // Результат: ['a', 'c', 'f', 'e']
end.

Перевод градусов Цельсия в градусы Фаренгейта

Перевод градусов Цельсия в градусы Фаренгейта и обратно можно выполнить с помощью operator implicit.

type
  Farenheit =  class;
  
  Celsius = auto class
    value: real;
  public  
    constructor (v: real) := value := v;
    static function operator implicit(c: Celsius): Farenheit;
    function ToString: string; override 
      := $'{value}°C';
  end;

  Farenheit = auto class
    value: real;
  public  
    constructor (v: real) := value := v;
    static function operator implicit(f: Farenheit): Celsius;
    function ToString: string; override 
      := $'{value}°F';
  end;

static function Celsius.operator implicit
  (c: Celsius): Farenheit 
  := new Farenheit(c.value * 9 / 5 + 32);

static function Farenheit.operator implicit
  (f: Farenheit): Celsius 
  := new Celsius((f.value - 32) * 5 / 9);
 
begin
  var c := new Celsius(25);
  var f: Farenheit := c; // Неявное преобразование из Цельсия в Фаренгейт
  Println($'Температура: {c} = {f}');
  
  var f2 := new Farenheit(77);
  var c2: Celsius := f2; // Неявное преобразование из Фаренгейта в Цельсий
  Println($'Температура: {f2} = {c2}');
end.

2025 год. В виде шутки

- Запретят ли Паскалев?
- Тогда у нас будет своих Питонов!
- Красивое...

Текстовые файлы в PascalABC.NET

Простая задача - добавить в конец каждой строки слово 'строка'.

Работа с файловыми переменными в PascalABC.NET - полностью объектно-ориентированная. И открывается файл - одной строкой - на чтение или за запись.

Рейтинг TIOBE 2025

Вышел рейтинг TIOBE популярности языков программирования январь 2025.

Питон объявлен языком года - он вырос почти на 10%.

Из других наблюдений. Языки из Top 12 тоже выросли. Это значит, что остальные языки уменьшились.

С++ поднялся на 2 позицию, повторив результат 2000 года.

C# и JavaScript сохраняют свои позиции как 5-го и 6-го языков.

Язык Go с 11 места переместился на 7-е.

Вновь ворвался в десятку Фортран.

И - Delphi - на 11 месте, поднявшись на 2 позиции. А всё потому что сделали for var i. Сделают лямбды как у нас - поднимутся ещё выше.

Язык Kotlin выскочил из двадцатки. А мы на него равняемся :(

Язык Rust поднялся с 19 места на 14-е.

Замыкает 20-ку COBOL, никуда не собираясь уходить.

Функции как объекты первого класса

Функции называют "объектами первого класса" (first-class objects) в языках программирования, если они обладают такими же возможностями, как и другие типы данных (например, числа, строки, массивы). Это означает, что функции можно передавать, возвращать, присваивать переменным и использовать в выражениях, как любые другие объекты.

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

Learn PascalABC.NET in Y minutes

На вики-странице Learn PascalABC.NET in Y minutes впервые представлены все ключевые возможности PascalABC.NET, отражающие 17 лет его эволюции.

📌 Важнейшие разделы:

🔹 Структуры данных: кортежи, диапазоны, строки, массивы, списки, словари, множества, записи и классы.
🔹 Современные языковые средства: автовыведение типа, внутриблочные описания, циклы loop и foreach, цикл for с шагом, интерполяция строк, многострочные строки, параметры по умолчанию и именованные аргументы.
🔹 Современные операции: in, срезы, индексация с конца. to для создания пар "ключ-значение" — лаконичные инструменты для работы с данными.
🔹 Новые литеральные массивы [1,2,3].
🔹 Лямбда-выражения и функциональные переменные: гибкость функционального подхода.
🔹 Последовательности: мощный инструмент для работы с данными, включая LINQ.
🔹 Поддержка разных парадигм: процедурное, функциональное, обобщенное и объектно-ориентированное программирование.
🔹 Полная интеграция со стандартной библиотекой .NET.

📖 Этот документ — уникальное собрание возможностей, отражающих эволюцию и современность PascalABC.NET.

🎖 Специальная благодарность @ulysses4ever за идею создания данного документа.

#PascalABCNET #новое

С Новым 2025 годом!

Дорогие читатели канала PascalABC.NET!

Поздравляем вас с наступающим Новым 2025 годом!

Пусть этот год принесет вам новые знания, вдохновение и успехи в изучении программирования и обучении программированию. Мы искренне рады быть частью вашего пути, связанного с программированием на PascalABC.NET, и готовы радовать вас интересными задачами, полезными примерами и увлекательными материалами.

Желаем, чтобы каждый ваш проект компилировался с первого раза, алгоритмы были элегантными, а решения — находились легко. Пусть PascalABC.NET продолжает вдохновлять вас на изучение нового и делать программирование доступным и увлекательным.

Спасибо, что вы с нами! До встречи в Новом 2025 году! Все вычисления говорят, что он скоро наступит:

##
Arr(1..9).Select(x -> x * x * x).Sum.Println;
Arr(1..9).Sum.Sqr.Println;
'2025'.Batch(2).Select(x -> x[0]+x[1])
  .Select(x -> x.ToInteger).Sum.Sqr.Println;
Seq(1,8,8,10).Select(x -> x ** 3)
  .Sum.Round.Println;
(2026..2029).Zip([4,-6,4,-1]
  ,(x,y) -> x * y).Sum.Println;
(2026..2029).Select(x -> x*x)
  .Zip([4,-6,4,-1],(x,y) -> x * y)
  .Sum.Sqrt.Round.Println;
(2021..2024).Reverse
  .Zip([4,-6,4,-1],(x,y) -> x * y).Sum.Println;
(2021..2024).Reverse.Select(x -> x*x)
  .Zip([4,-6,4,-1],(x,y) -> x * y)
  .Sum.Sqrt.Round.Println;

Как вы верно догадываетесь, вывод:

2025
2025
2025
2025
2025
2025
2025
2025

Ваш PascalABC.NET

Косой косой косой

Пять смыслов слова "косой" в одной строке.

Ну а мы разбиваем строку на слова замечательным методом ToWords - сразу и без колебаний.
Раньше на это ползанятия уходило... Были времена!

#методика

Метод Distinct для символов строк

Прекрасная комбинация методов Where, IsDigit, Order и Distinct.

Ну и конечно - косвенная транзакция как говорят психологи - строка без цифр, несущая отдельную положительную нагрузку: "It's better to light a candle than curse the darkness"

Что мы и делаем каждый день!

#методика

Корни n-той степени из комплексной единицы

Известно, что имеется ровно n корней n-той степени из единицы если рассматривать её в комплексной плоскости.

Код очень прост:

function RootsOfUnity(n: integer) 
  := (0..n-1).Select(x -> Complex.FromPolarCoordinates(1, 2 * PI * x / n));

begin
  RootsOfUnity(3).PrintLines
end.

И вывод

1+0i
-0.5+0.866025403784439i
-0.5-0.866025403784438i

А мы в Rosetta Code - на 72 месте с 511 задачами. Позади уже Prolog и PHP.

Болеем за наших! И хвалим claude.ai за сгенерированную картинку!

Сумма цифр в строке

Одно удовольствие - комбинировать уже известные методы для строк. Здесь их - 6 штук - и все в одной строке кода!

Как бедно жили люди когда не было методов - писали всё это руками. И плакали...

#методика

Шестнадцатеричные литеральные константы

В PascalABC.NET для шестнадцатеричные литеральных констант используется префикс $.

Потерянное время никогда не найти снова

Прекрасная фраза, сказанная Бенджамином Франклином, зашифрована в этом сообщении.

Ну а мы наслаждаемся лаконичностью метода EachCount после фильтрации цифр.

#методика

Select и JoinToString для строк

Зашифровать что-то - школьников хлебом не корми.

А мы вспоминаем Select для изменения каждого символа строки и JoinToString для превращения последовательности символов назад в строку.

Ну и паттерн Chr(Ord(c)+1) для увеличения всех кодов на 1.

Расшифровка таких строк - особое удовольствие!

#методика

Метод Count для строк

В данной простой задаче исследуем со школьниками применение уже известных методов и операций к строкам.

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

Компактно, ёмко - ничего лишнего

#методика

Ввод чисел до маркера конца ввода

Классический образец кода для начинающих.

Вводятся числа до определенного числа. Надо их обработать. Само введенное число не учитывать.

Удобно пользоваться циклом while и первое число вводить до цикла.

#методика

Задачи на использование метода Zip

Приведем несколько задач, иллюстрирующих использование метода Zip, объединяющего несколько последовательностей в одну. Используются структурированные данные.

Задача 1. Изменение координат наблюдений
Дана последовательность наблюдений с координатами (X, Y). Нужно найти разницу координат между соседними наблюдениями и представить её в виде объектов с полями (DX, DY).

type Observation = auto class
  X, Y: real;
end;

begin
  // Исходные наблюдения
  var observations := Seq(new Observation(0, 0), new Observation(1, 1), new Observation(3, 4), new Observation(6, 8));
  
  // Вычисление разницы координат
  var deltas := observations.Zip(observations.Skip(1), 
    (a, b) -> new class(DX := b.X - a.X, DY := b.Y - a.Y));
  
  deltas.Println; // Вывод результата
end.

Задача 2. Объединение данных о сотрудниках
Даны две последовательности: сотрудники с именами и возрастом, а также их зарплаты. Требуется объединить эти данные в объекты с полями Name, Age и Salary.

type Employee = auto class
  Name: string;
  Age: integer;
end;

type Salary = auto class
  Amount: real;
end;

begin
  // Списки сотрудников и зарплат
  var employees := Seq(new Employee('Alice', 25), new Employee('Bob', 30), new Employee('Charlie', 35));
  var salaries := Seq(new Salary(2000.0), new Salary(2500.0), new Salary(3000.0));
  
  // Объединение данных
  var employeeData := employees.Zip(salaries, 
    (e, s) -> new class(e.Name, e.Age, Salary := s.Amount));
  
  employeeData.Println; // Вывод результата
end.

Задача 3. Сводка по продажам
Даны данные о продажах товаров за два квартала. Требуется вычислить разницу продаж для каждого товара и представить её в виде объектов с полями ProductName, Q1Sales, Q2Sales и Difference.

type Sale = auto class
  ProductName: string;
  Quantity: integer;
end;

begin
  // Продажи за два квартала
  var q1Sales := Seq(new Sale('ProductA', 100), new Sale('ProductB', 200), new Sale('ProductC', 150));
  var q2Sales := Seq(new Sale('ProductA', 120), new Sale('ProductB', 180), new Sale('ProductC', 160));
  
  // Объединение данных и вычисление разницы
  var summary := q1Sales.Zip(q2Sales, 
    (q1, q2) -> new class(q1.ProductName, Q1Sales := q1.Quantity, Q2Sales := q2.Quantity, Difference := q2.Quantity - q1.Quantity));
  
  summary.Println; // Вывод результата
end.

Задача 4. Анализ рейтингов продуктов
Даны данные о рейтингах продуктов от двух разных покупателей. Требуется объединить эти данные и найти разницу между рейтингами.

type Rating = auto class
  ProductName: string;
  Score: integer;
end;

begin
  // Рейтинги от двух покупателей
  var ratings1 := Seq(new Rating('ProductA', 5), new Rating('ProductB', 3), new Rating('ProductC', 4));
  var ratings2 := Seq(new Rating('ProductA', 4), new Rating('ProductB', 5), new Rating('ProductC', 3));
  
  // Объединение данных и вычисление разницы
  var differences := ratings1.Zip(ratings2, 
    (r1, r2) -> new class(r1.ProductName, Score1 := r1.Score, Score2 := r2.Score, Difference := r1.Score - r2.Score));
  
  differences.Println; // Вывод результата
end.

Задача 5. Тренды в измерениях
Даны данные измерений, выполненных в два момента времени. Найдите разницу между значениями измерений.

type Measurement = auto class
  Time: integer;
  Value: real;
end;

begin
  // Измерения в два момента времени
  var measurements1 := Seq(new Measurement(0, 1.0), new Measurement(1, 2.5), new Measurement(2, 3.7));
  var measurements2 := Seq(new Measurement(0, 1.2), new Measurement(1, 2.4), new Measurement(2, 3.8));
  
  // Разница между измерениями
  var trends := Zip(measurements1, measurements2, 
    (m1, m2) -> new class(m1.Time, Difference := m2.Value - m1.Value));
  
  trends.Println; // Вывод результата
end.

Множества в PascalABC.NET уже никогда не будут прежними

Начиная с версии 3.10.2 выражения вида [1,2,3] в PascalABC.NET трактуется по умолчанию как массив.

Данное поведение реализовано в последних версиях Delphi, что абсолютно правильно: использовать распространенную запись [1,2,3] для редко используемых встроенных множеств - расточительство!

Встроенные множества в PascalABC.NET остаются, но для их использования следует использовать переменные с явным объявлением типа. Таким образом, весь код на старом Паскале будет работать.

На скриншоте показано, в каких ситуациях запись в [...] трактуется как массив, а в каких - как множество.

Старый синтаксис литеральных массивов |1,2,3| сохранится, но объявляется устаревшим.

#новое

Инициализация датасета

В PascalABC.NET имеется ряд создающих функций, позволяющих просто создавать датасеты.

На скрине показано создание датасета в виде словаря, сопоставляющего ключам - заголовкам столбцов - данные в виде массивов строк. Используются создающая функция Dict, а также операция to для создания пары (Ключ, Значение).

Иллюстрируется также будущая возможность PascalABC.NET - массивы задаются в квадратных скобках.

Считывание из файла словаря списков

На скриншоте - программа из 4 строк, считывающая из файла словарь слов вместе с их переводами.

В файле информация хранится в том же виде, что и выводится:

(consider,[рассматривать,учитывать])
(proposal,[предложение,заявка])
(affect,[влиять,затрагивать])
(suggest,[предлагать,советовать,означать])

Директива компилятора {$DisableStandardUnits}

А хотите, чтобы в генерируемый код вообще не добавлялось ничего лишнего? Воспользуйтесь директивой {$DisableStandardUnits}

В итоге к генерируемому коду не будет добавлено ничего из стандартных модулей. Нельзя будет пользоваться ни Print, ни срезами, ни встроенными множествами. Зато генерируемый код будет крайне компактным и наиболее близким к тому, что генерирует компилятор C#.

Код данной dll занимает всего 3072 байт! А на C# так сможете?

{$DisableStandardUnits}
library LibA;

type 
  My = class
    i,j: integer;
  end;

function Add(a,b: integer) := a + b;

end.

Нововведения в модуде Coords

В модуле Coords появились функции Distance, Middle и многое другое.

uses Coords;

begin
  Globals.PointRadius := 2.3;
  Globals.LineWidth := 1.0;
  var p1 := Pnt(2,3);
  var p2 := Pnt(-4,7.3);
  var p3 := Pnt(-5,-3);
  DrawPoint(p1); 
  DrawPoint(p2);
  DrawPoint(p3);
  DrawText(p1,'A', Align := Alignment.LeftBottom, Size := 18);
  DrawText(p2,'B', Align := Alignment.LeftBottom, Size := 18);
  DrawText(p3,'C', Align := Alignment.RightTop, Size := 18);
  DrawLine(p1,p2);
  DrawLine(p1,p3);
  DrawLine(p2,p3);
  DrawText(Middle(p1,p2), p1.Distance(p2).ToString(2), Align := Alignment.Center, BackgroundColor := Colors.LightBlue);
  DrawText(Middle(p2,p3), p2.Distance(p3).ToString(2), Align := Alignment.Center,
   BackgroundColor := Colors.White, BorderWidth := 0.5);
  DrawText(Middle(p1,p3), p1.Distance(p3).ToString(2), Align := Alignment.Center, BackgroundColor := Colors.LightGreen);
end.

Скачайте новую версию!

#новое

💡 Метод NWise в PascalABC.NET: анализ временных данных в несколько строк кода

Метод NWise в PascalABC.NET помогает разбивать последовательности на подгруппы фиксированной длины. Он возвращает последовательность массивов, где каждый массив содержит соседние элементы исходной последовательности. Это удобно для задач анализа временных данных, обработки текстов или любых последовательностей.

Пример работы:

var a := Arr(1, 2, 3, 4, 5, 6);
foreach var group in a.NWise(3) do
  Println(group); 
// Результат: [1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]

📝 Примеры задач для анализа временных рядов:

1️⃣ Скользящее среднее температуры
Вычислим средние значения температуры за последние 3 дня:

var temperatures := Arr(22.1, 23.4, 21.8, 24.2, 22.9, 23.7);
foreach var window in temperatures.NWise(3) do
  Println(window.Average.Round(4)); 
// Результат: 22.4333, 23.1333, 22.9667, 23.6

2️⃣ Обнаружение резких изменений
Найдем периоды, где изменения потребления электроэнергии превышают 50 кВт⋅ч:

var consumption := Arr(120, 180, 150, 200, 260, 220);
foreach var window in consumption.NWise(2) do
  if Abs(window[1] - window[0]) > 50 then
    Println(window);
// Результат: [120, 180], [200, 260]

3️⃣ Максимальная скорость ветра
Определим максимальную скорость ветра за каждые 3 часа:

var windSpeeds := Arr(5, 8, 6, 10, 12, 9, 7);
foreach var window in windSpeeds.NWise(3) do
  Println(window.Max); 
// Результат: 8, 10, 12, 12, 12

4️⃣ Суммирование данных в окнах
Подсчитаем общее количество запросов к серверу за каждые 4 часа:

var requests := Arr(50, 60, 70, 80, 90, 100, 110);
foreach var window in requests.NWise(4) do
  Println(window.Sum);
// Результат: 260, 300, 340, 380

5️⃣ Выявление стабильных периодов
Найдем периоды, где изменения курса валют минимальны (разница между максимумом и минимумом в окне ≤ 1):

var exchangeRates := Arr(74.5, 74.6, 74.8, 74.7, 74.5, 74.4, 74.6);
foreach var window in exchangeRates.NWise(3) do
  if window.Max - window.Min <= 1 then
    Println(window);
// Результат: [74.6, 74.8, 74.7], [74.5, 74.4, 74.6]

6️⃣ Выявление трендов
Определим окна, где значения постоянно растут:

var sales := Arr(100, 120, 140, 130, 150, 160, 170);
foreach var window in sales.NWise(3) do
  if (window[0] < window[1]) and (window[1] < window[2]) then
    Println(window);
// Результат: [100, 120, 140], [130, 150, 160], [150, 160, 170]

⚡️ Используйте NWise, чтобы ускорить анализ временных рядов и упростить код! 🚀

Отличия новых множеств

Одно из важнейших отличий новых множеств от старых - контроль выхода за границы типа.

Мы можем попытаться записать в set of byte значения, выходящие за границы, но получим исключение времени выполнения.

Новые множества

В PascalABC.NET обновлена реализация встроенных множеств set of T, просуществовавшая 17 лет. За это время в PascalABC.NET внесено огромное количество улучшений: появились обобщенные классы, перегрузка операций, методы расширения, реализация интерфейсов, последовательности. Именно благодаря этим средствам реализация новых множеств стала возможной.

В результате новые множества значительно ускорены, приближаясь по эффективности к HashSet<T>.

На скриншоте - программа, которая работает в старой версии примерно в 1000 медленнее.

Обновите Паскаль - скачайте новую версию!

#PascalABC #новое

begin
  var s: set of integer;
  var n := 10000000;
  for var i:=1 to n do
    s += [i];
  Print(MillisecondsDelta);
end.

Игра Животные

Создаем игру "Угадай животное" на PascalABC.NET

Хотите научить программу угадывать загаданные вами животные? В PascalABC.NET это легко реализовать с помощью бинарного дерева и сериализации. Покажем, как это сделать, на примере классической игры "Угадай животное".
Пример кода

type
  [Serializable]
  Node = auto class
    Data: string; Yes, No: Node;
  end;

const FName = 'animals.dat';

begin
  var root: Node;

  Println('Загадайте животное');
  if not FileExists(FName) then
    root := new Node('Собака', nil, nil)
  else root := Node(Deserialize(FName));
  
  var cur := root;
  while cur.Yes <> nil do
    if ReadlnInteger(cur.Data + '? (0-Нет, 1-Да):') = 1 then 
      cur := cur.Yes else cur := cur.No;

  if ReadlnInteger('Это ' + cur.Data + '? (0-Нет, 1-Да):') = 1 then
    Println('Я угадала!')
  else
  begin
    var newA := ReadlnString('Я проиграла. Какое животное вы загадали?');
    var quest := ReadlnString('Введите вопрос для отличия ' + 
      newA + ' от ' + cur.Data + ':');
    cur.Yes := new Node(newA, nil, nil);
    cur.No := new Node(cur.Data, nil, nil);
    cur.Data := quest;
  end;

  Serialize(FName, root);
end.

Что делает этот код?

🔹 Создание дерева знаний: узлы дерева содержат либо вопрос, либо название животного.
🔹 Интерактивный процесс угадывания: программа задает вопросы до тех пор, пока не достигнет конца дерева.
🔹 Добавление новых знаний: если программа ошибается, она добавляет новое животное и соответствующий вопрос в дерево.
🔹 Сохранение прогресса: данные сохраняются в файл, что позволяет программе "учиться" даже после закрытия.

Как это работает на практике?

🔹 Если вы играете впервые, программа начнет с единственного узла — "Собака".
🔹 Постепенно дерево знаний будет разрастаться: каждая ошибка добавляет новый вопрос и новый узел.
🔹 Благодаря сериализации, данные сохраняются между сессиями.

Почему это интересно?

🔹 Обучение на практике: игра демонстрирует, как устроены деревья и как их можно использовать.
🔹 Простота расширения: можно добавить сохранение статистики, визуализацию дерева или использование синонимов.

Попробуйте реализовать эту игру и удивите своих друзей — пусть они проверят, как "умна" ваша программа! 🚀

Ниже - интерактивная версия нашей игры на JavaScript
https://claude.site/artifacts/923ab4f7-5d10-4db2-a227-bc74d699419e

Работа с индексами элементов в матрице

В PascalABC.NET работа с матрицами становится особенно удобной благодаря встроенным методам. Хотите найти все позиции элементов, удовлетворяющих определённому условию? А может, сразу обновить значения? Давайте рассмотрим это на примере:

begin
  var a := MatrRandom(3,4,0,2); // Создаём случайную матрицу 3x4 с элементами от 0 до 2
  a.Println(3); // Выводим матрицу в удобном формате
  a.Indices(x -> x = 0).Println; // Находим индексы всех нулей в матрице
  a.Indices(x -> x = 0).ForEach(\(i,j) -> (a[i,j] := 99)); // Заменяем все нули на 99
  a.Println(3); // Выводим обновлённую матрицу
end.

🔍 Что здесь происходит?

🔹 Генерация матрицы: С помощью MatrRandom создаём матрицу 3x4 со случайными числами от 0 до 2.
🔹 Поиск индексов: Метод Indices возвращает все позиции элементов, соответствующих условию. В данном случае мы ищем нули.
🔹 Обновление значений: Метод ForEach позволяет перебрать пары индексов (i, j) и изменить значения в матрице — нули заменяются на 99.

📈 Зачем это нужно? Такой подход удобен для сложных вычислений, анализа данных, обработки изображений, где нужно находить и модифицировать элементы по условию. Сжатый и выразительный код позволяет быстрее решать задачи!

Попробуйте использовать матрицы и методы работы с индексами в своих проектах, и вы увидите, насколько это упрощает вашу жизнь программиста! 🚀

Оптимизация поиска простых чисел: Решето Эратосфена в PascalABC.NET

Решето Эратосфена — это один из наиболее эффективных алгоритмов для нахождения всех простых чисел до заданного предела n. Он отличается высокой производительностью и простотой реализации.

Алгоритм обладает асимптотической сложностью O(n * log(⁡log ⁡n)), что делает его значительно быстрее простейших методов определения простоты через деление.

function SieveOfEratosthenes(n: integer): array of integer;
begin
  var isPrime := |True| * (n + 1); 
  isPrime[0] := False;
  isPrime[1] := False;

  for var i := 2 to Trunc(Sqrt(n)) do
    if isPrime[i] then
      for var j := i * i to n step i do
        isPrime[j] := False;

  Result := (2..n).Where(i -> isPrime[i]).ToArray;
end;

begin
  var n := 50;
  var primes := SieveOfEratosthenes(n);
  Println('Простые числа до ', n, ': ', primes);
end.

Этот пример демонстрирует, как эффективно можно реализовать решето Эратосфена в PascalABC.NET. Для визуализации работы алгоритма и лучшего понимания его процесса, вы можете ознакомиться с интерактивной демонстрацией по ссылке: визуализация решета Эратосфена, любезно сгенерированной Claude.ai по коду, приведенному выше/

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

Гарри Поттер - самые частые слова в начале предложения

Разбиваем текст на предложения, а затем предложения - на слова. Слова добавляем в список, затем по ним составляем частотный словарь и сортируем его по встречаемости.

begin
  //    LordOfTheRings
  var sentences := ReadAllText('HarryPotter.txt').ToWords('.?!');
  var lst := new List<string>;
  foreach var sentence in sentences do
  begin
    var words := sentence.ToWords(AllDelimiters);
    if words.Length = 0 then
      continue;
    if words[0][1].IsLower then
      continue;
    lst.Add(words[0]);
  end;
  
  lst.EachCount.OrderByDescending(kvp -> kvp.Value).Take(30).Print;
end.

Сортировка столбцов матрицы по возрастанию суммы в столбце

Метод a.Cols и функция MatrByCol превращают матрицу в массив массивов по столбцам и наоборот. В промежутке можно выполнить любую операцию со столбцами - например, отсортировать их по некоторому критерию.

begin
  var a := MatrRandomInteger(3,4,1,9);  
  a.Println;
  a := MatrByCol(a.Cols.OrderBy(col -> col.Sum)); 
  a.Println;
end.

Аналогичный код на Python требует подключения numpy:

import numpy as np

a = np.random.randint(0, 100, (3, 4))
print(a)

sorted_indices = np.argsort(a.sum(axis=0))
sorted_matrix = a[:, sorted_indices]

print(sorted_matrix)

📌 Группировка элементов с использованием словаря в PascalABC.NET 📌

В PascalABC.NET есть стандартный метод GroupBy, который позволяет группировать данные по ключу в одну строку. Но сегодня мы покажем, как организовать подобный процесс вручную, что помогает глубже понять, как работает группировка и какие структуры данных задействованы.

👀 Что делает этот код?

🔹 Имеется список пар элементов с категориями, например, фрукт, овощ, ягода.
🔹 Код создаёт словарь grouped, где ключами являются категории, а значениями — списки элементов в каждой категории.
🔹 Для каждого элемента проверяется наличие категории в словаре:
✦ Если категория отсутствует, создаётся новая запись со списком.
✦ Элемент добавляется в соответствующий список.
🔹 В результате формируется структура данных, аналогичная результату GroupBy, но построенная вручную.

✨ Почему это полезно?

Такой пример не только помогает понять принцип работы GroupBy, но и показывает, как можно использовать словари для создания сложных структур данных. Подход может быть полезен в ситуациях, где требуется больше контроля над логикой группировки.

Пример кода:

begin
  var items := |('яблоко','фрукт'), ('помидор','овощ'), ('банан','фрукт')
    , ('морковь','овощ'), ('арбуз','ягода')|;

  var grouped := new Dictionary<string, List<string>>;

  foreach var (item,category) in items do
  begin  
    if category not in grouped then
      grouped[category] := new List<string>;
    grouped[category].Add(item)
  end;
  
  grouped.PrintLines;
end.

📊 Результат:

фрукт: яблоко, банан
овощ: помидор, морковь
ягода: арбуз

Попробуйте разобраться в устройстве GroupBy на этом примере — это важный шаг в понимании основ алгоритмов и структур данных!

#Группировка #Словарь #GroupBy

📚 Анализ больших текстов в PascalABC.NET, Использование словарей 📚

Сегодня расскажем, как PascalABC.NET позволяет легко анализировать большой текст и получать ценную статистику! Взяв для примера текст "Властелин колец", мы сможем узнать, какие слова разной длины встречаются наиболее часто.

Рассмотрим следующий код:

begin
  var a := ReadAllText('LordOfTheRings.txt').ToLower.ToWords(AllDelimiters)
    .Where(w -> w[1] in 'а'..'я');
  for var i:=2 to 10 do
    a.Where(w -> w.Length = i)
    .EachCount
    .OrderByDescending(kv -> kv.Value).Take(5).Println;
end.

👀 Что делает этот код?

🔹 Загружает текст из файла, приводит его к нижнему регистру и разбивает на слова, используя константу AllDelimiters как разделители.
🔹 Оставляет только те слова, которые начинаются с русских букв.
🔹 С помощью метода EachCount получает словарь частот слов заданной длины.
🔹 Сортирует слова по их длине (от 2 до 10 символов) и подсчитывает частоту каждого слова.
🔹 Выводит самые популярные слова для каждой длины, помогая понять, какие слова наиболее часто встречаются.

✨ Почему это удобно? Работа с текстом в PascalABC.NET позволяет:

🔹 Легко анализировать большие текстовые данные,
🔹 Использовать встроенные методы Where, EachCount, OrderByDescending, Println и многие другие для фильтрации и сортировки данных,
🔹 Проводить быстрый и наглядный анализ, который можно адаптировать под любой текст.


Попробуйте адаптировать этот пример под свои тексты и узнайте, как часто и какие слова встречаются!

🔹 Лямбда-выражения в PascalABC.NET: преобразования, условия и проекции

Лямбда-выражения в PascalABC.NET дают возможность упростить и улучшить код. Важно понимать, что лямбда-выражения делятся на три основные группы: лямбда-преобразования, лямбда-условия и лямбда-проекции. Давайте разберем каждый вид с примерами.

1. Лямбда-преобразования

Лямбда-преобразование используется для преобразования данных. Оно может оставлять тип данных без изменений или переводить элементы в другой тип. Рассмотрим оба варианта:

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

var a := Arr(1, 2, 3, 4, 5);
var squares := a.Select(x -> x * x); // Числа преобразуются в их квадраты
a := squares.ToArray; // Результат можно присвоить тому же массиву
Println(squares); // Вывод: [1, 4, 9, 16, 25]

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

var a := Arr(1, 2, 3, 4, 5);
var strValues := a.Select(x -> x.ToString); // Числа преобразуются в строки
Println(strValues); // Вывод: ['1', '2', '3', '4', '5']

В обоих случаях метод Select позволяет эффективно преобразовывать данные: в первом случае, чтобы получить квадраты чисел, во втором — текстовое представление чисел.

2. Лямбда-условия

Лямбда-условия применяются для фильтрации элементов по критерию. В примере ниже отбираются только четные числа:

var a := Arr(1, 2, 3, 4, 5, 6);
var evenNumbers := a.Where(x -> x mod 2 = 0); // Отбираются только чётные числа
Println(evenNumbers); // Вывод: [2, 4, 6]

Метод Where использует условие x -> x mod 2 = 0, чтобы выбрать только числа, делящиеся на 2 без остатка.

3. Лямбда-проекции

Лямбда-проекция применяется, когда нужно извлечь часть составного объекта. В примере ниже из массива кортежей извлекаются только названия фруктов:

var items := Arr(('apple', 1.5), ('banana', 1.2), ('cherry', 0.9));
var fruitNames := items.Select(x -> x[0]); // Извлекается только название фрукта
Println(fruitNames); // Вывод: ['apple', 'banana', 'cherry']

Метод Select создает проекцию x -> x[0], возвращая первую часть кортежа x.

Подводим итоги:

✦ Лямбда-преобразования помогают изменить значение элемента, сохраняя или меняя его тип.
✦ Лямбда-условия отбирают данные по критерию.
✦ Лямбда-проекции полезны для извлечения частей составных объектов.

Пользуйтесь этими возможностями, чтобы сделать ваш код лаконичнее и понятнее! 🚀

Работа с форматом JSON

Дорогие подписчики! Сегодня мы расскажем о том, как легко и удобно работать с форматом JSON в PascalABC.NET с использованием библиотеки Newtonsoft.Json. JSON (JavaScript Object Notation) — это текстовый формат для представления структурированных данных на основе синтаксиса JavaScript. Он стал стандартом де-факто для обмена данными в веб-приложениях и широко используется благодаря своей простоте и удобству.

💻 Предлагаем вашему вниманию небольшой пример кода, который демонстрирует разбор сложной JSON-структуры и вывод ее содержимого в консоль с русскими названиями полей. Обратите внимание на легкость доступа к вложенным объектам и массивам:

uses Newtonsoft.Json.Linq;

begin
  // Считываем содержимое JSON из файла
  var jsonString := ReadAllText('data.json');
  
  // Разбор JSON-строки в объект JObject
  var jsonObject := JObject.Parse(jsonString);
  
  // Доступ к верхнему уровню объекта "человек"
  var person := jsonObject['человек'];
  
  // Извлечение простых значений
  var name := person['имя'].ToString;
  var age := person['возраст'].ToObject&<integer>;
  var isStudent := person['являетсяСтудентом'].ToObject&<boolean>;
  
  // Доступ к вложенному объекту "контакты"
  var contacts := person['контакты'];
  var email := contacts['электроннаяПочта'].ToString;
  var phone := contacts['телефон'].ToString;
  
  // Доступ к массиву "хобби"
  var hobbies := person['хобби'];
  var hobbyList := hobbies.ToObject&<array of string>;

  // Вывод извлеченных данных с ручным выравниванием
  Println($'Имя:                {name}');
  Println($'Возраст:            {age}');
  Println($'Является студентом: {isStudent}');
  Println($'Электронная почта:  {email}');
  Println($'Телефон:            {phone}');
  
  // Объединение элементов массива хобби в строку и вывод
  Println($'Хобби:              {hobbyList.JoinToString('', '')}');
end.

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

Файл data.json имеет следующее содержимое:

{
  "человек": {
    "имя": "Иван",
    "возраст": 30,
    "являетсяСтудентом": false,
    "контакты": {
      "электроннаяПочта": "[email protected]",
      "телефон": "123-456-7890"
    },
    "хобби": ["чтение", "путешествия", "плавание"]
  }
}

🚀 Пробуйте работать с JSON в своих проектах на PascalABC.NET и делитесь своими впечатлениями в комментариях! Мы всегда рады услышать ваше мнение и поддержать новые идеи. 💬

#PascalABCNET #JSON #DataParsing

Присваивание и сравнение динамических массивов

Работа с массивами в PascalABC.NET имеет свои особенности, особенно если речь идёт о динамических массивах. В этой новости разберём, как правильно присваивать, копировать и сравнивать такие массивы.

🔹 Присваивание динамических массивов

Когда вы присваиваете один динамический массив другому через оператор :=, происходит ссылочное присваивание. Это означает, что обе переменные ссылаются на один и тот же массив в памяти. Любые изменения в одном массиве автоматически отразятся на другом.

Пример:

var a := new integer[5]; // Создаём массив
var b := a; // b ссылается на тот же массив,что и a
b[0] := 10; // Теперь и a[0], и b[0] равны 10

Чтобы создать независимую копию массива, следует использовать встроенную функцию Copy(a).

Пример:

var a := new integer[5]; // Создаём массив
var b := Copy(a);        // b — это копия массива a
b[0] := 10;  // Изменение b не затрагивает a

🔹 Сравнение массивов

✦ Прямое сравнение массивов через оператор = проверяет ссылки, а не содержимое массивов. Даже если два массива содержат одинаковые элементы, они будут считаться неравными, если ссылаются на разные объекты в памяти.

Пример

var a, b: array of integer;
a := new integer[5];
b := new integer[5];
if a = b then // это сравнение вернёт False
  Println('Массивы равны')
else
  Println('Массивы не равны');

✦ Для корректного сравнения содержимого массивов в PascalABC.NET нужно использовать метод ArrEqual, который проверяет, равны ли все элементы двух массивов.

Пример:

var a := new integer[5];
var b := new integer[5];
if a.ArrEqual(b) then  // Проверяет равенство всех элементов массива
  Println('Массивы равны')
else
  Println('Массивы не равны');

🔹 Итоги:

✦ Для копирования массива используйте функцию Copy(a), чтобы избежать ссылочного присваивания.
✦ Для сравнения содержимого массивов используйте метод ArrEqual.

Это поможет вам избежать ошибок при работе с динамическими массивами и сделает ваш код более предсказуемым и надёжным! 🚀

Операции с массивами

Операции + и * с массивами позволяют быстро и эффективно конструировать массивы, заполняя их значениями. Для непрерывного диапазона элементов помогает также конструкция Arr(1..3).

Задание - из реального урока в компьютерной школе, под контролем системы невидимой автоматической проверки.

Сортировка выбором - минимизация обменов

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

В улучшенной версии сортировки выбором проверяется, найдено ли новое минимальное значение, и обмен выполняется только в случае необходимости. Это позволяет сократить число обменов, что особенно полезно для массивов, которые уже частично отсортированы.

Новый алгоритм выглядит так:

procedure SortByChoice(a: array of integer);
begin
  var n := a.Length;
  for var i := 0 to a.Length - 2 do
  begin
    var imin := i;

    for var j := i + 1 to n - 1 do
      if a[j] < a[imin] then
        imin := j;

    if imin <> i then
      Swap(a[imin], a[i]);
  end;
end;

🔥 Теперь алгоритм работает эффективнее за счёт уменьшения количества обменов! 🔥 Пробуйте и внедряйте это улучшение в свои программы! 🚀

Copilot - задача о поиске двух первых минимумов в массиве

Два запроса - два отличных ответа!

begin
  var arr := ArrRandomInteger(10);
  
  var min1, min2 := (MaxInt, MaxInt);
  
  foreach var x in arr do
    if x < min1 then
      (min1, min2) := (x, min1)
    else if x < min2 then
      min2 := x;
  
  Println('Сгенерированный массив: ', arr);
  Println('Первый минимум: ', min1);
  Println('Второй минимум: ', min2);
end.

и

begin
  var arr := ArrRandomInteger(10);
  
  var min1 := arr.Min();
  var min2 := arr.Where(x -> x <> min1).Min();
  
  Println('Сгенерированный массив: ', arr);
  Println('Первый минимум: ', min1);
  Println('Второй минимум: ', min2);
end.

Логирование в PascalABC.NET

✦ Устанавливаем пакет NLog командой nuget install NLog.
✦ Копируем dll в папку проекта
✦ Создаем конфигурационный файл nlog.config:

<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <targets>
    <target xsi:type="File" name="logfile" fileName="log.txt" />
  </targets>
  <rules>
    <logger name="*" minlevel="Info" writeTo="logfile" />
  </rules>
</nlog>

✦ Просим Copilot написать программу для логирования:

{$reference 'NLog.dll'}

uses NLog;

begin
  // Инициализация логгера
  LogManager.LoadConfiguration('nlog.config');
  var log := LogManager.GetCurrentClassLogger;
  
  // Запись логов
  log.Info('Программа запущена');
  
  try
    var a := 10;
    var b := 0;
    var c := a div b; // Это вызовет исключение
  except
    on e: Exception do
      log.Error('Ошибка: ' + e.Message);
  end;
  
  log.Info('Программа завершена');
end.

Вуаля!

Вычисление средних оценок студентов

Дан словарь оценок студентов. Вычислить для каждого студента среднюю оценку. Результат записать в новый словарь.

Трансформация части элементов массива

На скриншоте показана программа, в которой преобразуется часть элементов массива, удовлетворяющая некоторому условию. Для задания условия используется лямбда с условной операцией.

Используй принцип локальности при описании переменных!

Сегодня напомним об одном важном принципе, который делает ваш код более чистым, понятным и безопасным — принципе локальности при описании переменных.

Принцип локальности подразумевает, что переменные должны объявляться как можно ближе к месту их использования, а не в самом начале программы или функции. Это помогает избежать путаницы и ошибок при работе с переменными, особенно в больших и сложных проектах.

🔹 Почему это важно?

✦ Читаемость: Когда переменные объявляются рядом с кодом, который их использует, легче понять, для чего они нужны.
✦ Минимизация ошибок: Переменные, объявленные локально, реже влияют на другие части программы, что уменьшает шанс на случайные ошибки.
✦ Упрощение отладки: Когда переменная используется только в одном небольшом блоке кода, легче отследить, как она изменяется и откуда берутся значения.
✦ Экономия памяти: Локальные переменные занимают память только в пределах своего блока, что делает код более эффективным.

Использование атрибутов Combinatorial, Values и RangeAttribute при Unit-тестировании

Атрибуты Combinatorial, Values и RangeAttribute позволяют легко задавать разные наборы данных для тестов.

🔹 Combinatorial
Этот атрибут помогает комбинировать несколько наборов данных, применяемых к параметрам теста.

🔹 Values
С помощью атрибута Values можно указать несколько значений для одного параметра теста. Когда тест запускается, он выполняется с каждым из заданных значений, что позволяет проверить работу функции сразу на множестве входных данных.

🔹 RangeAttribute
Атрибут RangeAttribute позволяет указать диапазон значений, которые будут использоваться для параметра теста.

Использование этих атрибутов особенно полезно для тестирования методов с числовыми параметрами, чтобы покрыть различные диапазоны входных данных.

🧪 Unit-тестирование в PascalABC.NET

Один из лучших способов убедиться, что ваш код работает корректно, — это Unit-тестирование. В PascalABC.NET вы можете использовать популярный инструмент для тестирования — NUnit, который интегрирован в модуль NUnitABC. Изображенную на скрине программу надо запустить, используя Ctrl-Shift-T.

Тестирование с помощью NUnit — это не просто проверка кода, а способ сделать ваш проект стабильным, качественным и лёгким в поддержке. Внедряйте Unit-тестирование в ваш рабочий процесс, и ваши приложения станут надёжнее! 🚀

😈 Вредные советы для программистов на PascalABC.NET 😈

🎃 Совет 1: Никогда не проверяй код на ошибки. Если программа откомпилировалась — значит, всё работает идеально! А баги? Это фантазии пользователей.

🎃 Совет 2: Прояви немного уважения к программистам прошлого — объявляй все переменные до beginа основной программы. Зачем их размещать в блоке begin-end? Пусть поиск места первого присваивания такой переменной станет увлекательным квестом!

🎃 Совет 3: Используй глобальные переменные как можно больше! Глобальные переменные очень удобны, т. к. к ним можно обращаться отовсюду! И чем больше глобальных переменных — тем веселее искать причину ошибок!

🎃 Совет 4: Никогда не пиши комментарии. Пусть будущее поколение программистов с удивлением гадает, зачем этот код вообще существует.

🎃 Совет 5: Лишние скобки? Не заморачивайся, всё равно PascalABC.NET их поймёт! А ещё лучше — перемешивай их везде, где можно. Чем больше скобок, тем надёжнее программа!

🎃 Совет 6: Пиши всё в одну строку! Пробелы и отступы — для слабаков. Пусть коллеги попробуют разобрать этот шедевр без форматирования! И так код будет быстрее компилироваться!

🎃 Совет 7: Обязательно используй названия переменных вида a, b, c. Чем короче имя — тем быстрее работаешь. А тот, кто разберётся, что такое x9, будет настоящим героем!

🎃 Совет 8: Никогда не обновляй PascalABC.NET! Работает старая версия 2010 года? Зачем тогда что-то менять? Современные фишки — это излишество.

🎃 Совет 9: Писать тесты? Забудь! Тесты — для слабаков. Настоящие программисты сразу выкатывают код в продакшен!

🎃 Совет 10: Используй магические числа вместо констант. Пусть твой код выглядит загадочно и мистически! Никто не должен догадаться, зачем ты использовал 42 в каждом цикле.

🎃 Совет 11: Если что-то не работает, то, скорее всего, глючит компилятор. Попробуйте поменять местами некоторые переменные и строки кода.

🎃 Совет 12: Не пользуйся стандартной библиотекой языка! Что может быть интереснее, чем написать собственный алгоритм сортировки или собственное бинарное дерево? В своём коде уж точно не будет ошибок, а вот в стандартных функциях - ещё неизвестно!

🎃 Совет 13: Смело сравнивай числа с плавающей точкой с помощью операции =. Раз есть такая операция, значит ей нужно пользоваться.

🎃 Совет 14: Зачем инициализировать переменные, если там и так нули? Я вот недавно не инициализировал, и там ноль был. Всё работало.

🎃 Совет 15: Нет времени думать, копируй код многократно! Повторение — мать учения!

🎃 Совет 16: Выравнивание и единый стиль не дают раскрыться вашей индивидуальности и креативности. Это притеснение свободы личности и самовыражения. Каждый должен оформлять код так, как ему нравится.

🎃 Совет 17: Экономь память. Используй одну переменную для разных целей!

🎃 Совет 18: Статический массив — лучшее решение. И вообще, выделение памяти — зло. array[1..256] хватит всем, а если не хватит, то потом поменяем на 512. В крайнем случае – на 1024.

🎃 Совет 19: Если что-то не работает — просто добавь больше if-else. Логика обязательно сложится, а если нет, добавь ещё несколько уровней условий!

🎃 Совет 20: Настоящие программисты программируют только на PascalABC.NET. В крайнем случае на C++. И обязательно ругают Python!


😎 Эти советы точно помогут вам стать супер-программистом и на голову превзойти всех конкурентов! Научившись применять эти рекомендации на PascalABC.NET, используйте их затем и для других языков — они универсальны!

Снежинка Коха

Сегодня поговорим о создании одного из самых известных фракталов — снежинки Коха.

uses Turtle;

procedure Koch(sz: real; n: integer);
begin
  if n = 0 then
    Forw(sz)
  else begin
    Koch(sz/3,n-1); Turn(-60);
    Koch(sz/3,n-1); Turn(120);
    Koch(sz/3,n-1); Turn(-60);
    Koch(sz/3,n-1);
  end;
end;

begin
  Window.Title := 'Снежинка Коха';
  Turn(90);
  Forw(-10);
  Down;
  Koch(20,5);
end.

Программа построения снежинки Коха использует модуль Turtle. Алгоритм заключается в следующем:

Базовый случай: Если глубина рекурсии n=0, то рисуем отрезок длиной sz.

Рекурсивный случай: Если n>0:
✦ Разбиваем отрезок на три части.
✦ Рисуем первую треть отрезка и поворачиваем на 60° влево.
✦ Рисуем первую часть писка и поворачиваем на 120° вправо.
✦ Рисуем вторую часть пика и поворачиваем на 60° влево
✦ Рисуем последнюю треть отрезка.

Процесс повторяется для каждой стороны, добавляя всё больше деталей на каждом шаге.

#рекурсия #графика

Библиотеки в PascalABC.NET

Вот слайд с сегодняшней лекции по библиотекам.

Библиотеки отличаются от модулей по нескольким параметрам.

🔍 Метод Ньютона: Быстрый способ нахождения корней уравнений

Метод Ньютона — популярный численный метод нахождения корней уравнений с квадратичной сходимостью.

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

Метод Ньютона особенно эффективен для задач, где производная функции не равна нулю в окрестности корня.

function f(x: real) := exp(x) - 4; 
function df(x: real) := exp(x);    // Производная f'(x) = exp(x)

function NewtonMethod(x, eps: real): real;
begin
  while abs(f(x)) > eps do
    x := x - f(x) / df(x); 
  Result := x;
end;

begin
  var x := 0.5;       // Начальное приближение
  var eps := 0.00001; 

  var root := NewtonMethod(x, eps);
  
  Println('Корень уравнения: ', root);
end.

📝 Метод половинного деления: простой и эффективный способ нахождения корней уравнений

Один из классических численных методов — метод половинного деления. Этот метод позволяет находить корни нелинейных уравнений с высокой точностью. Его особенность заключается в том, что он работает на отрезке, где функция непрерывна и меняет знак, и последовательно делит этот отрезок пополам, приближаясь к решению.

Метод прост в реализации и гарантированно сойдется, если на выбранном интервале есть корень.

function f(x: real) := exp(x) - 4; 

function BisectionMethod(a, b, eps: real): real;
begin
  var fa := f(a); // Вычисляем f(a) один раз в начале
  while Abs(b - a) > eps do
  begin
    var c := (a + b) / 2;
    var fc := f(c); 
    if fc = 0 then
      break; 
    if fa * fc < 0 then
      b := c
    else
      (a, fa) := (c, fc); 
  end;
  Result := (a + b) / 2; 
end;

begin
  var (a, b) := (0.0, 3.0); 
  var eps := 0.000001;
  
  var root := BisectionMethod(a, b, eps);
  
  Println('Корень уравнения:', root);
end.

Реализация класса SortedMultiset

Перед вами - реализация класса мультимножества, реализованная ChatGPT. Идея использовать для реализации класс SortedDictionary с подсчетом количества дублей также принадлежит ChatGPT. Отличное решение!

Операции добавления, удаления, поиска и получения минимального/максимального элемента выполняются за O(log(n)) благодаря использованию сбалансированного дерева поиска, которое реализовано в SortedDictionary.

type
  SortedMultiset<T> = class(IEnumerable<T>)
  private
    data: SortedDictionary<T, integer>; // Храним элемент и количество его вхождений

  public
    // Конструктор
    constructor Create;
    begin
      data := new SortedDictionary<T, integer>();
    end;

    // Метод добавления элемента
    procedure Add(x: T);
    begin
      if data.ContainsKey(x) then
        data[x] := data[x] + 1 // Увеличиваем количество вхождений
      else
        data.Add(x, 1); // Добавляем новый элемент с количеством 1
    end;

    // Метод удаления элемента
    function Remove(x: T): boolean;
    begin
      if data.ContainsKey(x) then
      begin
        if data[x] > 1 then
          data[x] := data[x] - 1 // Уменьшаем количество вхождений
        else
          data.Remove(x); // Удаляем элемент, если это последнее вхождение
        Result := true;
      end
      else
        Result := false;
    end;

    // Метод получения количества вхождений элемента
    function Count(x: T): integer;
    begin
      if data.ContainsKey(x) then
        Result := data[x]
      else
        Result := 0;
    end;

    // Метод для получения минимального элемента
    function Min: T;
    begin
      if data.Count = 0 then
        raise new System.InvalidOperationException('Мультимножество пусто.');
      Result := data.Keys.First(); // Первый элемент в отсортированном множестве
    end;

    // Метод для получения максимального элемента
    function Max: T;
    begin
      if data.Count = 0 then
        raise new System.InvalidOperationException('Мультимножество пусто.');
      Result := data.Keys.Last(); // Последний элемент в отсортированном множестве
    end;

    // Метод для получения всех элементов множества
    function GetElements: sequence of T;
    begin
      foreach var key in data.Keys do
        for var i := 1 to data[key] do
          yield key;
    end;

    // Реализация интерфейса IEnumerable<T>
    function GetEnumerator: IEnumerator<T>;
    begin
      Result := GetElements().GetEnumerator();
    end;

    function System.Collections.IEnumerable.GetEnumerator: System.Collections.IEnumerator;
    begin
      Result := GetElements().GetEnumerator();
    end;
    
    // Метод для вывода множества
    procedure Print;
    begin
      foreach var e in self do
        Write(e, ' ');
      Writeln;
    end;
  end;

// Пример использования
begin
  var multiset := new SortedMultiset<integer>();
  multiset.Add(5);
  multiset.Add(3);
  multiset.Add(5);
  multiset.Add(2);
  
  multiset.Print(); // Вывод: 2 3 5 5
  
  multiset.Remove(5);
  multiset.Print(); // Вывод: 2 3 5
  
  Writeln('Min: ', multiset.Min); // Вывод: Min: 2
  Writeln('Max: ', multiset.Max); // Вывод: Max: 5
  Writeln('Количество 5: ', multiset.Count(5)); // Вывод: Количество 5: 1

  multiset.Println;
end.

🤖 Алгоритм кластеризации K-means, написанный ChatGPT!

Мир программирования не стоит на месте, и сегодня мы хотим рассказать вам об одном из самых популярных алгоритмов машинного обучения — K-means! Этот алгоритм помогает автоматически разделять данные на кластеры, что очень полезно в задачах анализа данных, сегментации пользователей, обработки изображений и многого другого.

Но самое интересное — алгоритм K-means был написан с помощью ChatGPT и теперь доступен для изучения и использования! 🎉 Мы подготовили специальный материал, который объяснит основные принципы работы этого алгоритма и покажет, как его можно реализовать на PascalABC.NET.

🔗 Полный код и объяснение по ссылке: https://teletype.in/@pascalabcnet/FLq12dPr2bW

💡 Чем полезен K-means?

✦ Простота реализации и высокая скорость работы.
✦ Эффективен при обработке больших объемов данных.
✦ Идеален для визуализации и анализа многомерных данных.

Если вы хотите разобраться в алгоритмах машинного обучения и применить их в своих проектах на PascalABC.NET, то K-means — отличный выбор для старта! 🚀

#МашинноеОбучение #Kmeans #Алгоритмы

Новый стандартный метод массивов IndexMinBy

В PascalABC.NET у массивов появился новый стандартный метод, который позволяет в массиве найти индекс минимального элемента после проекции на ключ.

На скриншоте - пример использования в массиве кортежей.

🆕 Новый метод Window.SaveToClipboard

В GraphWPF появился метод Window.SaveToClipboard сохранения содержимого окна в буфер обмена.

Теперь можно легко сохранять содержимое окна прямо в буфер обмена всего одной строкой кода! Это отличное решение для быстрого обмена информацией, создания скриншотов или копирования данных для дальнейшего использования.

🔧 Пример использования:

uses GraphWPF;

begin
  Circle(200,200,100,Colors.LightBlue);
  Window.SaveToClipboard;
end.

✨ Что это дает?
✦ Удобство в разработке: быстрое сохранение визуальных данных.
✦ Интеграция с другими приложениями: копируйте данные напрямую и вставляйте в любые другие программы.
✦ Экономия времени: больше не нужно использовать сторонние инструменты для захвата экранов.

Пробуйте новый метод и делитесь своими впечатлениями! 🚀

#новое

🚀 Генерация кластеров точек на плоскости

uses Coords;

function GenerateCluster(X, Y, spread: real; count: integer): array of Point;
begin
  Result := ArrGen(count, i -> new Point(
    RandomReal(X - spread / 2, X + spread / 2),
    RandomReal(Y - spread / 2, Y + spread / 2)
  ));
end;

begin
  Window.Title := 'Генерация кластеров';
  var cluster1 := GenerateCluster(5, 3, 5, 90);
  var cluster2 := GenerateCluster(7, -6, 4, 105);
  var cluster3 := GenerateCluster(-7, 2, 6, 44);
  
  DrawPoints(cluster1,3);
  DrawPoints(cluster2,3);
  DrawPoints(cluster3,PointRadius := 3);
end.

Здесь показано, как генерировать три кластера точек, используя:

✦ Автоклассы для создания типов данных
✦ Функцию ArrGen для генерации массивов
✦ Модуль Coords и функцию DrawPoints для визуализации массивов точек
✦ Функцию RandomReal(a, b) для получения случайных вещественных

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

#ЕГЭ #Графика #Кластеры #ГенерацияТочек

Мы начинаем повторные публикации некоторых старых постов нашего канала. Некоторые из них - очень удачные, и повторно хочется что то обсудить. Другие подойдут вновь подключившимся участникам.

Одна из них - про русский язык в программах. Источник многих споров. И - интересно - когда мы делали пакет для Alt Linux, я получил массу вопросов именно по модулю Исполнители, где имена на русском.

Русские имена в программах

В PascalABC.NET в качестве идентификаторов можно использовать русские имена. Это затрудняет написание программы, но повышает её читаемость.

В стандартных примерах PascalABC.NET имеется папка Русские исполнители - здесь приводится одна из программ.

Все имена в программе - русские. Даже параметры лямбд. В подсказках также - исключительно русский язык.

На наш взгляд, для примеров это - идеальный способ донести идею до начинающих.

#методика
#русский

🌐 Работа с сетевыми библиотеками .NET в PascalABC.NET 🌐

PascalABC.NET позволяет использовать мощные сетевые библиотеки .NET для создания приложений, которые могут взаимодействовать с веб-сервисами и сетевыми ресурсами. Сегодня рассмотрим, как с помощью класса System.Net.WebClient можно легко загружать данные из интернета.

📡 Пример: Загрузка веб-страницы с помощью .NET

uses System.Net;

begin
  var url := 'https://yandex.ru';
  var client := new WebClient;
  try
    var content := client.DownloadString(url);
    Println(content[:1000]);
  except
    on e: Exception do
      Println('Ошибка при загрузке данных:', e.Message);
  end;
end.

⚙️ В этом примере мы используем класс WebClient для получения данных с веб-страницы. С помощью методов этой библиотеки можно загружать как строки, так и файлы, а также отправлять запросы к API.

📡 Применение: Этот пример можно использовать для парсинга данных с веб-сайтов или создания простого сетевого клиента.

Откройте для себя возможности сетевых приложений с PascalABC.NET и библиотеками .NET!

#PascalABC #dotNET #Сети #Программирование #Pascal #Web