Лига программистов C/C++

Недавно устроился на новую работу в связи с банкротством компании, в которой работал. Поскольку начинаю работать только в Сентябре, решил порешать задачки с leetcode, чтоб совсем мозги не закисали.

И вот одна из этих задачек. Даны два числа, представленные связными списками. Каждый элемент списка - это один знак этого числа. Причём в обратном порядке. Т.е. 721 будет выглядеть так: 1 -> 2 -> 7

Задача написать функцию, складывающую эти два числа. И дана уже заготовка кода.

/**

* Definition for singly-linked list.

* struct ListNode {

* int val;

* ListNode *next;

* ListNode() : val(0), next(nullptr) {}

* ListNode(int x) : val(x), next(nullptr) {}

* ListNode(int x, ListNode *next) : val(x), next(next) {}

* };

*/

class Solution {

public:

ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {}

};

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

class Solution {

public:

ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {

if((l1 != nullptr) || (l2 != nullptr) || (carry != 0) ) {

int tmp_result = ((l1 != nullptr) ? l1->val : 0) + ((l2 != nullptr) ? l2->val : 0) + carry;

if(tmp_result >= 10) {

carry = 1;

tmp_result -= 10;

} else {

carry = 0;

}

return new ListNode(tmp_result, addTwoNumbers((l1 != nullptr) ? l1->next : nullptr, (l2 != nullptr) ? l2->next : nullptr));

} else {

return nullptr;

}

}

private:

int carry = 0;

};

А причём тут ИИ, спросите вы? Да после того, как решил эту задачу, решил посмотреть, как её решит ИИ. А сделал он достаточно топорно, а именно так, как я хотел решать изначально.

class Solution {

public:

ListNode* addTwoNumbers(ListNode* _l1, ListNode* _l2) {

// Create a dummy head to simplify the list construction logic

ListNode* dummyHead = new ListNode(0);

ListNode* currentNode = dummyHead;

int carryValue = 0;

// Iterate while there are nodes in either list or a carry remains

while (_l1 != nullptr || _l2 != nullptr || carryValue != 0) {

// Get values from the current nodes, default to 0 if list is exhausted

int firstVal = (_l1 != nullptr) ? _l1->val : 0;

int secondVal = (_l2 != nullptr) ? _l2->val : 0;

// Calculate the sum of the digits and the current carry

int sumValue = firstVal + secondVal + carryValue;

carryValue = sumValue / 10;

// Create a new node with the digit part of the sum

currentNode->next = new ListNode(sumValue % 10);

currentNode = currentNode->next;

// Advance the pointers of the input lists

if (_l1 != nullptr) {

_l1 = _l1->next;

}

if (_l2 != nullptr) {

_l2 = _l2->next;

}

}

// Store the actual head of the result list

ListNode* resultHead = dummyHead->next;

// Free the dummy head memory to prevent memory leaks

delete dummyHead;

return resultHead;

}

};

На самом leetcode есть несколько решений к данной задаче. И нет ни одного решения с рекурсией. Да, я понимаю, многие не любят рекурсию и считают её антипаттерном, но тем не менее, задание тестовое, есть конструктор, кричащий: "Будь мужиком, заюзай рекурсию, б***ь!". По мне так, вариант с рекурсией выглядит проще и элегантнее.

Вывод напрашивается сам собой. Да, ИИ решит задачу. Но решит её так, чтоб она просто работала, т.е. на уровне индуса. А вот если надо проявить креативность, тут уже не так всё радужно. Хотя, зная, что это по сути языковая модель, а не интеллект, ожидать какой-то креативности от него не стоит.

P.S. Да, я знаю, что вместо (l1 != nullptr) можно было написать просто l1, но я предпочитаю именно такую запись в своём коде. Чтоб другие разрабы не искали каждый раз, что за переменные l1, l2, а уже понимали, что это какие-то указатели.

Автор: Денис Аветисян

Исследование потенциала больших языковых моделей для прямой компиляции кода без традиционных этапов обработки.

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

Несмотря на значительные успехи в различных областях, возможность использования больших языковых моделей (LLM) в качестве полноценных компиляторов оставалась малоизученной. Данная работа, 'Exploring the Feasibility of End-to-End Large Language Model as a Compiler', посвящена исследованию потенциала LLM для прямой трансляции исходного кода в машинный, с акцентом на разработку датасета CompilerEval и фреймворка LaaC. Эксперименты показали, что LLM демонстрируют базовые способности к компиляции, однако текущий процент успешной компиляции остается низким. Возможно ли, путем оптимизации запросов, масштабирования моделей и внедрения методов рассуждения, создать LLM, способные генерировать высококачественный ассемблерный код и изменить парадигму компиляции?

Эволюция Компиляции: От Надежности к Гибкости

Традиционная компиляция, несмотря на свою надежность, представляет собой сложный и ресурсоемкий процесс. Растущий спрос на кроссплатформенность и поддержку специализированного оборудования требует адаптивных решений. Технологии искусственного интеллекта, в частности, большие языковые модели (LLM), предлагают принципиально новый подход к компиляции, способный упростить и ускорить разработку. Прозрачность алгоритмов – ключ к безопасному и эффективному программному обеспечению.

Возможность сквозной компиляции с использованием LLM демонстрирует потенциал для упрощения процесса разработки.

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

Предлагаемый подход основан на непосредственном преобразовании исходного кода в машинный язык с использованием больших языковых моделей (LLM), минуя традиционные этапы компиляции. Разработанная платформа LaaC (LLM as a Compiler) является развитием данной идеи, ключевым компонентом которой является база знаний, содержащая информацию об исходных языках и наборах инструкций целевых архитектур. Несмотря на перспективность, текущие показатели успешной компиляции остаются относительно невысокими.

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

CompilerEval: Строгий Анализ Возможностей LLM

Для систематической оценки возможностей больших языковых моделей (LLM) в генерации ассемблерного кода разработана платформа CompilerEval, использующая специализированный набор данных CompilerEval Dataset. В рамках исследования была проведена оценка коэффициента успешной компиляции (Compilation Success Rate) для LLM, включая GPT-4o, Gemini-2.0, Claude-3.5 и Llama-3, на различных аппаратных архитектурах. Результаты демонстрируют зависимость эффективности от архитектуры и используемой модели.

Применение методов оптимизации запросов (Prompt Engineering) позволило улучшить показатели успешной компиляции. Так, для Claude-3.5-Sonnet наблюдалось увеличение на 7,5%, для GPT-4o с применением Chain-of-Thought – на 5%, а масштабирование Llama с Llama-70B до Llama-405B дало прирост в 1,55%.

Кроссплатформенность и Перспективы Будущего

Оценка продемонстрировала потенциал LLM для генерации кода для различных архитектур (x86, ARM, RISC-V), обеспечивая кроссплатформенную совместимость и автоматизацию разработки. Генерируемый код показал более высокие показатели корректности для ARM и RISC-V по сравнению с x86, что может быть связано с более стандартизированной природой этих архитектур.

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

Исследование демонстрирует, что большие языковые модели могут выступать в роли компиляторов, генерируя ассемблерный код непосредственно из высокоуровневых инструкций. Однако, успешность компиляции остаётся переменной величиной, требующей дальнейшей оптимизации и проработки. Это напоминает о высказывании Грейс Хоппер: “Лучший способ предсказать будущее — это создать его.”. В контексте LaaC Framework и необходимости повышения точности и эффективности компиляции, данная фраза подчеркивает активную роль исследователей в формировании будущего компиляционных технологий. Вместо пассивного ожидания прогресса, необходимо создавать инструменты и методы, способные преодолеть текущие ограничения и обеспечить надежную кросс-платформенную поддержку.

Что дальше?

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

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

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

Оригинал статьи: denisavetisyan.com/yazykovye-modeli-kak-kompilyatory-vozmozhno-li-eto

Связаться с автором: linkedin.com/in/avetisyan

Я почему-то уверен, что она у тебя уже есть. Либо в списке литературы для самообразования, либо где-то среди скачанных pdf, а может, даже в печатном виде. Возможно, ты даже начинал её читать, но… работа, таски, собеседования… деньги вроде и так платят… и ты так и не осилил Мейерса "Эффективный и современный С++".

А ведь именно эта книга — ключ, который поможет тебе пробить потолок уровня middle и начать движение к senior.

Да, можно скачать список из 400 популярных вопросов, выучить их и бодро ответить на вопрос: «Расскажи про std::unique_ptr». А потом тебе прилетает дополнительный вопрос: «А как изменится размер std::unique_ptr при использовании пользовательского удалителя?» Иии… Я не буду додумывать твой уровень знаний. Попробуй сам ответить на этот вопрос и поставь себе оценку🙂
И это только один из примеров тонких нюансов, которые описаны в этой книге и которые реально спрашивают на собеседованиях.

Ещё одна сильная сторона книги: почти каждая фича современного C++ иллюстрируется примерами её использования в реальном проде. А это большая редкость для технической литературы.

Хватит откладывать эту книгу на «потом». Поставь цель на этот год и, наконец-то, найди время, чтобы прочитать 300 страниц "Эффективного и современного С++".

Привет всем ребятам с пикабу! Сегодня столкнулся с проблемой, что мне нужно было сделать так, чтобы я вводил PID процесса, или хотя-бы имя самого процесса, вместо имени окна чтобы скрыть, или показать его в панели задач. Пробовал сам - не получилось. Спросил ChatGpt - нерабочая тарабарщина. Просьба помочь чем сможете, буду благодарен любому совету!

Вот сам код: #include <windows.h>
#include <iostream>
#include <string>

int main()
{
int choice;
std::string programName;
HWND hwnd;

std::cout << "Choose an option:\n";
std::cout << "(1) Hide Window\n";
std::cout << "(2) Show Window\n";

std::cin >> choice;
std::cin.ignore();

switch (choice) {
case 1:
std::cout << "Enter the Window Name to hide: ";
std::getline(std::cin, programName);
hwnd = FindWindowA(NULL, programName.c_str());
if (hwnd == NULL) {
std::cout << "Program not found." << std::endl;
return 1;
}
ShowWindow(hwnd, SW_HIDE);
std::cout << "Window '" << programName << "' was hidden." << std::endl;
break;
case 2:
std::cout << "Enter the Window Name to show: ";
std::getline(std::cin, programName);
hwnd = FindWindowA(NULL, programName.c_str());
if (hwnd == NULL) {
std::cout << "Program not found." << std::endl;
return 1;
}
ShowWindow(hwnd, SW_SHOW);
std::cout << "Window '" << programName << "' is now visible." << std::endl;
break;
default:
std::cout << "Invalid option selected." << std::endl;
return 1;
}
return 0;
}