Estou desenvolvendo algoritmos personalizados de soma de subconjuntos e me deparei com um problema intrigante: parece difícil gerar instâncias de soma de subconjuntos realmente "difíceis" (ou seja, forçando esforço computacional exponencial) sem usar números inteiros muito grandes (por exemplo, maiores que cerca de 2^22).

Gostaria de saber especificamente:

• Existem construções conhecidas ou geradores de instâncias para soma de subconjuntos que forçam de forma confiável a complexidade exponencial — particularmente contra algoritmos comuns de soma de subconjuntos ou heurísticas personalizadas — usando apenas inteiros de tamanho moderado (≤2^22)?
• A dificuldade das instâncias de subconjunto-soma está inerentemente ligada ao tamanho dos números inteiros envolvidos ou é possível criar instâncias computacionalmente difíceis puramente por meio de estruturas e relacionamentos numéricos, mesmo com números menores?

Para contextualizar, aqui estão algumas tentativas que fiz para gerar instâncias potencialmente difíceis (feedback ou melhorias são bem-vindos):

import random

def generate_exponential_instance(n):
    max_element = 2 ** 22
    A = [random.randint(1, max_element) for _ in range(n)]
    while True:
        mask = [random.choice([0, 1]) for _ in range(n)]
        if sum(mask) != 0:
            break
    target = sum(A[i] * mask[i] for i in range(n))
    return A, target

def generate_dense_high_values_instance(n):
    base = 2 ** 22 - random.randint(0, 100)
    A = [base + random.randint(0, 20) for _ in range(n)]
    target = sum(random.sample(A, k=n // 2))
    return A, target

def generate_merkle_hellman_instance(n, max_step=20):
    total = 0
    private_key = []
    for _ in range(n):
        next_val = total + random.randint(1, max_step)
        private_key.append(next_val)
        total += next_val
    q = random.randint(total + 1, 2 * total)
    r = random.randint(2, q - 1)
    public_key = [(r * w) % q for w in private_key]
    message = [random.randint(0, 1) for _ in range(n)]
    ciphertext = sum(b * k for b, k in zip(message, public_key))
    return public_key, ciphertext

Tenho um serviço ASP.NET Core 7 Web API implementado em C# e um método definido assim:

[ApiController]
[Route("api/[controller]")]
public class SensorsController : ControllerBase
{
    // ...
    [HttpGet("{sensorname}/zf")]
    public async Task<ActionResult> GetZForecast(string sensorname, [FromQuery]DateTime? when, [FromQuery]string? wind)
    {
        // ...
    }
}

Quero testá-lo com este comando curl:

curl -X get https://localhost:7091/api/Sensors/VK_THC_GreenRoom/zf?when="2025-03-15T08:00:00Z"&wind="Calm"

Por que o windparâmetro não é capturado pelo controlador neste caso?

Se eu usar apenas um dos parâmetros de consulta opcionais, como mostrado abaixo, tudo funcionará bem e ambos winde whenserão capturados respectivamente:

curl -X get https://localhost:7091/api/Sensors/VK_THC_GreenRoom/zf?when="2025-03-15T08:00:00Z"

curl -X get https://localhost:7091/api/Sensors/VK_THC_GreenRoom/zf?wind="Calm"

Então o que estou perdendo?

Desculpe pelo título longo. Não sei se isso é mais um problema de matemática ou de programação, mas acho que minha matemática está extremamente enferrujada e sou melhor em programação.

Então eu tenho essa expansão de fração contínua do arco tangente:

Eu peguei da Wikipedia

Tentei encontrar um algoritmo simples para calculá-lo:

E eu consegui, escrevi uma implementação de precisão infinita da expansão de frações contínuas sem usar nenhuma biblioteca, usando apenas aritmética básica de inteiros:

import json
import math
import random
from decimal import Decimal, getcontext
from typing import Callable, List, Tuple


Fraction = Tuple[int, int]


def arctan_cf(y: int, x: int, lim: int) -> Fraction:
    y_sq = y**2
    a1, a2 = y, 3 * x * y
    b1, b2 = x, 3 * x**2 + y_sq
    odd = 5
    for i in range(2, 2 + lim):
        t1, t2 = odd * x, i**2 * y_sq
        a1, a2 = a2, t1 * a2 + t2 * a1
        b1, b2 = b2, t1 * b2 + t2 * b1
        odd += 2

    return a2, b2

E converge mais rápido que a série arco-tangente de Newton que usei anteriormente .

Agora acho que se eu combinar isso com a fórmula do meio-ângulo do arco tangente, a convergência deve ser mais rápida.

def half_arctan_cf(y: int, x: int, lim: int) -> Fraction:
    c = (x**2 + y**2) ** 0.5
    a, b = c.as_integer_ratio()
    a, b = arctan_cf(a - b * x, b * y, lim)
    return 2 * a, b

E, de fato, converge ainda mais rápido:

def test_accuracy(lim: int) -> dict:
    result = {}
    for _ in range(lim):
        x, y = random.sample(range(1024), 2)
        while not x or not y:
            x, y = random.sample(range(1024), 2)

        atan2 = math.atan2(y, x)
        entry = {"atan": atan2}
        for fname, func in zip(
            ("arctan_cf", "half_arctan_cf"), (arctan_cf, half_arctan_cf)
        ):
            i = 1
            while True:
                a, b = func(y, x, i)
                if math.isclose(deci := a / b, atan2):
                    break

                i += 1

            entry[fname] = (i, deci)

        result[f"{y} / {x}"] = entry

    return result


print(json.dumps(test_accuracy(8), indent=4))

for v in test_accuracy(128).values():
    assert v["half_arctan_cf"][0] <= v["arctan_cf"][0]

{
    "206 / 136": {
        "atan": 0.9872880750087898,
        "arctan_cf": [
            16,
            0.9872880746658675
        ],
        "half_arctan_cf": [
            6,
            0.9872880746018052
        ]
    },
    "537 / 308": {
        "atan": 1.0500473287277563,
        "arctan_cf": [
            18,
            1.0500473281360896
        ],
        "half_arctan_cf": [
            7,
            1.0500473288158192
        ]
    },
    "331 / 356": {
        "atan": 0.7490241118247137,
        "arctan_cf": [
            10,
            0.7490241115996227
        ],
        "half_arctan_cf": [
            5,
            0.749024111913438
        ]
    },
    "744 / 613": {
        "atan": 0.8816364228048325,
        "arctan_cf": [
            13,
            0.8816364230439662
        ],
        "half_arctan_cf": [
            6,
            0.8816364227495634
        ]
    },
    "960 / 419": {
        "atan": 1.1592605364805093,
        "arctan_cf": [
            24,
            1.1592605359263286
        ],
        "half_arctan_cf": [
            7,
            1.1592605371181872
        ]
    },
    "597 / 884": {
        "atan": 0.5939827714677137,
        "arctan_cf": [
            7,
            0.5939827719895824
        ],
        "half_arctan_cf": [
            4,
            0.59398277135389
        ]
    },
    "212 / 498": {
        "atan": 0.40246578425167584,
        "arctan_cf": [
            5,
            0.4024657843859885
        ],
        "half_arctan_cf": [
            3,
            0.40246578431841773
        ]
    },
    "837 / 212": {
        "atan": 1.322727785860997,
        "arctan_cf": [
            41,
            1.322727786922624
        ],
        "half_arctan_cf": [
            8,
            1.3227277847674388
        ]
    }
}

Esse bloco assert é bastante longo para um grande número de amostras, mas nunca gera exceções.

Então, acho que posso usar a expansão de fração contínua do arco tangente com séries do tipo Machin para calcular π. (Usei a última série na seção vinculada porque ela converge mais rápido)

def sum_fractions(fractions: List[Fraction]) -> Fraction:
    while (length := len(fractions)) > 1:
        stack = []
        for i in range(0, length - (odd := length & 1), 2):
            num1, den1 = fractions[i]
            num2, den2 = fractions[i + 1]
            stack.append((num1 * den2 + num2 * den1, den1 * den2))

        if odd:
            stack.append(fractions[-1])

        fractions = stack

    return fractions[0]


MACHIN_SERIES = ((44, 57), (7, 239), (-12, 682), (24, 12943))


def approximate_loop(lim: int, func: Callable) -> List[Fraction]:
    fractions = []
    for coef, denom in MACHIN_SERIES:
        dividend, divisor = func(1, denom, lim)
        fractions.append((coef * dividend, divisor))

    return fractions


def approximate_1(lim: int) -> List[Fraction]:
    return approximate_loop(lim, arctan_cf)


def approximate_2(lim: int) -> List[Fraction]:
    return approximate_loop(lim, half_arctan_cf)


approx_funcs = (approximate_1, approximate_2)


def calculate_pi(lim: int, approx: bool = 0) -> Fraction:
    dividend, divisor = sum_fractions(approx_funcs[approx](lim))
    dividend *= 4
    return dividend // (common := math.gcd(dividend, divisor)), divisor // common

getcontext().rounding = 'ROUND_DOWN'
def to_decimal(dividend: int, divisor: int, places: int) -> str:
    getcontext().prec = places + len(str(dividend // divisor))
    return str(Decimal(dividend) / Decimal(divisor))


def get_accuracy(lim: int, approx: bool = 0) -> Tuple[int, str]:
    length = 12
    fraction = calculate_pi(lim, approx)
    while True:
        decimal = to_decimal(*fraction, length)
        for i, e in enumerate(decimal):
            if Pillion[i] != e:
                return (max(0, i - 2), decimal[:i])

        length += 10


with open("D:/Pillion.txt", "r") as f:
    Pillion = f.read()

Pillion.txt contém os primeiros 1000001 dígitos de π, Pi + Milhão = Pillion.

E funciona, mas apenas parcialmente. A expansão básica de fração contínua funciona muito bem com fórmulas do tipo Machin, mas combinadas com fórmulas de meio ângulo, eu só consigo obter 9 casas decimais corretas não importa o que aconteça, e de fato, eu obtenho 9 dígitos corretos na primeira iteração, e então essa coisa toda não melhora nunca:

In [2]: get_accuracy(16)
Out[2]:
(73,
 '3.1415926535897932384626433832795028841971693993751058209749445923078164062')

In [3]: get_accuracy(32)
Out[3]:
(138,
 '3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231')

In [4]: get_accuracy(16, 1)
Out[4]: (9, '3.141592653')

In [5]: get_accuracy(32, 1)
Out[5]: (9, '3.141592653')

In [6]: get_accuracy(1, 1)
Out[6]: (9, '3.141592653')

Mas os dígitos de fato mudam:

In [7]: to_decimal(*calculate_pi(1, 1), 32)
Out[7]: '3.14159265360948500093515231500093'

In [8]: to_decimal(*calculate_pi(2, 1), 32)
Out[8]: '3.14159265360945286794831052938917'

In [9]: to_decimal(*calculate_pi(3, 1), 32)
Out[9]: '3.14159265360945286857612896472974'

In [10]: to_decimal(*calculate_pi(4, 1), 32)
Out[10]: '3.14159265360945286857611676794770'

In [11]: to_decimal(*calculate_pi(5, 1), 32)
Out[11]: '3.14159265360945286857611676818392'

Por que a fração contínua com fórmula de meio-ângulo não está funcionando com fórmula tipo Machin? E é possível fazê-la funcionar, e se puder funcionar, então como? Eu quero uma prova de que é impossível, ou um exemplo funcional que prove que é possível.

Apenas uma verificação de sanidade, usando π/4 = arctan(1) consegui gerar half_arctan_cfdígitos de π, mas ele converge muito mais lentamente:

def approximate_3(lim: int) -> List[Fraction]:
    return [half_arctan_cf(1, 1, lim)]


approx_funcs = (approximate_1, approximate_2, approximate_3)

In [28]: get_accuracy(16, 2)
Out[28]: (15, '3.141592653589793')

In [29]: get_accuracy(16, 0)
Out[29]:
(73,
 '3.1415926535897932384626433832795028841971693993751058209749445923078164062')

E o mesmo problema se repete, ele atinge a precisão máxima de 15 dígitos na 10ª iteração:

In [37]: get_accuracy(9, 2)
Out[37]: (14, '3.14159265358979')

In [38]: get_accuracy(10, 2)
Out[38]: (15, '3.141592653589793')

In [39]: get_accuracy(11, 2)
Out[39]: (15, '3.141592653589793')

In [40]: get_accuracy(32, 2)
Out[40]: (15, '3.141592653589793')

Acabei de reescrever minha implementação de fração contínua arco-tangente e fiz com que ela evitasse cálculos redundantes.

No meu código, em cada iteração, t1 aumenta em 2 * y_sq, então não há necessidade de multiplicar repetidamente y_sq pelo número ímpar; em vez disso, basta usar uma variável cumulativa e um passo de 2 * y_sq.

E a diferença entre cada par de números quadrados consecutivos são apenas os números ímpares, então posso usar uma variável cumulativa de uma variável cumulativa.

def arctan_cf_0(y: int, x: int, lim: int) -> Fraction:
    y_sq = y**2
    a1, a2 = y, 3 * x * y
    b1, b2 = x, 3 * x**2 + y_sq
    odd = 5
    for i in range(2, 2 + lim):
        t1, t2 = odd * x, i**2 * y_sq
        a1, a2 = a2, t1 * a2 + t2 * a1
        b1, b2 = b2, t1 * b2 + t2 * b1
        odd += 2

    return a2, b2


def arctan_cf(y: int, x: int, lim: int) -> Fraction:
    y_sq = y**2
    a1, a2 = y, 3 * x * y
    b1, b2 = x, 3 * x**2 + y_sq
    t1_step, t3_step = 2 * x, 2 * y_sq
    t1, t2 = 5 * x, 4 * y_sq
    t3 = t2 + y_sq
    for _ in range(lim):
        a1, a2 = a2, t1 * a2 + t2 * a1
        b1, b2 = b2, t1 * b2 + t2 * b1
        t1 += t1_step
        t2 += t3
        t3 += t3_step

    return a2, b2

In [301]: arctan_cf_0(4, 3, 100) == arctan_cf(4, 3, 100)
Out[301]: True

In [302]: %timeit arctan_cf_0(4, 3, 100)
58.6 μs ± 503 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [303]: %timeit arctan_cf(4, 3, 100)
54.3 μs ± 816 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

Embora isso não melhore muito a velocidade, é definitivamente uma melhoria.

usingdeclaração é comum e funciona para outros métodos de membros, incluindo construtor, mas para operador de conversão não parece tão simples. GCC tem sintaxe using base::operator basepara introduzir, que é negada por Clang. Declarar uma função forward é aceito por ambos os compiladores, mas é um pouco complicado na minha opinião.

exemplo foi testado com gcc 14.2.0 e clang 19.1.7, std=c++20. Herança SFINAE rejeitada por clang.

struct base {
  template <typename T> requires (std::is_integral_v<T>)
  operator T() const { printf("to int\n"); return 0; }
};
struct derived: base {
  //using base::operator;        // denied by clang & gcc
  //using base::operator base;   // denied by clang 

  template <typename T> requires (std::is_floating_point_v<T>)
  operator T() const { printf("to float\n"); return 0; }

  // both accept
  template <typename T> requires requires { (T) std::declval<base>(); }
  operator T() const { return base::operator T(); }
};

derived D;
(int)   D;  // -> to int
(float) D;  // -> to float

Estou tentando usar o preenchimento automático do Algolia, a lista aparece bem, mas quando clicamos nela, nenhum evento é disparado, a rolagem de palavras-chave também está funcionando, mas a seção na lista não.

https://jsfiddle.net/qeLwbfpj/

const { autocomplete } = window['@algolia/autocomplete-js'];

var ac_instance = autocomplete({
    insights: true,
    container: '#autocomplete',
    placeholder: 'Type a name...',
    openOnFocus: true,

    getSources({ query }) {
        return [
            {
                sourceId: 'dummy-source',
                getItems() {
                    return [
                        { label: 'Apple', Id: '123' },
                        { label: 'Mango', Id: '456' },
                        { label: 'Banana', Id: '789' },
                        { label: 'Orange', Id: '101' }
                    ].filter(item => item.label.toLowerCase().includes(query.toLowerCase()));
                },
                templates: {
                    item({ item }) {
                        return item.label;
                    }
                }
            }
        ];
    },

    onSelect(item ) {
        console.log(`File: dummy.php, Line: 62`, item);
        alert(`File: dummy.php, Line: 63`);
    },

    onSubmit(state) {
        alert(`File: dummy.php, Line: 67`);

    }
});

console.log(`File: dummy.php, Line: 79`, ac_instance);

então estou executando este código

def login_or_join(request):

    if request.method == "POST":
        option = request.POST.get("option")
        print('post request recieved')

        if option == "1":
            return login_screen(request)

        if option == '2':
            return in_game(request)

    return render(request,"login_or_join.html")

e def login_screen() se parece com isso

def login_screen(request):
    if request.method == "POST":
    
        username = request.POST.get("username")
        password = request.POST.get("password")
        print(username)
        print(password)

        user = authenticate(request, username=username, password=password)
    
        print(user)

        if user is not None:
            return redirect('join_lobby')
        else:
            return render(request,'login_page.html',)
    
    return render(request, 'login_page.html')

Sempre que clico em "opção 1", ele executa login_screen, mas de uma forma que eu não quero. Parece que ele apenas segue essa solicitação.method == "POST" e imprime nome de usuário e senha imediatamente, o que significa que ele está definindo nome de usuário e senha imediatamente, tornando qualquer tentativa de login errada. Mas eu não quero que ele os defina (ou os imprima) até que eu tenha pressionado o botão na próxima página. Além disso, quando clico em "enter" ou "log in", ele não mostra novamente a página com a mensagem de erro, ele apenas retorna login_or_join(). Sinto que estou tomando pílulas malucas, pois estou trabalhando neste site há um tempo e esta é a primeira vez que estou tendo esse tipo de problema. Tentei mexer com ele, mas sinto que estou olhando para ele há muito tempo. Qualquer ajuda seria apreciada!

Tenho uma tabela PaymentItemscom 8 milhões de linhas. 100.000 linhas têm a chave estrangeira PaymentItemGroupId = '662162c6-209c-4594-b081-55b89ce81fda'.

Criei um índice não clusterizado na coluna PaymentItems.Date(ASC) para poder classificar/encontrar entradas mais rapidamente para datas.

Ao executar a seguinte consulta, levará cerca de 3 minutos:

SELECT TOP 10 [p].[Id], [p].[Receivers]
FROM [PaymentItems] AS [p]
WHERE [p].[PaymentItemGroupId] = '662162c6-209c-4594-b081-55b89ce81fda'
ORDER BY [p].[Date]

O interessante é que, sem o TOP 10, levará 18 segundos e retornará todas as 100.000 linhas. Quando eu ordeno decrescente em vez de crescente ( ORDER BY [p].[Date] DESC), levará cerca de 1 segundo. Quando eu removo o índice, também é mais rápido ao classificar de forma crescente.

Analisei o plano de consulta para a consulta lenta e parece que o MS SQL Server não filtra as linhas pela chave estrangeira primeiro, mas classifica todas as 8 milhões de linhas primeiro (varredura de índice não agrupada no Dateíndice).

Na consulta rápida, ele filtrará primeiro as condições where (pesquisa de chaves agrupada).

Há algo que eu possa fazer além de remover o índice para Dateevitar que o SQL Server crie um plano de consulta ruim como esse?

Aqui está o plano de consulta real: https://www.brentozar.com/pastetheplan/?id=xBBArQl9kh

Aqui está o script de criação da tabela:

CREATE TABLE [dbo].[PaymentItems](
    [Id] [uniqueidentifier] NOT NULL,
    [PaymentItemGroupId] [uniqueidentifier] NOT NULL,
    [Date] [datetime2](7) NOT NULL,
 CONSTRAINT [PK_PaymentItems] PRIMARY KEY CLUSTERED 
(
    [Id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]
GO
CREATE NONCLUSTERED INDEX [IX_PaymentItems_Date] ON [dbo].[PaymentItems]
(
    [Date] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
GO

CREATE NONCLUSTERED INDEX [IX_PaymentItems_PaymentItemGroupId] ON [dbo].[PaymentItems]
(
    [PaymentItemGroupId] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
GO

Problema

Digamos que eu tenha esta matriz em R:

(x <- matrix(1:6, ncol = 3, byrow = TRUE))
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6

que eu quero combinar por linhas várias vezes. Aqui está um exemplo usandorbind()

rbind(x, x)
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6
[3,]    1    2    3
[4,]    4    5    6

O problema é que quero fazer isso um número indefinido de vezes dentro de uma função e estou tentando evitar ficar xfazendo cópias dela.

O que eu tentei até agora

Tentei várias operações envolvendo replicate(), array(), matrix(), *apply(), e o mais próximo que cheguei do que queria foi isso (para duas repetições):

replicate(2, rbind(x))
, , 1

     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6

, , 2

     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6

Se eu tentar transformar isso em uma matriz, os elementos ficam misturados por causa de como a sequência da matriz é armazenada:

as.vector(replicate(2, rbind(x)))
[1] 1 4 2 5 3 6 1 4 2 5 3 6

Uma solução desajeitada

Até agora, a única maneira de conseguir o que queria foi abusando de t():

t(array(t(x), dim = c(ncol(x), nrow(x) * 2)))
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6
[3,]    1    2    3
[4,]    4    5    6

Aposto que há uma maneira mais limpa de fazer isso, mas depois de algumas horas estou perplexo. Alguém ajuda?

Perguntas relacionadas

Aqui estão algumas perguntas relacionadas com soluções que tentei sem sucesso:

• Replicar Matriz em R
• como vincular o mesmo vetor várias vezes?
• em que circunstâncias o R recicla?

Tenho uma matriz de ponteiros de função e quero atribuir funções fictícias simples.

A primeira coisa que me veio à mente foi usar lambda. Funcionou muito bem. A única coisa que me surpreendeu foi o fato de que obtenho endereços de ponteiro diferentes quando os atribuo um por um, mas obtenho endereços idênticos quando faço isso em um loop.

#include <iostream>

int main()
{

    int (*ptrArr[6])(void);
    int size = sizeof(ptrArr)/sizeof(void*);

    // results in three different pointer addresses
    ptrArr[0] = [](){return 0;};
    ptrArr[1] = [](){return 0;};
    ptrArr[2] = [](){return 0;};

    // results in three identical pointer addresses
    for(int i = 3; i < size; i++)
    {
        ptrArr[i] = [](){return 0;};
    }

    for(int i = 0; i < 6; i++)
    {
        std::cout << (void*)ptrArr[i] << std::endl;
    }

    return 0;
}

Saída:

00E9F810
00E9F840
00E9F870
00E9F8A0
00E9F8A0
00E9F8A0

Existe uma maneira de obter diferentes instâncias das funções fictícias usando o loop?

Também tentei algumas construções usando std::function<>, mas não consegui atribuí-lo aos ponteiros de função.

Ao sombrear identro do loop for, o seguinte código

#include <stdio.h>

int main()
{
    for (int i = 1; i < 5; i++) {
        printf("%d", i);
        int i = i;
        printf("%d ", i);
    }
}

saídas:

10 20 30 40

Pelo meu entendimento de shadowing, deveria ter sido icriado um novo com o valor igual ao anterior i. Isso significa que a saída que eu esperava seria:

11 22 33 44

Além disso, o código parece armazenar o novo ivalor se você incrementá-lo.

#include <stdio.h>

int main()
{
    for (int i = 1; i < 5; i++) {
        printf("%d", i);
        int i = i + 2;
        printf("%d ", i);
    }
}

isso produz:

12 24 36 48

Aparentemente, inão está sendo redeclarado a cada iteração - funciona como uma variável que foi inicialmente 0e depois incrementada a cada iteração.

O que está realmente acontecendo aqui? Como você prevê o comportamento?