Soma segura de estouro

Suponha que eu receba números inteiros de largura fixa (ou seja, eles se encaixam em um registro de largura ), modo que sua soma também se encaixe em um registro de largura . $n$ $w$ $a_1, a_2, \dots a_n$ $a_1 + a_2 + \dots + a_n = S$ $w$

Parece-me que sempre podemos permutar os números para modo que cada soma de prefixo também se ajuste a um registro de largura . $b_1, b_2, \dots b_n$ $S_i = b_1 + b_2 + \dots + b_i$ $w$

Basicamente, a motivação é calcular a soma em máquinas de registro de largura fixa sem ter que se preocupar com estouros de número inteiro em qualquer estágio intermediário. $S = S_n$

Existe um rápido (tempo de preferência linear) algoritmo para encontrar uma tal permutao (assumindo a são dadas como uma matriz de entrada)? (ou diga se essa permutação não existe). $a_i$

— Aryabhata
fonte

Acompanhamento: Detecção de estouro na soma - existe um método mais rápido que leva em consideração os recursos típicos do processador?

— Gilles 'SO- stop be evil'

Basta usar dois registros de complemento e somar. Mesmo se estourar no meio, sua pré-condição garante que os estouros sejam cancelados e o resultado estará correto. : P

— CodesInChaos

@CodeInChaos: Isso é realmente verdade?

— Aryabhata

Acho que sim. Você está trabalhando essencialmente em um módulo de grupo 2 ^ n, onde escolhe a representação canônica de -2^(n-1)para 2^(n-1)-1. É claro que requer o complemento de dois e um comportamento de estouro bem definido, mas em uma linguagem como C # deve funcionar.

— código é o seguinte

@CodeInChaos: Não existem duas possibilidades que dão o mesmo módulo restante

? Você está basicamente dizendo, independentemente da ordem, um deles nunca pode acontecer. Ou eu estou esquecendo de alguma coisa?

2^{n}

$2^n$

— Aryabhata

Estratégia
O algoritmo de tempo linear a seguir adota a estratégia de pairar em torno de , escolhendo números positivos ou negativos com base no sinal da soma parcial. Ele processa previamente a lista de números; calcula a permutação da entrada on-the-fly , enquanto executa a adição. $0$

Algoritmo

Particionar em um duas listas, os elementos positivos e os elementos negativos . Os zeros podem ser filtrados. $a_1, \ldots, a_n$ $P$ $M$
Deixe . $Sum=0$
Embora as duas listas não estejam vazias
$~~~~~~$ Se { ; $Sum>0$ $Sum:=Sum+\text{head}(M)$ ; } $M:=\text{tail}(M)$
$~~~~~~$ outro { ; ; } $Sum:=Sum+\text{head}(P)$ $P:=\text{tail}(P)$
Quando uma das duas listas fica vazio, adicione o resto da lista restante para . $S$

Correção A
correção pode ser estabelecida usando um argumento indutivo direto no comprimento da lista de números.

Em primeiro lugar, provar que se são todos positivos (ou todos negativos), e sua soma não causa excesso, em seguida, nem as somas de prefixo. Isso é direto. $a_1, \ldots, a_n$

Em segundo lugar, provar que é dentro de limites é uma invariante do ciclo do algoritmo. Claramente, isto é verdade em cima da entrada para o circuito, como . Agora, se , adicionando um número negativo que está dentro de limites para a não causa para ir fora dos limites. Da mesma forma, quando adicionar um número positivo dentro dos limites da soma não causa sair dos limites. Assim, ao sair do loop, $Sum$ $Sum=0$ $Sum>0$ $Sum$ $Sum$ $Sum\le0$ $Sum$ é dentro de limites. $Sum$

Agora, o primeiro resultado pode ser aplicado e, juntos, são suficientes para provar que a soma nunca sai dos limites.

— Dave Clarke
fonte

Para uma implementação eficiente no local, execute a) Particionamento por Quicksort (a variante de dois ponteiros) com pivô implícito

e, em seguida, b) some, movendo um ponteiro pela área com resp negativo. números positivos.

0

$0$

— Raphael