Forem: Adriel Henrique

Claude resolve problema em aberto e choca Donald Knuth

Adriel Henrique — Tue, 24 Mar 2026 21:09:37 +0000

Terence Tao - Para muitos um dos maiores matematicos vivos - acreditva que em alguns anos teriamos a IA sendo uma co-autora confiavel para artigos na área de exatas em alguns anos. Ao contrário do que acreditava Tao, isso acabou de acontecer, a IA Claude pode resolver um problema de grafos que estava em aberto. Knuth, um dos maiores nomes da ciência da computação, também um grande "ex-cético" da capacidade da IA, no auge de seus 88 anos estava trabalhando em um problema que o assombrava a semanas para sua lendária coleção de livros sobre programação(sim, Knuth ainda trabalha no "Art of Computer Programming"), quando houve um resultado inesperado, a IA Claude Opus pode resolver um problema de pesquisa em aberto.
Isso ocoreu quando, já assombrado durante semanas por um problema de grafos e combinatória, Knuth solicitou ajuda a seu amigo Filip Stappers, que acabou jogando esse problema para o Claude, que tentou uma série de estratégias para tentar atacar o problema, após 25 abordagens percebeu que para encontrar uma solução "geral" para o problema informado deveria usar matemática pura, onde após uma série de erros pode encontrar mesmo que de maneira muito incompleta algumas soluções que permitiam uma generalização, que Knuth tratou de desenvolver e que de fato resolvia o problema. Apesar do grande sucesso do Claude, por vezes ele chegou a "enroscar" sem conseguir executar os próprios progamas que escrevia além de não ter conseguido de fato elaborar a generalização.
Para finalizar o paper "Claude Cycles", Knuth fez uma piada que de fato nos deixa bastante reflexivos: "Acho que o espírito de Claude Shannon provavelmente se orgulha de saber que seu nome agora está sendo associado a tais avanços. Parabéns ao Claude!".
Esse acontecimento é algo incrível. Ainda me lembro de alguns professores dizendo que o ChatGPT errava muitas coisas de matemática básica. Ou ainda, há algum tempo, ao colocar um problema da Olimpíada Internacional de Matemática — que levei um tempo considerável para resolver —, nenhuma IA que testei foi capaz de resolvê-lo.
o problema em questão:

\text{IMO - 1964. Prove que, para a>b² ,ocorre a seguinte identidade:} \newline \sqrt{a-b\sqrt{a+b\sqrt{a-b...}}}=\sqrt{a-\frac{3b^{2}}{4}} - \frac{b}{2}

Apesar de ser uma questão bastante complexa, ela segue um caminho relativamente conhecido; o problema real é a fatoração de um polinômio de grau 4 que surge ao desenvolver a espressão. Em outra situação, cheguei a testar alguns problemas algebricamente bem pesados do livro Higher Algebra, de Hall and Knight — conhecido por ter exercícios de altíssimo nível —, onde o DeepSeek apresentou dificuldades, “enroscando” ou não conseguindo resolver alguns deles.
Todavia, os problemas citados são simplesmente triviais perto do que Knuth e Filip Stappers pediram ao Claude para resolver. De fato, isso pode ser um avanço considerável no uso de IA em nível de pesquisa. De fato, parabéns ao Claude!

Entendendo Ponteiros

Adriel Henrique — Fri, 12 Jul 2024 14:08:50 +0000

Em graduações da área de tecnologia, existem conceitos e matérias que geralmente assustam os alunos, alguns dos principais exemplos são matérias relacionadas a Programação Orientada a Objetos e Cálculo, outro exemplo são algumas noções mais abstratas tal como ponteiros, principalmente em C, tema deste artigo.
Diferentemente de nós, os computadores não conhecem uma determinada informação por um “rótulo” ou “nome”, e sim pelo endereço onde este dado está alocado na memória. Podemos pensar na memória como um conjunto de “células” que contém um número de bits que armazenam 0 ou 1 e que cada célula está associada a um determinado endereço onde armazena alguma informação para que os programas executados pela máquina possam acessar estes dados e os manipular.
Tendo em vista que para um programa poder usar um dado ele precisa saber de seu endereço na memória, podemos conceber o conceito de ponteiro. O ponteiro é uma variável que “aponta” para algum outro dado, é como se fosse um espaço na memória destinado a guardar o endereço de outra variável ou informação para que esta possa ser manipulada.
Mas agora vem a pergunta, qual a utilidade de um ponteiro? O ponteiro permite algumas operações mais complexas envolvendo a memória, tal como alocação dinâmica com Malloc ou a criação de estruturas de dados mais complexas, etc. Além disso, há alguns detalhes que não são tão facilmente percebidas pelos estudantes em um primeiro momento, tal como o fato de o nome de um vetor ser um ponteiro. Isto mesmo, um vetor nada mais é que um “ponteiro fixo” que aponta para uma determinada posição na memória e que nós usamos o índice para manipular de acordo com a necessidade.
Outra utilidade é a manipulação de dados por referência, por exemplo: passar uma matriz como parâmetro para outra função, permitindo que a matriz original seja modificada ao invés do valor ou objeto passado ser apenas uma cópia, algo que por exemplo ocorre no Javascript onde não há conceito de ponteiro (ao menos não explicitamente), por exemplo:

#include <stdio.h>

int vet [5] ={10,20,3,4};

void somadez(int * ref){
    for(int i=0;i<5;i++)
        ref[i]+=10;
}

int main () {
    somadez(vet);
    for(int i=0;i<5;i++)
        printf("%i\n",vet[i]);

    return 0;
}

saída:
20
30
13
14

note que quem foi alterado foi o vetor original

Outra utilidade não tão evidente de ponteiros, desta vez para linguagens orientadas a objeto, onde podemos, por exemplo, criar objetos dinâmicos e facilitar o trabalho com herança e polimorfismo.
Temos esse exemplo a baixo com C++:

#include <iostream>

using namespace std;

class Animal{
public:
    virtual void som();
};

class Cachorro : public Animal{
public:
    void som(){
        cout << "auau";
    }
};

int main () {
    Animal * ClasseBase;
    Cachorro ClasseFilha;

    ClasseBase = &ClasseFilha;
    ClasseBase->som();
    //neste caso podemos usar o ponteiro para acessar métodos e atributos de uma classe derivada.
    return 0;
}

Introdução ao Laravel

Adriel Henrique — Fri, 22 Dec 2023 06:09:10 +0000

O Laravel é um framework PHP de sintaxe elegante que fornece uma série de recursos para a construção de aplicações web padrão MVC ,possuindo uma vasta documentação e comunidade é um dos maiores frameworks para trabalhar com web da atualidade.
Para construir um projeto é necessário ter o composer instalado localmente e executar o seguinte comando:

composer create-project laravel/laravel<nome do projeto>

Após a execução do comando, será criado um diretório raiz do projeto e dentro dele terá uma série de diretórios que contem arquivos que servem para exercer certas funções em nossa aplicação, neste momento os diretórios que interessam são o “App” e “Routes”, o primeiro é necessário para definir os métodos e a maioria das funcionalidades do nosso aplicativo, sendo este o coração do projeto, ao qual não daremos tanto foco em um primeiro momento. O segundo diz respeito a organização de nossas rotas e o direcionamento de cada requisição.
Dando continuídade a explicação da pasta Route, dentro dela temos os arquivos: web.php, api.php, channels.php e console.php.
Geralmente, começamos definindo as rotas no “web.php” que são aquelas rotas que devem ser acessadas pelo navegador usando a url, para definir uma rota podemos fazer assim:

Route::get('/', function () {
return view('HelloWorld');
});

Este metodo, quando acessado a rota ‘/’, retorna um documento blade(Blade é uma ferramenta inclusa no laravel que fornece uma maneira de gerar e renderizar arquivos html) chamado “HelloWorld.blade.php” na pasta ‘/resoures/view’.
Outra ferramenta muito útil para trabalhar com Laravel é o Artisan que é uma interface em linha de comando que serve para agilizar o processo de desenvolvimento.
Podemos usar o Artisan para gerar um controller:

php artisan make:controller <nome do controller>

Controllers servem para gerenciar requisições http enviadas para determinadas rotas e poder adicionar uma lógica a estas.
Por fim vamos construir uma aplicação que pegue um parametro, chame um controller que através de um metodo retorne uma view
no web.php:

use App\Http\Controllers\exemplo;

Route::get('/{nome}', [exemplo::class, 'index']);

o 'use' indica a localização do arquivo do controller, nossa rota tem o parametro "nome" e no entre as colchetes esta a chamada do método index do controller "exemplo".

php artisan make:controller exemplo

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class exemplo extends Controller
{
    public function index(string $nome){
        return view('HelloWorld', ['nome' => $nome]);
    }
}

O Método index retorna a view "Hello World" passando para ela o parametro nome

<div>
    <h1>Hello, {{ $nome }}</h1>
</div>

entre as chaves esta o parametro que repassamos à view, o resultado deve ser assim quando acessarmos "http://127.0.0.1:8000/dev":

Resolvendo o Exercise Tracker - Free-code-camp

Adriel Henrique — Thu, 15 Jun 2023 19:04:47 +0000

A algum tempo fiz a certificação de Back-end da free-code camp,a maioria dos projetos propostos são no geral bem simples, no entanto, houve um que o nível de complexidade é mais elevado, que é o projeto de “exercise tracker”, neste artigo vou explicar como acabei resolvendo ele.

Para este artigo vou usar algumas ferramentas:

O repositório oficial do freecode camp do projeto.
Postman para trabalhar com a API

Além de alguns conhecimentos prévios, como:

Algumas noções de requições HTTP/REST.
Express, Mongoose e Atlas DB

O projeto quando importado do Github ou do Replit tem apenas as funções básicas do express:

const express = require('express')
const app = express()
const cors = require('cors')
require('dotenv').config()

Devemos adicionar as dependências do projeto tais como o Mongoose, para que funcione como nosso banco de dados NoSQL e o Body-parser para que possamos trabalhar com nossas requisições.

const express = require('express')
const app = express()
const cors = require('cors')
require('dotenv').config()
const mongoose = require('mongoose');
const bodyParser = require('body-parser');

app.use(bodyParser.urlencoded({ extended: true }))
app.use(bodyParser.json());

Indo para o html:

     <form action="/api/users" method="post">
        <h3>Create a New User</h3>
        <p><code>POST /api/users</code></p>
        <input id="username" type="text" name="username" placeholder="username" />
        <input type="submit" value="Submit" />
      </form>
      <form id="exercise-form" method="post">
        <h3>Add exercises</h3>
        <p><code>POST /api/users/:_id/exercises</code></p>
        <input id="uid" type="text" name="_id" placeholder=":_id" />
        <input id="desc" type="text" name="description" placeholder="description*" />
        <input id="dur" type="text" name="duration" placeholder="duration* (mins.)" />
        <input id="date" type="text" name="date" placeholder="date (yyyy-mm-dd)" />
        <input type="submit" value="Submit" />
      </form>

    <script>
      const exerciseForm = document.getElementById("exercise-form");

      exerciseForm.addEventListener("submit", () => {
        const userId = document.getElementById("uid").value;
        exerciseForm.action = `/api/users/${userId}/exercises`;

        exerciseForm.submit();
      });
    </script>

Análisando o html vemos que este possui dois formulários que chamam rotas diferentes uma chama a rota ‘/api/users/’ com uma requisição do tipo POST e a outra ‘api/users/:_id/exercises’.

Primeiramente,após definirmos as variaveis de ambiente e fazer a conexão com o AtlasDB devemos criar os Schemas e Modelos que usaremos:

async function main() {
  await mongoose.connect(mySecret);
}
//-----------
const userSchema = mongoose.Schema({
  username: String,
  _id: String
});
const exerciseSchema = mongoose.Schema({
  duser: String,
  description:{
    type: String,
    required: true
  },
  duration:{
      type: Number,
      required: true
  },
  date: Date
});

var User = mongoose.model('user',userSchema);
var exercise = mongoose.model('exercise',exerciseSchema);

No primeiro requisito deve-se utilizando um nome de usuário fornecido no formulário 'Create a New User' para um usuário e devolva uma resposta em JSON com o nome do usuário e seu id

app.post('/api/users',async function(req,res){
  const user = req.body.username;
  try{
    const username = await User.findOne({username: user});
    if(username == null){
      let newId = new mongoose.mongo.ObjectId();
      const newUser = new User({username: req.body.username, _id: newId});
      await newUser.save();
      res.json({'username':newUser.username,'_id': newUser._id});
    }else{
      res.json({'username':username.username,'_id': username._id});
    }

  }catch(err){

    res.status(500).json(err);
  }
});

No trecho de código acima, antes de registrar ele procura para ver se este usuário existe, caso o resultado seja "null" ele criara um novo usuário.

Como requisito para terminar o projeto também é necessário que quando houver uma requisição do tipo GET para a mesma rota ela devolva um array de objetos com o nome de usuário e id dos usuários registrados,algo relativamente simples:

app.get('/api/users',async function(req,res){
  try{
    var users = [];
    users = await User.find();
    res.json(users);
  }catch(err){
    res.status(500).json(err);
  }

})

A resposta do tipo get deve ser assim:

Seguindo o desafio,devemos fazer com que a API possa salvar exercícios desde que ceda uma id(através da URL) de usuário,uma descrição e uma duração, caso uma data não seja cedida,devemos pegar a data atual.

app.post('/api/users/:_id/exercises', async function(req,res){
  const id = req.params._id;
  const data = req.body;

  let date;
  if(data.date == null || data.date == ''){
    date = new Date();
  }else{
    date = data.date;
  }

  try{
    const newexer = new exercise({
      duser: id,
      description:data.description,
      duration: data.duration,
      date:date
    });
    await newexer.save();
    const user = await User.findById(id).exec();

    res.json({
      username:  user.username,
      _id: user._id,
      description:newexer.description,
      duration:newexer.duration,
      date: new Date(newexer.date).toDateString()

    });
  }catch(err){
    res.status(500).json(err);

  }
});

Note que usaremos o campo "duser" para guardar o id do usuário. A rota de GET seguirá uma linha parecida com a anterior:

app.get('/api/users/:_id/exercises', async function(req,res){
  const id = req.params._id;
  try{
    const exers = await exercise.find({duser: id});
    res.json(exers);
 }catch(err){
    res.status(500).json(err);

  }
})

A rota agora construiremos a rota de logs, onde reside maior parte do desafio:
Quando solicitado à rota deve-ser devolver o objeto do usuário com o campo "count" que recebe o valor do número de exercicios cadastrados para o usuário, além do array dos exercicios, além da possibilidade de podermos filtrar por faixa de tempo, para isso usaremos o Postman.

Vendo a parte tracejada em vermelho,temos um exemplo de solicitação GET onde a Query esta na URL, no caso após "?" temos as condicionais que devem ser atendidas na consulta, para isso devemos criar um objeto que receba os parametros from,to e Limit usando o método "req.query", assim:

app.get('/api/users/:_id/logs',async function(req,res){
  const id = req.params._id;
  const { from, to, limit } = req.query;
  let dateObj = {}
  if (from) {
    dateObj["$gte"] = new Date(from)
  }
  if (to){
    dateObj["$lte"] = new Date(to)
  }
  let filter = {
    duser: id
  }
  if(from || to){
    filter.date = dateObj;
  }

  try{
    const user = await User.findById(id).exec();
    const exers = await exercise.find(filter).limit(+limit ?? 500);
    const num = await exercise.find({ duser: id}).count().exec();
    let log = exers.map((e) => {
            return {
                'description': e.description,
                    'duration': e.duration,
                'date': new Date(e.date).toDateString()
        };
    });
    res.json({
      username: user.username,
      count : num,
      _id: user._id,
     log});
 }catch(err){
    res.status(500).json(err);

  }
})

A resposta deve ser assim:

Por fim, o código completo:

const express = require('express')
const app = express()
const cors = require('cors')
require('dotenv').config()
const mongoose = require('mongoose');
const bodyParser = require('body-parser');

app.use(bodyParser.urlencoded({ extended: true }))
app.use(bodyParser.json());

app.use(cors())
app.use(express.static('public'))
app.get('/', (req, res) => {
  res.sendFile(__dirname + '/views/index.html')
});

const mySecret = process.env['MONGO_URI']

main().catch(err => console.log(err));

async function main() {
  await mongoose.connect(mySecret);
}
//-----------
const userSchema = mongoose.Schema({
  username: String,
  _id: String
});
const exerciseSchema = mongoose.Schema({
  duser: String,
  description:{
    type: String,
    required: true
  },
  duration:{
      type: Number,
      required: true
  },
  date: Date
});

var User = mongoose.model('user',userSchema);
var exercise = mongoose.model('exercise',exerciseSchema);
//------------
app.post('/api/users',async function(req,res){
  const user = req.body.username;
  try{
    const username = await User.findOne({username: user});
    if(username == null){
      let newId = new mongoose.mongo.ObjectId();
      const newUser = new User({username: req.body.username, _id: newId});
      await newUser.save();
      res.json({'username':newUser.username,'_id': newUser._id});
    }else{
      res.json({'username':username.username,'_id': username._id});
    }

  }catch(err){

    res.status(500).json(err);
  }
});
//--------------------
app.get('/api/users',async function(req,res){
  try{
    var users = [];
    users = await User.find();
    res.json(users);
  }catch(err){
    res.status(500).json(err);
  }

})

app.post('/api/users/:_id/exercises', async function(req,res){
  const id = req.params._id;
  const data = req.body;

  let date;
  if(data.date == null || data.date == ''){
    date = new Date();
  }else{
    date = data.date;
  }

  try{
    const newexer = new exercise({
      duser: id,
      description:data.description,
      duration: data.duration,
      date:date
    });
    await newexer.save();
    const user = await User.findById(id).exec();


    res.json({
      username:  user.username,
      _id: user._id,
      description:newexer.description,
      duration:newexer.duration,
      date: new Date(newexer.date).toDateString()

    });
  }catch(err){
    res.status(500).json(err);

  }
});

app.get('/api/users/:_id/exercises', async function(req,res){
  const id = req.params._id;
  try{
    const exers = await exercise.find({duser: id});
    res.json(exers);
 }catch(err){
    res.status(500).json(err);

  }
})

app.get('/api/users/:_id/logs',async function(req,res){
  const id = req.params._id;
  const { from, to, limit } = req.query;
  let dateObj = {}
  if (from) {
    dateObj["$gte"] = new Date(from)
  }
  if (to){
    dateObj["$lte"] = new Date(to)
  }
  let filter = {
    duser: id
  }
  if(from || to){
    filter.date = dateObj;
  }

  try{
    const user = await User.findById(id).exec();
    const exers = await exercise.find(filter).limit(+limit ?? 500);
    const num = await exercise.find({ duser: id}).count().exec();
    let log = exers.map((e) => {
            return {
                'description': e.
description
,
              'duration': e.duration,
                'date': new Date(e.date).toDateString()
        };
    });
    res.json({
      username: user.username,
      count : num,
      _id: user._id,
     log});
 }catch(err){
    res.status(500).json(err);

  }
})

const listener = app.listen(process.env.PORT || 3000, () => {
  console.log('Your app is listening on port ' + listener.address().port)
})

link do projeto no replit: https://replit.com/@AdrielH024/boilerplate-project-exercisetracker?v=1

link do projeto no github:
https://github.com/AdrielH024/free-Code-Camp-ExerciseTracker