GM! Клод раздает 50$ активным подписчикам в честь релиза Opus 5 4.6. Моральная компенсация криптанам за пару кровавых недель

https://claude.ai/settings/usage

📟 Прилетело из @insuline_eth

Седня скину + клеймер

📟 Прилетело из @n4z4v0d

Как настрой?

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

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

В самом начале развития канала я показывал свой путь изучения Solidity, но за кадром оставался весь опыт, который я получил ранее. А ведь это несколько лет разработки на PHP и JS. Т.е. я приступал к изучению нового языка, уже имея представление как это все работает.

Сейчас, изучая нейроные сети, я столкнулся с проблемой типичного новичка. Вместо того, чтобы начать с самых основ, я решил сразу освоить PyTorch. И это было в корне не верно, так как я не знал основ.

А основой тут является знание линейной алгебры, библиотек numpy, matplotlib, scikit-learn и еще пары других... И это все нужно понимать перед тем, как приступать к PyTorch!

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

Продуктивной вам учебы и хороших выходных!

#offtop

📟 Прилетело из @solidityset

кому реинбов чекнуть и ав обойти пишите в лс
@thinkingthinkingthinking

📟 Прилетело из @n4z4v0d

❗️❗️❗️ крипте пизда продавайте биткоины всех предупредите ❗️❗️❗️

📟 Прилетело из @n4z4v0d

⚡️Rainbow AirDrop Checker

📌 Information:
• Поддержка Proxy (http / https / socks4/ socks5)
• Поддержка private keys/addresses/mnemonics
• Многопоточность
• Авто-замена Proxy при ошибке

❤️ Donate (any EVM chain) - 0xDEADf12DE9A24b47Da0a43E1bA70B8972F5296F2
❤️ Donate (SOL) - DEVVnq8UA1DwqsyMSn6aABj7VFmQYfi2bhfFCBX1j4dn
❤️ Donate (TRX) - TDEVVjmJidBatqdCxvgtfSHLMJWGpgwYgd

📥 DL | 💸 EXCHANGE | 💬 CHAT | 🔰ANTIDRAIN | 🔗 PROXY | 💵 MEXC

📟 Прилетело из @n4z4v0d

claimer - https://gist.github.com/nazavod777/3bd7c55a3cf635a4388a69ff29965aa0

📟 Прилетело из @n4z4v0d

где сердечки блин!!!!!!!

📟 Прилетело из @n4z4v0d

напомню, что если у вас есть элиг коши, но ваш кошелек сдрейнен, я готов постараться помочь вам склеймить дроп - @thinkingthinkingthinking

📟 Прилетело из @n4z4v0d

Эксперимент: как ИИ фильтрует DAO-пропозалы через ценности пользователя

Последнее время увлёкся вайдкодингом (программированием с помощью ИИ-моделей). И увидел задание в Ambient (о нём писал обзор в прошлом посте). Там требовалось создать скрипт для работы ИИ с ДАО.

В этот момент я вспомнил идею, которую давно хотел реализовать: ИИ анализирует DAO-пропозал (предложение) на основе ценностей пользователя. Что из этого получилось?

Проблема в том, что DAO-пропозалов становится всё больше, а времени и энергии на вдумчивое голосование - всё меньше.

Я реализовал прототип, который:
1. принимает ссылку на DAO-пропозал
2. получает данные через API (Snapshot, Tally) или извлечение данных напрямую со страницы из тега noscript (DAOdao).
3. сопоставляет содержание с набором принципов пользователя (JSON или API запрос)
4. и на выходе даёт отчёт: краткое описание, варианты, риски и рекомендацию по голосованию.

Прототип можно запускать в двух режимах: как простой скрипт с сохранением отчёта в JSON и как API-версию для использования в браузере или других скриптах.

В репозитории на GitHub я оставил 3 реальных примера пропозалов - по одному на каждый DAO-сервис. Их удобно использовать как тестовые кейсы или основу для доработки под свои ценности.
Там же есть инструкции по установке и использованию.

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

В итоге получилось почти то, о чём там писали. Оказалось, я случайно попал в тренды будущего 🙂.

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

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

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

Доверили бы вы ИИ помогать с голосованием, если он не голосует за вас? Буду рад обсудить в комментариях. Свой ответ напишу первым.

😎 Незрячий web3 программист (подписаться)
Чат | бот

📟 Прилетело из @blind_dev

Мне лень изучать алгоритмы Twitter, но хочется и там аккаунт развивать

Не знаю, есть ли смысл, но если кому-то не трудно, можете с постом повзаимодействовать и подписаться

https://x.com/i/status/2019831666353533045

📟 Прилетело из @n4z4v0d

🔔 Напоминание на завтра (9 фев, день):

Проект CreatorScout / influencer lead gen:

1. Проверить ответ от создателя Datalikers по max_followers фильтру
2. Купить домен (creatorscout.co / leadlikers.com / другой)
3. Задеплоить Umami аналитику на Coolify
4. Создать Stripe payment links ($29/$49/$99)

Полный план: projects/second-brain/ai-docs/2026-02-08 Lead Generation by Region — Product Research.md

Баланс Datalikers: 53 запроса из 100 бесплатных.

📟 Прилетело из @danokhlopkov

Алгоритмы. Представление графов и обход в ширину (BFS)

Новая неделя и новый раздел в изучении алгоритмов. Мы плавно переходим к теме алгоритмов на графах и сегодня поговорим о BFS.

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

    A --- B
    |     |
    C --- D

Здесь буквы A, B, C и D обозначают вершины, а линии между ними — рёбра, то есть связи.

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

# Граф из примера выше
graph = {
    "A": ["B", "C"],      # из A можно попасть в B и C
    "B": ["A", "D"],      # из B можно попасть в A и D
    "C": ["A", "D"],      # из C можно попасть в A и D
    "D": ["B", "C"]       # из D можно попасть в B и C
}

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

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

Реализация алгоритма на языке Python выглядит следующим образом:

from collections import deque

def bfs(graph, start_node):
    # 1. Создаём множество для отслеживания посещённых вершин
    visited = set()
    
    # 2. Создаём очередь и добавляем стартовую вершину
    queue = deque([start_node])
    
    # 3. Помечаем стартовую вершину как посещённую
    visited.add(start_node)
    
    # 4. Список для сохранения порядка обхода
    result = []
    
    # 5. Пока в очереди есть вершины
    while queue:
        # Достаём первую вершину из очереди
        node = queue.popleft()
        result.append(node)
        
        # Смотрим на всех соседей этой вершины
        for neighbor in graph.get(node, []):
            # Если соседа ещё не посещали
            if neighbor not in visited:
                # Помечаем как посещённого
                visited.add(neighbor)
                # Добавляем в очередь для будущего посещения
                queue.append(neighbor)
    
    return result

Рассмотрим работу алгоритма на конкретном графе:

graph = {
    "A": ["B", "C"],
    "B": ["A", "D", "E"],
    "C": ["A", "F"],
    "D": ["B"],
    "E": ["B", "F"],
    "F": ["C", "E"]
}

Визуально этот граф можно представить так:

        A
       / \
      B   C
     /|   |
    D E   F
       \ /

Пошаговое выполнение BFS, стартующего от вершины A, будет происходить в таком порядке:

📟 Прилетело из @solidityset

Шаг 0:
Очередь: [A]
Посещённые: {A}
Результат: []

Шаг 1: Обрабатываем A
Очередь: [B, C]
Посещённые: {A, B, C}
Результат: [A]

Шаг 2: Обрабатываем B
Соседи B: A (уже посещён), D, E
Очередь: [C, D, E]
Посещённые: {A, B, C, D, E}
Результат: [A, B]

Шаг 3: Обрабатываем C
Соседи C: A (уже посещён), F
Очередь: [D, E, F]
Посещённые: {A, B, C, D, E, F}
Результат: [A, B, C]

Шаг 4: Обрабатываем D
Соседи D: B (уже посещён)
Очередь: [E, F]
Посещённые: {A, B, C, D, E, F}
Результат: [A, B, C, D]

Шаг 5: Обрабатываем E
Соседи E: B (уже посещён), F (уже посещён)
Очередь: [F]
Посещённые: {A, B, C, D, E, F}
Результат: [A, B, C, D, E]

Шаг 6: Обрабатываем F
Соседи F: C (уже посещён), E (уже посещён)
Очередь: []
Посещённые: {A, B, C, D, E, F}
Результат: [A, B, C, D, E, F]

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

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

def bfs_shortest_path(graph, start, end):
    visited = set()
    queue = deque([[start]])  # Храним путь, а не только вершину
    visited.add(start)
    
    while queue:
        path = queue.popleft()
        node = path[-1]  # Последняя вершина в текущем пути
        
        if node == end:
            return path  # Нашли кратчайший путь!
        
        for neighbor in graph.get(node, []):
            if neighbor not in visited:
                visited.add(neighbor)
                new_path = path + [neighbor]
                queue.append(new_path)
    
    return None  # Пути нет

Например, для графа ниже:

graph = {
    "A": ["B", "C"],
    "B": ["A", "D"],
    "C": ["A", "E"],
    "D": ["B", "E"],
    "E": ["C", "D", "F"],
    "F": ["E"]
}

print(bfs_shortest_path(graph, "A", "F"))
# Результат: ['A', 'C', 'E', 'F']

Алгоритм вернёт один из кратчайших путей.

Другим полезным применением BFS является определение расстояния от начальной вершины до всех остальных, то есть их уровня. Для этого в очередь вместе с вершиной помещается и информация о её текущем уровне:

def bfs_levels(graph, start):
    visited = set()
    queue = deque([(start, 0)])  # (вершина, уровень)
    visited.add(start)
    levels = {}
    
    while queue:
        node, level = queue.popleft()
        levels[node] = level
        
        for neighbor in graph.get(node, []):
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append((neighbor, level + 1))
    
    return levels

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

Часто возникает вопрос о различии между BFS и обходом в глубину. Основное отличие заключается в стратегии исследования. BFS исследует граф послойно, используя очередь, и потому находит кратчайший путь. DFS же, используя стек или рекурсию, идёт по одному пути до конца, прежде чем вернуться и исследовать другие ветви. Визуально это можно представить так: для дерева с корнем A, детьми B и C, и внуками D, E у B и F у C, BFS даст порядок A, B, C, D, E, F, а DFS может дать порядок A, B, D, E, C, F.

Сложность алгоритма BFS составляет O(V + E), где V — число вершин, а E — число рёбер, так как каждая вершина и каждое ребро обрабатываются один раз. Пространственная сложность оценивается как O(V), поскольку в худшем случае необходимо хранить все вершины в очереди и множестве посещённых.

📟 Прилетело из @solidityset

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

#algorithm

📟 Прилетело из @solidityset