@romacll

Нахождение наименьшего общего кратного (НОК) на языке программирования Leo

2024-08-30T20:03:56.833Z

Введение

Наименьшее общее кратное (НОК) — это математическое понятие, которое имеет множество применений в реальных задачах, таких как синхронизация процессов, распределение ресурсов и даже криптография. В этой статье мы рассмотрим, как на языке Leo реализовать алгоритм для нахождения НОК двух и более чисел.

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

Зачем нужен НОК?

Прежде чем углубиться в программирование, давайте разберемся, почему НОК важен. Представьте себе две повторяющиеся задачи, которые выполняются через определенные временные интервалы. Например, одна задача запускается каждые 6 минут, а другая — каждые 8 минут. Чтобы определить, когда обе задачи выполнятся одновременно, нужно найти НОК этих двух чисел. В данном случае НОК равен 24 минутам. Подобные задачи часто встречаются в компьютерных системах, где необходимо синхронизировать различные процессы.

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

Основы языка Leo

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

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

Синтаксис и особенности

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

Пример простейшей программы на Leo: function main() {
let x = 5;
let y = 10;
let result = x + y;
console.log("Результат сложения:", result);
}

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

Математические вычисления на языке Leo

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

Алгоритм Евклида

Как уже было упомянуто, нахождение НОК тесно связано с нахождением наибольшего общего делителя (НОД). Наиболее популярным и эффективным методом нахождения НОД является алгоритм Евклида. Этот древний алгоритм используется уже на протяжении тысячелетий и остаётся одним из самых быстрых способов вычисления НОД.

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

function gcd(a: u32, b: u32) -> u32 {
let mut x = a;
let mut y = b;

while y != 0 {
let temp = y;
y = x % y;
x = temp;
}

return x;
}

Этот код реализует алгоритм Евклида на языке Leo. Он использует цикл while для итеративного вычисления НОД двух чисел.

Применение НОК в реальной жизни

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

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

В производственных системах, где машины работают с различными интервалами обслуживания, вычисление НОК может помочь определить, когда потребуется остановить обе машины для профилактики. Это позволяет лучше планировать обслуживание и предотвращать незапланированные простои.

НОК и криптография

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

Расширенная реализация на языке Leo

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

function lcm_array(numbers: [u32; N]) -> u32 {
let mut result = numbers[0];

for i in 1..N {
result = lcm(result, numbers[i]);
}

return result;
}

Эта функция принимает массив чисел и последовательно вычисляет НОК для каждой пары чисел, пока не будет получен общий НОК для всего массива.

Обработка больших данных

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

Обработка больших данных

Этот код реализует рекурсивный метод вычисления НОК с использованием принципа "разделяй и властвуй". Разбивая массив чисел на две части и вычисляя НОК для каждой половины, можно значительно ускорить выполнение программы на больших данных.

Тестирование и отладка программы

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

Пример тестовых данных:

Числа 3, 5, 7, 11 — результат должен быть 1155.
Числа 10, 20, 30, 40 — результат должен быть 120.
Числа 8, 9, 21 — результат должен быть 504.

Эти тесты позволяют проверить корректность алгоритма и его способность обрабатывать разные наборы данных.

Применение на практике: блокчейн и смарт-контракты

Leo был разработан для работы в рамках блокчейн-платформы Aleo, которая нацелена на создание приватных и конфиденциальных смарт-контрактов. В блокчейн-среде смарт-контракты могут использовать алгоритмы нахождения НОК и НОД для управления криптографическими операциями и распределения ресурсов.

Например, смарт-контракт может использовать алгоритм нахождения НОК

Нахождение наименьшего общего кратного двух чисел на Leo

2024-08-28T18:07:21.140Z

Привет! Сегоднчя мы решаем интересную и достаточно сложную задачу на языке программирования Leo от проекта Aleo. Полный текст задачи выглядит так:

Давайте начнем с изучения алгоритма поиска наименьшего общего кратного (далее НОК):

Открываем Aleo Studio и создаем новый проект.

У нас создалась базовая программа, изменяем вход и выход функции main. На входе две переменные типа u32, НОК которых мы и будем находить. На выходе функции переменная также типа u32, она будет хранить в себе НОК.

Для начала находим наибольший общий делитель (далее НОД) с помощью алгоритма, указанного ранее. Создаем вспомогательную переменную ost в которой будет храниться остаток от деления большего числа на меньшее.

Теперь создаем цикл for с помощью которого будем делать перебор. В идеале было бы использовать цикл while, но Leo его пока не поддерживает.

Следующим шагом добавляем условия проверки, является ли остаток равным нулю и также у нас появляются два случая: когда a > b и когда b > a.

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

Теперь нам нужно найти остаток от деления меньшей переменной на остаток.

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

Самое сложное мы сделали, теперь в переменной l_ost хранится НОД чисел. Создадим переменную nok в которую сохраним результат работы программы, а также переменную mult в которой будет хранится перемноженное значение переменных a и b (она требуется при нахождении НОК, используя НОД).

Осталось в переменную nod записать формулу и вывести её по результату работы программы. Итоговый код выглядит так:

transition main(a: u32, b:u32) -> u32 {
        let ost: u32 = 0u32;
        let l_ost: u32 = 0u32;
        let nok: u32 = 0u32;
        let mult: u32 = a*b;
            for i: u32 in 1u32..10u32 {
                if b != 0u32 {
                    if a > b {
                        ost = a.rem(b);
                        l_ost = ost;
                        ost = b.rem(ost);
                    }
                    if b > a {
                        ost = b.rem(a);
                        l_ost = ost;
                        ost = a.rem(ost);
                    }
                }
            }
            nok = mult / l_ost;
            return nok;
    }

Давайте проверим наш код с этими входными данными:

Мы должны получить 60. Запускаем нашу программу:

Всё верно, наша программа работает корректно. До встречи в следующих статьях!

Проверка числа на совершенное на Leo

2024-08-27T23:10:34.961Z

Привет! Сегодня мы создадим функцию на языке программирования Leo от проекта Aleo, которая будет определять, является ли полученное число совершенным. Полную задачу вы можете изучить ниже:

Логика программы следующая: мы делаем перебор от 1 до значения переменной, проверяя, делится ли данное число без остатка на нашу переменную, если да, тогда мы суммируем делитель с остальными делителями числа. И далее проверяем, равна ли сумма делителей нашей переменной.

Давайте приступим и создадим новую программу через Aleo Studio:

У нас создалась базовая функция main, изменим в ней вход функции на одну переменную a типа u32, а на выходе функции переменная типа boolean (true, если число совершенное, иначе, false):

Теперь давайте создадим переменную, которая будет хранить сумму всех делителей, переменной а.

Следующим шагом создадим переменную result, она будет иметь тип bool и хранить в себе результат работы программы.

Теперь создаем цикл перебора, в идеале должен быть перебор от 1 до а, но leo это не поддерживает, поэтому просто берем число в рамках которого будет значение переменной a.

В условном выражении прописываем условие. С помощью оператора rem определяем, является ли итерация i делителем и также проверяем, чтобы мы не выходили за значение переменной a (при i > a делителей быть не может). И если i является делителем, тогда прибавляем i к переменной num

Теперь сравниваем num и a. Если они равны, тогда число совершенное и переменная result имеет значение true.

Итак, наша программа готова:

program soversh.aleo { 
    transition main(a: u32) -> bool { 
        let num: u32 = 0u32; 
        let result: bool = false; 
            for i: u32 in 1u32..100u32 { 
                if a.rem(i) == 0u32 && i < a { 
                    num = num + i; 
                } 
            if num == a { 
                result = true; 
                } 
            } 
            return result; 
    } 
}

Давайте введем число 131:

И получаем false:

Если же введем число 28, которое является совершенным получаем true:

Да! Всё верно. На этом всё, увидимся в следующей статье.

Разность суммы четных и нечетных чисел на Leo

2024-08-27T23:03:58.662Z

Всем привет! Давно мы с вами не говорили о языке программирования Leo от проекта Aleo. Пора это исправлять и сегодня мы решим данную задачу:

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

Давайте приступать. Открываем Aleo Studio и создаем новую программу.

У нас создалась автоматически функция main, давайте её модифицировать.

Для начала меняем вход функции, на входе будут 5 переменных типа u32, а на выходе также переменная типа u32 (разность сумм).

Теперь нам нужно создать 2 переменные, которые будут хранить в себе суммы четных и нечетных чисел соответственно. Назовем их "ch" для четных и "nch" для нечетных, они будут иметь также тип u32 и по умолчанию значение 0.

Теперь пишем основной алгоритм для начала для переменной a. Для определения, является ли переменная четной или нечетной используем оператор rem, находя остаток от деления на 2. Если остаток равен 0, тогда переменная четная и прибавляем эту переменную к переменной ch, иначе, к переменной nch. В коде это выглядит следующим образом:

Теперь проделываем те же самые алгоритмы с остальными переменными:

Далее давайте проверим, корректно ли считаются суммы четных и нечетных чисел. Для этого на выходе функции поставим переменные ch и nch.

Впишем следующие входные данные:

Таким образом, мы должны получить 6 (четные) и 8 (нечетные). Давайте запустим нашу программу.

Да, программа работает верно.

Создадим вспомогательную переменную, назовем её sum.

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

Запускаем нашу программу:

К сожалению, мы получили данную ошибку. Чтобы ее исправить меняем тип всех переменных с u32 на i32. Итоговый код:

program ex_sum.aleo { 
    transition main(a: i32, b: i32, c: i32, d: i32, e:i32) -> i32 { 
        let ch: i32 = 0i32; 
        let nch: i32 = 0i32; 
        let sum: i32 = 0i32; 
            if a.rem(2i32) == 0i32 { 
                ch = ch + a; 
            } else { 
                nch = nch + a; 
            } 
            if b.rem(2i32) == 0i32 { 
                ch = ch + b; 
            } else { 
                nch = nch + b; 
            } 
            if c.rem(2i32) == 0i32 { 
                ch = ch + c; 
            } else { 
                nch = nch + c; 
            } 
            if d.rem(2i32) == 0i32 { 
                ch = ch + d; 
            } else { 
                nch = nch + d; 
            } 
            if e.rem(2i32) == 0i32 { 
                ch = ch + e; 
            } else { 
                nch = nch + e; 
            } 
            if nch >= ch { 
            sum = nch - ch; 
            } else { 
            sum = ch - nch; 
            } 
            return sum; 
    } 
}

Даем следующие входные данные:

Теперь наша программа работает верно:

На этом всё! До встречи в следующих статьях, пока!

Aleo Instructions and snarkVM: A Comprehensive Guide

2024-07-25T13:22:15.162Z

Introduction

Welcome to the comprehensive guide on Aleo instructions and snarkVM. This guide aims to provide an in-depth understanding of Aleo instructions, the intermediate representation of Aleo programs. All Leo programs are compiled into Aleo instructions, which are then compiled into bytecode. Understanding Aleo instructions is crucial for those interested in fine-grained circuit design or implementing a compiler that reads a high-level language other than Leo and runs on Aleo.

Aleo Instructions Overview

Aleo programs are defined in files with a .aleo extension. These programs contain Aleo instructions, which are akin to an assembly-like programming language. Aleo instructions serve as an intermediate step between high-level Leo programs and the low-level bytecode executed by the Aleo Virtual Machine (AVM).

The Compilation Process

Leo to Aleo Instructions: High-level Leo programs are first compiled into Aleo instructions. This step involves translating the more abstract and user-friendly Leo syntax into a more granular and detailed set of operations.
Aleo Instructions to Bytecode: The Aleo instructions are then compiled into AVM opcodes, the bytecode that the Aleo Virtual Machine can execute. This bytecode is optimized for execution efficiency and security within the AVM.

Key Concepts and Features

1. File Import

In Aleo, you can import modules or other program files to utilize their functions, records, and other definitions.

import foo.aleo;

This statement imports the foo.aleo file, allowing you to use its contents in your current program.

2. Programs

An Aleo program is defined with the program keyword followed by the program name. Inside the program block, you can define various elements such as records, functions, and transitions.

program hello.aleo {
    // code
}

This defines a new program named hello.aleo.

3. Data Types

Aleo supports several primitive data types essential for blockchain programming:

Boolean: Represents a true or false value.
Unsigned Integer: Represents non-negative integers with different bit sizes (e.g., u8, u32).
Field Element: Represents elements of a finite field, useful in cryptographic operations.
Group Element: Represents elements of a cryptographic group.
Scalar Element: Used in elliptic curve cryptography operations.
Address: Represents a user or contract address on the Aleo blockchain.

let b: bool = false; // boolean
let i: u8 = 1u8; // unsigned integer
let a: field = 1field; // field element
let g: group = 0group; // group element
let s: scalar = 1scalar; // scalar element
let receiver: address = aleo1ezamst4pjgj9zfxqq0fwfj8a4cjuqndmasgata3hggzqygggnyfq6kmyd4; // address

Type Casting Type casting allows you to convert a value from one type to another.

let a: u8 = 1u8;
let b: u32 = a as u32; // cast 1u8 to 1u32

4. Records

Records in Aleo are used to group related data together under one name.

record token {
    owner: address,
    amount: u64,
}

This defines a token record with two fields: owner (an address) and amount (an unsigned 64-bit integer).

5. Structs

Structs in Aleo provide a way to model more complex data structures.

struct message {
    sender: address,
    object: u64,
}

This defines a message struct with a sender (an address) and an object (an unsigned 64-bit integer).

6. Arrays

Arrays in Aleo are collections of elements of the same type.

let arr: [bool; 2] = [true, false];

This creates an array arr of two boolean values, true and false.

7. Transitions

Transitions define state changes in the blockchain and can take public or private inputs to produce a new state.

transition mint_public(
    public receiver: address,
    public amount: u64,
) -> token {
    // Your code here
}

This mint_public transition takes a receiver address and an amount, returning a token record.

8. Functions

Functions in Aleo are reusable blocks of code that perform specific tasks.

function compute(a: u64, b: u64) -> u64 {
    return a + b;
}

This compute function takes two unsigned 64-bit integers and returns their sum.

9. Inline Functions

Inline functions are more restricted and meant for simple, reusable code snippets.

inline foo(
    a: field,
    b: field,
) -> field {
    return a + b;
}

This foo inline function adds two field elements and returns the result.

Function rules:

Transition functions can call functions and inline functions.
Function functions can only call inline functions.
Inline functions can only call other inline functions.
Recursive calls (direct or indirect) are not allowed.

10. For Loops

For loops iterate over a range of values.

let count: u32 = 0u32;

for i: u32 in 0u32..5u32 {
    count += 1u32;
}

This loop increments count from 0 to 5.

11. Mappings

Mappings associate keys with values, similar to dictionaries or hash maps.

mapping balances: address => u64;

let contains_bal: bool = Mapping::contains(balances, receiver);
let get_bal: u64 = Mapping::get(balances, receiver);
let get_or_use_bal: u64 = Mapping::get_or_use(balances, receiver, 0u64);
let set_bal: () = Mapping::set(balances, receiver, 100u64);
let remove_bal: () = Mapping::remove(balances, receiver);

12. Commands

Commands perform specific blockchain operations, such as asserting conditions or generating random numbers.

transition matches(height: u32) -> Future { 
    return check_height_matches(height); 
}

async function check_height_matches(height: u32) {
    assert_eq(height, block.height); // block.height returns the latest block height
}

let g: group = group::GEN; // the group generator
let result: u32 = ChaCha::rand_u32(); // generate a random u32
let owner: address = self.caller; // address of the program function caller
let hash: field = BHP256::hash_to_field(1u32); // hash any type to a field
let commit: group = Pedersen64::commit_to_group(1u64, 1scalar); // commit using a scalar as a blinding factor

let a: bool = true;
assert(a); // assert the value of a is true

let a: u8 = 1u8;
let b: u8 = 2u8;
assert_eq(a, a); // assert a and b are equal
assert_neq(a, b); // assert a and b are not equal

13. Operators

Operators perform arithmetic, bitwise, and logical operations on data.

let sum: u64 = a + b; // arithmetic addition
let diff: u64 = a - b; // arithmetic subtraction
let prod: u64 = a * b; // arithmetic multiplication
let quot: u64 = a / b; // arithmetic division
let remainder: u64 = a % b; // arithmetic remainder
let neg: u64 = -a; // negation

let bitwise_and: u64 = a & b; // bitwise AND
let bitwise_or: u64 = a | b; // bitwise OR
let bitwise_xor: u64 = a ^ b; // bitwise XOR
let bitwise_not: u64 = !a; // bitwise NOT

let logical_and: bool = a && b; // logical AND
let logical_or: bool = a || b; // logical OR
let eq: bool = a == b; // equality
let neq: bool = a != b; // non-equality
let lt: bool = a < b; // less than
let lte: bool = a <= b; // less than or equal
let gt: bool = a > b; // greater than
let gte: bool = a >= b; // greater than or equal

Conclusion

Understanding Aleo instructions and snarkVM is essential for anyone looking to delve deeper into the Aleo ecosystem. By mastering the intermediate representation of Aleo programs, developers can achieve fine-grained control over their circuit designs and optimize their applications for the Aleo blockchain. Whether you're transitioning from Leo or implementing a new compiler, this guide serves as a foundational resource for working with Aleo instructions and snarkVM.

Leo Syntax Cheatsheet

2024-07-24T03:07:37.691Z

1. File Import

In Aleo, you can import modules or other program files to utilize their functions, records, and other definitions in your program. This is similar to import statements in other programming languages like Python or JavaScript.

import foo.aleo;

This statement imports the foo.aleo file, allowing you to use its contents in your current program.

2. Programs

An Aleo program is defined with the program keyword followed by the program name. Inside the program block, you can define various elements such as records, functions, and transitions.

program hello.aleo {
    // code
}

This defines a new program named hello.aleo. The program's code goes inside the curly braces.

3. Data Types

Aleo supports several primitive data types that are commonly used in blockchain programming.

Boolean: Represents a true or false value.
Unsigned Integer: Represents non-negative integers with different bit sizes (e.g., u8, u32).
Field Element: Represents elements of a finite field, useful in cryptographic operations.
Group Element: Represents elements of a cryptographic group.
Scalar Element: Used in elliptic curve cryptography operations.
Address: Represents a user or contract address on the Aleo blockchain.

let b: bool = false; // boolean
let i: u8 = 1u8; // unsigned integer
let a: field = 1field; // field element
let g: group = 0group; // group element
let s: scalar = 1scalar; // scalar element
let receiver: address = aleo1ezamst4pjgj9zfxqq0fwfj8a4cjuqndmasgata3hggzqygggnyfq6kmyd4; // address

Type Casting Type casting allows you to convert a value from one type to another. This is useful when you need to operate on values of different types.

let a: u8 = 1u8;
let b: u32 = a as u32; // cast 1u8 to 1u32

Primitive types include: address, bool, field, group, i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, scalar. Casting is possible between these types, ensuring flexibility in handling different data types.

4. Records

Records in Aleo are similar to structs in other languages. They are used to group related data together under one name.

record token {
    owner: address,
    amount: u64,
}

This defines a token record with two fields: owner (an address) and amount (an unsigned 64-bit integer).

5. Structs

Structs are another way to group related data, providing a way to model more complex data structures.

struct message {
    sender: address,
    object: u64,
}

This defines a message struct with a sender (an address) and an object (an unsigned 64-bit integer).

6. Arrays

Arrays in Aleo are collections of elements of the same type.

let arr: [bool; 2] = [true, false];

This creates an array arr of two boolean values, true and false.

7. Transitions

Transitions are special functions that define state changes in the blockchain. They can take public or private inputs and produce a new state.

transition mint_public(
    public receiver: address,
    public amount: u64,
) -> token {
    // Your code here
}

This mint_public transition takes a receiver address and an amount, then returns a token record. The public keyword indicates that these inputs are visible to everyone.

8. Functions

Functions in Aleo are reusable blocks of code that perform specific tasks. They can accept parameters and return values.

function compute(a: u64, b: u64) -> u64 {
    return a + b;
}

This compute function takes two unsigned 64-bit integers and returns their sum.

9. Inline Functions

Inline functions are a more restricted type of function meant for simple, reusable code snippets. They can only be called within other inline functions or regular functions.

inline foo(
    a: field,
    b: field,
) -> field {
    return a + b;
}

This foo inline function adds two field elements and returns the result.

Function rules:

Transition functions can call functions and inline functions.
Function functions can only call inline functions.
Inline functions can only call other inline functions.
Recursive calls (direct or indirect) are not allowed to prevent infinite loops and ensure predictable execution.

10. For Loops

For loops in Aleo iterate over a range of values.

let count: u32 = 0u32;

for i: u32 in 0u32..5u32 {
    count += 1u32;
}

This loop increments count from 0 to 5.

11. Mappings

Mappings in Aleo are similar to dictionaries or hash maps in other languages. They associate keys with values.

mapping balances: address => u64;

let contains_bal: bool = Mapping::contains(balances, receiver);
let get_bal: u64 = Mapping::get(balances, receiver);
let get_or_use_bal: u64 = Mapping::get_or_use(balances, receiver, 0u64);
let set_bal: () = Mapping::set(balances, receiver, 100u64);
let remove_bal: () = Mapping::remove(balances, receiver);

This snippet defines a balances mapping from addresses to unsigned 64-bit integers and demonstrates various operations on the mapping.

12. Commands

Commands in Aleo allow you to perform specific blockchain operations, such as asserting conditions or generating random numbers.

transition matches(height: u32) -> Future { 
    return check_height_matches(height); 
}

async function check_height_matches(height: u32) {
    assert_eq(height, block.height); // block.height returns the latest block height
}

let g: group = group::GEN; // the group generator
let result: u32 = ChaCha::rand_u32(); // generate a random u32
let owner: address = self.caller; // address of the program function caller
let hash: field = BHP256::hash_to_field(1u32); // hash any type to a field
let commit: group = Pedersen64::commit_to_group(1u64, 1scalar); // commit using a scalar as a blinding factor

let a: bool = true;
assert(a); // assert the value of a is true

let a: u8 = 1u8;
let b: u8 = 2u8;
assert_eq(a, a); // assert a and b are equal
assert_neq(a, b); // assert a and b are not equal

Commands include assertions and various cryptographic operations essential for blockchain functionality.

13. Operators

Operators in Aleo allow you to perform arithmetic, bitwise, and logical operations on data.

let sum: u64 = a + b; // arithmetic addition
let diff: u64 = a - b; // arithmetic subtraction
let prod: u64 = a * b; // arithmetic multiplication
let quot: u64 = a / b; // arithmetic division
let remainder: u64 = a % b; // arithmetic remainder
let neg: u64 = -a; // negation

let bitwise_and: u64 = a & b; // bitwise AND
let bitwise_or: u64 = a | b; // bitwise OR
let bitwise_xor: u64 = a ^ b; // bitwise XOR
let bitwise_not: u64 = !a; // bitwise NOT

let logical_and: bool = a && b; // logical AND
let logical_or: bool = a || b; // logical OR
let eq: bool = a == b; // equality
let neq: bool = a != b; // non-equality
let lt: bool = a < b; // less than
let lte: bool = a <= b; // less than or equal
let gt: bool = a > b; // greater than
let gte: bool = a >= b; // greater than or equal

This section demonstrates the use of various operators for performing different types of operations on data in Aleo.

Калькулятор штрафов за превышение скорости на Leo

2024-07-23T11:34:17.757Z

Привет! Мы продолжаем изучать язык программирование Leo, который создала команда проекта Aleo. И сегодня мы решим такую задачу от ChatGPT:

Задача достаточно простая, но здесь есть сложности с работой с отрицательными числами. Но обо всём по порядку. Для начала создаём новый проект в Aleo Studio

Создалась базовая программа

К нам в функцию main поступают переменные speed_limit и actual_speed, они имеют тип i32, это нужно, так как мы будем вычитать из актуальной скорости лимит и это значение может быть отрицательным, если нет никаких нарушений. На выходе функции переменная типа i32, она будет хранить в себе сумму штрафа

Теперь давайте создадим переменную penalty, она будет хранить в себе сумму штрафа и мы будем выводить её по результатам работы программы. По умолчанию штраф равен 0.

Далее мы начинаем сравнивать ограничение и актуальную скорость. Если скорость минус ограничение больше 0 и меньше 10, тогда штраф равен 50.

Тоже самое прописываем для разницы больше 10, но меньше 20

Если же превышение больше, чем на 20, тогда штраф равен 200

Возвращаем переменную penalty и так выглядит наш итоговый код

Вводим, например, такие входные данные:

Соответсвенно превышение на 15 километров в час и штраф должен быть 100. Запускаем нашу программу

Да, всё работает корректно! Мы выполнили задачу правильно. До встречи в следующих уроках

Проверка числа на число Армстронга на Leo

2024-07-22T13:24:41.352Z

Всем привет! В данной статье мы решим задачу, которую нам предложил ChatGPT. Она выглядит следующим образом:

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

То есть мы должны провести данный расчёт. Находим все цифры числа и возводим их в степень, равную количеству цифр. Для начала открываем Aleo Studio и создаём новый проект.

У нас создалась базовая функция main, давайте её менять:

У нас в функцию поступает одна переменная, которую мы будем проверять, является ли её значение числом Армстронга. Она будет иметь тип u32. На выходе функции переменная boolean, если значение переменной является числом Армстронга, то мы возвращаем true, иначе, false

Теперь давайте для дальнейшей работы продублируем значение переменной a в еще одну переменную. Пусть это будет переменная b.

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

Давайте для проверки выведем цифры нашего числа (они должны быть задом наперед)

С этими входными данными:

Если всё работает верно, мы должны получить 321

Да, всё работает! Создадим переменную result, она будет иметь тип boolean.

Переходим к последнему этапу. Если переменная a равняется необходимым вычислениям, тогда result будет иметь значение true.

Нам остается вернуть переменную result.

Запускаем нашу программу с предыдущими входными данными. В них число 123, которое не является числом Армстронга, так что мы должны получить false.

Если же мы отправим число 153

Мы получаем true

Всё верно! Наша программа работает корректно. До встречи в следующих статьях по проекту Aleo и языку программирования Leo.

Поиск среднего значения списка без минимального и максимального элементов на Leo

2024-06-30T08:07:33.081Z

Всем привет! Сегодня мы решим такую необычную задачу на языке программирования Leo, который создан проектом Aleo:

Для начала конечно же открываем Aleo Studio и создаем новый проект.

У нас создалась базовая программу с функцией main.

Теперь меняем вход и выход функции. На входе функции 5 переменных типа u32, на выходе одна переменная типа u32, которая будет хранить в себе среднее арифметическое.

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

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

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

Следующим шагом ищем наибольшее число. Будем искать его следующим способом: если a > b, тогда задаем переменной b значение переменной a. И по очереди перебираем до переменной e. В коде это выглядит так:

Сейчас наибольшее число хранится в переменной e, зададим значение переменной highest переменной e.

Делаем тоже самое только с обратным действием для поиска наименьшего числа:

Теперь находим среднее арифметическое по принципу, который я описал вначале статьи и возвращаем переменную result:

Вписываем входные данные:

Исходя из этих данных мы должны получить 120.

Всё верно, мы получили правильный результат, а значит выполнили задачу. До встречи в следующем уроке!

Решаем задачи от новой версии ChatGPT 4o #4

2024-06-15T21:32:04.207Z

Привет! Рад видеть вас в 4ой статье, где мы изучаем язык программирования Leo от проекта Aleo, используя ChatGPT 4O.

Напоминаю, мы делали этот запрос в ChatGPT:

Четвёртая задача имеет следующее содержание:

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

Создадим новый проект в Aleo Studio, назовём его ex4.

Теперь у нас есть базовая функция main, давайте её модифицировать:

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

Создадим переменную frg, которая будет хранить преобразованное значение.

Далее исходя из задачи использовать константы, хочется создать константы со значением 9/5 и 32 (забегая вперед скажу, что это не сработает), и задать переменной frg значение в виде формулы, где цифры мы заменим константами.

Но если мы запустим код со входными данными 20, то получим 52, что неправильно.

Это происходит из-за того что Leo не поддерживает дробные числа, поэтому округляет 9/5, причем до единицы.

Поэтому нам следует просто вынести из константы 9/5 и сразу записать в формулу:

Теперь запускаем со входными данными 20.

И мы получили 68, что является правильным результатом.

На этом всё! До встречи в следующих статьях по проекту Aleo и языку программирования Leo.