## google sheets – Excluding a Column Range from a Filter Equation

I’ve been bashing my head against this for hours.

My boss has a filter equation running in column A that spits out a long list of ID numbers. In column B, there is a running manual list of ID numbers that we DON’T want to show up in column A.

When I try to set the condition for the range to exclude the range “A:A<>B:B” in a filter, it just ignores it and includes B’s IDs anyway.

I need a filter for Column A that will exclude the running list of data in Column B. Thanks!

## algorithms – How to sort an array \$A[1..n]\$ where all but \$lfloor sqrt n rfloor\$ elements are integers in range \$sqrt n\$ to \$nsqrt n\$, at \$Theta(n)\$ time?

In the rest of the answer I will slightly abuse the notation by treating $$A$$ as a set. For simplicity I will also assume that the integers to sort are distinct, so that we are dealing with sets instead of multisets. This assumption is easy to remove.

Construct a min-heap $$H^-$$ and a max-heap $$H^+$$, each containing all elements in $$A$$. Extract the minimum $$lfloor sqrt{n} rfloor$$ times from $$H^-$$ and let $$S^-$$ be the set of the extracted elements.
Similarly, extract the maximum $$lfloor sqrt{n} rfloor$$ times from $$H^+$$, and let $$S^+$$ be the set of the extracted elements. The overall time required so far is $$O(n) + O(sqrt{n} log n) = O(n)$$. (Notice also that $$S^- cap S^+ = emptyset$$ since $$2 lfloor sqrt{n} rfloor le n$$ for $$n > 1$$).

Now you know that all the elements in $$A setminus (S^- cup S^+)$$ are integers between $$0$$ and $$n^{3/2}$$ (actually, between $$sqrt{n}$$ and $$n^{3/2}$$, but this is irrelevant), and therefore can be sorted in time $$O(n)$$ using Radix sort (indeed, each integer in $$S setminus (S^- cup S^+)$$ has just two digits when written in base $$n$$).
Let $$A’$$ be the sorted version of $$A setminus (S^- cup S^+)$$.

To obtain a sorted version of $$A$$, we just need to insert the elements in $$S^- cup S^+$$ into the right position of $$A’$$.
This can be done by first sorting $$S^- cup S^+$$ in time $$O(n)$$ (any quadratic-time algorithm suffices since $$|S^- cup S^+| le 2 sqrt{n}$$) and then merging the resulting sorted sequence with $$A’$$ a-la-Mergesort.

## ubuntu – UFW – Allow outgoing traffic to a range?

I’m attempting to restrict outbound 443 traffic from a server to a set of subnets. When I write the tuple rules in my user.rules file, this looks like it should work, however no traffic is being allowed to the subnet. Does UFW not allow ranges in destinations?

`### tuple ### allow tcp 443 X.X.X.0/24 any 0.0.0.0/0 out`

Thank you

## How to query data range including data formatting (color, font) in Google sheets?

How to modify this formula to make the result get the data with its original color & font formatting.

`=query(Sheet1!A1:D,"select A,B,C,D where A is not null",0)`

Lets say I want only column D to be in the new tab with its original color format.

## How to randomly pick a cell out of a range and print its value in a different cell in Google Sheets?

By clicking “Accept all cookies”, you agree Stack Exchange can store cookies on your device and disclose information in accordance with our Cookie Policy.

## independente de linguagem – Por que ocorre e como resolver um erro de “out of bounds” ou “out of range” ou algo de tipo?

Antes de mais nada este é um erro de programação. É importante dizer isso porque costuma ser uma exceção em várias linguagens e as pessoas ficam tentadas em capturar a exceção e fazer alguma. Isto é usar exceção para controle de fluxo, é deixar de validar algo que pode ocorrer de errado para só tratar se der o erro, não faça isto, corrija o erro, mesmo que seja fazer a validação e dar o tratamento antes de dar o erro.

Este erro (não vou falar em exceção aqui, porque mesmo que seja lançada uma, ainda é um erro) ocorre apenas em coleções de dados ou objetos compostos que se comportam como coleções (algumas linguagens de tipagem dinâmica possuem composições implementadas como uma coleção, por exemplo uma classe ou algo parecido é implementada como um dicionário que é uma coleção). Para acessar um elemento da coleção é preciso dizer qual é o elemento desejado, de alguma forma. Esta forma costuma ser chamada de índice, mas em alguns casos pode ser uma chave, e em inglês podem usar o termo subscript. Este valor que indexa o elemento da coleção tende a ser um número, mas nada impede que seja outros tipos de dados, de fato em dicionários é comum ser strings.

Algumas coleções os valores são sequenciais e formam uma faixa clara de dados, por exemplo começa em 0 e termina 9, possuindo uniformemente 10 elementos em sequência, possuem uma forma de array, mesmo que não seja exatamente um. Em coleções mais livres podem ter índices/chaves (o termo mais usado nesses casos) esparsos, ou seja, os valores não estão de forma sequencial, então se for números pode começar em qualquer número e terminar em qualquer outro e não precisa ter todos os números entre eles. O mesmo vale para strings ou outros dados como chave.

``````for (var i = 1; i <= lista.Count; i++) //erro aqui
for (var i = 1; i < lista.Count; i++) //certo
``````

Uma string é uma coleção de dados, ela é uma sequência de caracteres geralmente começada no caractere de posição 0 e terminando no tamanho menos um, não tente acessar uma caractere que esteja fora desta faixa. É comum a pessoa tentar acessar sem querer fora desta faixa, talvez porque tentou fazer uma busca que não achou a informação (pode retornar -1).

Se considerar que uma tabela ASCII ou algo parecido é uma coleção, pode ocorrer algo semelhante sem dar erro, só resultado ruim. Outro exemplo.

Como é uma coleção esse valor de índice/chave precisa existir nela, se não existir ocorre o erro descrito na pergunta ou alguma variante dele.

Em coleções normais como arrays o termo faixa ou o uso de limites de início e fim é mais usado porque ele certamente tem todos os números de uma faixa, o que você não pode fazer é acessar um número que esteja fora dessa faixa. Não é obrigatória começar em 0, mas se começar não pode usar um valor que seja negativo. E não pode acessar um valor que seja maior do que a quantidade de elementos. Então se começa com 0 não pode ser nem o número que indica o tamanho, nem um número maior que este. Porque se começa do 0, por exemplo se tiver 10 elementos, vai de 0 até 9, então o 10 já não é válido. Se começar em 1, então o 10 seria válido, mas o 11 não, e neste caso o 0 também seria inválido.

``````letr = (2, 5, 6, 18, 20, 10, 23, 12, 19, 10);
let s = (1, 5, 7, 13, 18, 21, 10, 25, 32, 17, 3);
let x = (0);
let i;
console.log("i = " + i);
for (i = 0; i <= 9; i++) {
x(i) = r(i);
console.log("i = " + i);
}
console.log("i = " + i);
for (i = 0; i <= 10; i++) {
x(i + 10) = s(i);
console.log("i = " + i);
}
console.log("i = " + i);``````

O erro pode indicar um valor fora da faixa para baixo ou para cima, não importa.

O erro ocorre de forma muito comum quando o índice que é usado é obtido usado uma fórmula ou é obtido por um dado externo que aquele algoritmo não tem controle. Ou ocorre quando vai acessar um elemento específico ou então quando faz um laço e este laço ou começa no número errado ou tenta terminar depois que já avaliou todos elementos que tinha que analisar.

É comum ocorrer em funções e métodos que tem um laço internamente, um caso muito comum é a `Substring()`.

Tem uma classe que mostra superficialmente como o erro é gerado.

No caso do laço o ideal é usar uma construção da linguagem, se tiver que varrer toda coleção por controle próprio assim não tem muito como errar (desde que a coleção não seja modificada em sua estrutura e não mude a quantidade de elementos existentes). Pode ser um `foreach` ou um `for` abstrato que faça isto. Quando usa um `for` bruto ou `while` onde o programador controla onde deve parar é que costuma acontecer o erro. O erro mais comum é a pessoa colocar a comparação verificando o fim se o contador é menor ou igual ao tamanho, mas se começa do zero tem que ser menor que tamanho total da coleção.

``````foreach (var item in lista) WriteLine(item); //assim não tem como dar esse erro
``````

Há casos que está usando um laço mas não acessando o elemento de forma direta mas sim calculando o número usando o contador do laço como parte da fórmula, este um caso híbrido, o problema pode ser no limite do contador ou pode ser na fórmula. Por exemplo, se você usa uma fórmula que pega sempre o “contador mais um”, obviamente não pode ir até o último valor possível na coleção porque o último possível mais um dá um número fora da faixa, por exemplo se a coleção vai de 0 a 9, o contador deve parar em 8, se for no 9 a fórmula resultará em 10 e dará o erro.

Então a solução para o problema é sempre validar certo quando deve parar, nunca deixar passar do número do elemento que não existe na coleção naquele momento. Nunca pressuponha que sabe quantos elementos tem ali, sempre pegue esse número ou use uma construção que garanta isso.

``````if (n >= 0 && n < opcoes.size()) return opcoes(n)->reproduz();
``````

No caso do acesso ser feito individualmente por um dado calculado ou obtido externamente quase sempre é necessário validar o dado variável e que veio sem controle direto do seu algoritmo. Se não passar na validação de estar entre a faixa inicial (geralmente 0) e a final (geralmente o tamanho da coleção menos um), ou ainda se tem aquela chave, então deve fazer alguma operação alternativa, geralmente retornando um erro ou fazendo algo diferente (em alguns casos até pode lançar uma exceção, mas não costuma ser a melhor opção, mas se forma uma exceção mais específica em alguns casos pode ser interessante, só é mais raro ser o certo).

Só acesse um índice/chave condicionalmente, a não ser que seja 100% garantido que não tem como ser um dado inválido, mas são raros casos assim, como pode ser visto nos códigos e links postados aqui. Esta dica para para qualquer dado não só estes que são índices/chaves, quase todos os bugs ocorrem porque algum dado não está no estado que está esperando e não pode confiar em nada.

O uso de `assert()`, `requires()` ou algo semelhante costuma ser uma boa ideia.

Algumas estruturas de dados não lançam erros ou exceções quando a chave não existe, apenas retornam um código de erro que pode ser um nulo. Algumas tem métodos que permitem escolher o que acontece quando tenta acessar uma chave não existente. Cuidado pode parecer certo porque funciona, mas dará resultado ruim.

Tem linguagens que não dão erro, só ferra tudo. C, e C++ em certa medida, são assim.

Se você não está passando uma posição em uma coleção de dados então o erro não acontecerá, então precisa de duas coisas: coleção de dados e posição sendo acessada. A Posição pode ser passada por um operador indexador, muito comum ser colchetes `objeto(x)`, mas outras linguagens podem ter outras notações, JS pode fazer assim `objeto.x` e ainda é uma posição nessa coleção. Também pode ocorrer em métodos que recebem a posição de uma forma ou de outra, pode ser até um dado que será usado para calcular a posição.

Um teste de mesa manual ou auxiliado pelo IDE (debugger) sempre indicará o que está acontecendo. Você executa passo a passo e analisa o valor do elemento sendo usado e verá que um dele logo no momento que dará o erro está acessando um índice/chave que não existe, por isso é preciso saber todas chaves possíveis ou a faixa do índice possível.

Lembre-se sempre de olhar o dado naquele momento, ele pode não ser o que deseja, pode não conter todos elementos que está esperando, isto pode ser a causa do erro. Se o dado estiver ok então seu algoritmo está pegando um valor que não devia.

Não tem milagre, não tem resposta fácil e rápida, tem que analisar o que está acontecendo. Faça a análise e aprenda programar melhor n o processo. Aprenda se virar por conta própria, você vai precisar.

Este é um erro chato por sempre ocorre em tempo de execução (existem poucas situações que poderia ser evitado em tempo de execução e nem costuma valer o esforço fazer isto).

Não falei, mas já vi erros em que o valor sendo usado era um literal e portanto de total controle do algoritmo sendo escrito ali. Quase sempre o problema não está bem nesse algoritmo, está no dado recebido, provavelmente você esperava receber uma coleção de dados com um número determinado de elementos e por alguma razão não está recebendo isto. Provavelmente o problema está na criação do dado e deve concentrar os esforços em analisá-lo. Você pode melhorar seu algoritmo para lidar com um caso de erro assim, mas quase sempre o resultado melhor fazer o dado vir corretamente já que faz parte do contrato vir assim. Claro, isso pode não ser um bom design, não é robusto, ou para dar robustez complica o código e piora a performance, mas muita gente desenvolve sem pensar nessas coisas (todos que escolhem uma linguagem de tipagem dinâmica). Exemplo.

De uma certa forma pode ser visto como uma variante da divisão por zero. Só ocorre porque está recebendo um valor que não é aceito naquele contexto. Não importa o que faça, a solução sempre está em validar implícita ou explicitamente o dado que será usado como índice/chave antes de usar, tem que ser garantido que ele existe.

Exemplo em C# de código robusto para não deixar acessar um elemento que não existe inadvertidamente.

Exemplos de perguntas que falam deste erro, é quase certo que o seu está coberto em algum.

Vou colocar mais exemplos, tentar usar mais linguagens, outras respostas podem ajudar mais pessoas

## sorting – sort array with some of the elements in a known range

let $$A$$ be an array of n elements. We know that $$n – lfloor sqrt n rfloor$$ elements are integers in range $$sqrt n$$ to $$nsqrt n$$ (the other $$lfloor sqrt n rfloor$$ elements may or may not be in the range). I need to sort the array in $$Theta (n)$$.

I thought of partitioning the array to 3 subarray:

1. elements smaller than $$sqrt n$$
2. element in range $$sqrt n$$ to $$nsqrt n$$
3. element bigger than $$nsqrt n$$

the first and last subarrays can be sorted with insertion sort in $$O(n)$$ because there are at most $$lfloor sqrt n rfloor$$ elements in those arrays. The second array have between $$n – lfloor sqrt n rfloor$$ to $$n$$ elements in range $$sqrt n$$ to $$nsqrt n$$ so using counting sort will run in $$O(nsqrt n)$$. Using bucket sort where each bucket has all the elements in subrange with n integers each bucket can be sorted with counting sort in O(n) and there are $$sqrt n$$ buckets so the sort will also take $$O(nsqrt n)$$.

My problem is how to sort that second array in $$O(n)$$, I assume it is something to do with the amount of buckets or maybe the subrange of each bucket, as sorting the second array costs $$O(number_ of_buckets * O(number_of_elements_in_bucket + number_of_integers_in_range))$$

## Full Range of Servers

We are offering full range of dedicated Servers, Cloud Servers and Services.

8 Core 8 GB Cloud Servers \$12/month
8 Core 8 GB Dedicated Servers \$34/month
24 Core 16 GB Dedicated Servers \$64/month
Itel dialer from \$79/month
ItelSwitch from \$79/month
VOIPSwitch from \$59/month
Goautodial/Vicidial from \$38/month
CPanel Server from \$32/month
VPN Connection \$4/month
Windows 10 Virtual Desktop from \$9/month
Website Account with 5 Domains \$9/month
Email Hosting with 5 Accounts \$9/month

Order today…

Full Range of Servers

## Jquery Conditional Formatting – Number Range

Not the way that you are selecting cells, because you are using the CSS selector `:contains()` to find cells with a specific text value. You can’t use `contains()` for anything other than an exact match.

You could look at ranges if you get the value of the table cells in a usable way in code and then compare it to a range:

``````// this selects _all_ of the table cells that match your CSS selector,
// regardless of their content, and loops through them all
\$("td .ms-vb-lastCell.ms-cellstyle.ms-vb2.ms-vb-lastCell").each(function() {

// inside the loop function, "\$(this)" refers to the single table cell
// that is getting looped over that time through the loop.  you can use
// jQuery's "text()" function to get the text contents of the cell
var cellText = \$(this).text();

// from your code example, it appears as though you are expecting the
// contents of the cells to be precentages, i.e "10%", "20%", etc.
// so you can use parseInt() to change the percentage string into
// an actual number so you can do number comparisons
var cellPercentValue = parseInt(cellText);

// then you can do your comparisons, and set the background color
// accordingly.  remember "\$(this)" still refers to the table cell
if (cellPercentValue >= 50) {
\$(this).css('background-color', 'green');
} else if (25 <= cellPercentValue < 50) {
\$(this).css('background-color', 'yellow');
} else if (cellPercentValue < 25) {
\$(this).css('background-color', 'red');
}
});
``````

## Full Range of Servers

We are offering full range of dedicated Servers, Cloud Servers and Services.

8 Core 8 GB Cloud Servers \$12/month
8 Core 8 GB Dedicated Servers \$34/month
24 Core 16 GB Dedicated Servers \$64/month
Itel dialer from \$79/month
ItelSwitch from \$79/month
VOIPSwitch from \$59/month
Goautodial/Vicidial from \$38/month
CPanel Server from \$32/month
VPN Connection \$4/month
Windows 10 Virtual Desktop from \$9/month
Website Account with 5 Domains \$9/month
Email Hosting with 5 Accounts \$9/month

Order today at Datasoft networks.

Thanks,

Datasoft networks.