Como você identifica casos "avançados" em algoritmos?

Basicamente, como você descobre qual poderia ser seu pior ou melhor caso e qualquer outro caso "básico" que você possa ter antes de tê-los e, portanto, como você prepara seu código para eles?

Com base no conteúdo do algoritmo, você pode identificar quais estruturas / tipos / construções de dados são usadas. Em seguida, você tenta entender os (possíveis) pontos fracos desses e tenta criar um plano de execução que o faça executar nesses casos.

Por exemplo, o algoritmo usa uma string e um número inteiro como entrada e faz uma classificação dos caracteres da string.

Aqui temos:

String com alguns casos especiais conhecidos:

• String vazia
• Long string
• Sequência Unicode (caracteres especiais)
• Se limitado a um conjunto específico de caracteres, o que acontece quando alguns não estão no intervalo
• Cadeia de comprimento ímpar / par
• Nulo (como argumento)
• Não nulo encerrado

Inteiro com casos especiais conhecidos:

• 0 0
• Min / MaxInt
• Negativo positivo

Algoritmo de classificação que pode falhar nos seguintes casos de limite:

• Entrada vazia
• 1 entrada de elemento
• Entrada muito longa (talvez com comprimento máximo (tipo de dados usado para o índice))
• Lixo dentro da coleção que será classificada
• Entrada nula
• Elementos duplicados
• Coleção com todos os elementos iguais
• Entrada ímpar / par de comprimento

Em seguida, pegue todos esses casos e crie uma lista longa tentando entender como eles se sobrepõem. Ex:

• O estojo de cordas vazio cobre o estojo de coleção vazio
• String nula == coleção nula
• etc.

Agora crie casos de teste para eles :)

Resumo resumido : quebre o algoritmo em blocos básicos para os quais você conhece os casos de limite e depois remonte-os, criando casos de limite globais

Eu não acho que exista algum algoritmo para determinar condições de borda .... apenas experiência.

Exemplo: para um parâmetro de byte, você deseja testar números como 0, 127, 128, 255, 256, -1, qualquer coisa que possa causar problemas.

Uma "aresta" tem dois significados, e ambos são relevantes quando se trata de arestas. Uma aresta é uma área em que uma pequena alteração na entrada leva a uma grande alteração na saída ou no final de um intervalo.

Portanto, para identificar os casos extremos de um algoritmo, primeiro analiso o domínio de entrada. Seus valores de borda podem levar a casos de borda do algoritmo.

Em segundo lugar, olho para o domínio de saída e para os valores de entrada que podem criá-los. Geralmente, esse é um problema com algoritmos, mas ajuda a encontrar problemas nos algoritmos projetados para gerar saídas que abrangem um determinado domínio de saída. Por exemplo, um gerador de números aleatórios deve ser capaz de gerar todos os valores de saída pretendidos.

Finalmente, verifico o algoritmo para ver se há casos de entrada semelhantes, mas que levam a resultados diferentes. Encontrar esses casos extremos é o mais difícil, pois envolve domínios e um par de entradas.

Esta é uma pergunta muito geral, então tudo o que posso fazer é lançar algumas idéias gerais e vagas :)

- Examinar casos de fronteira. Ex. se você estiver analisando uma string, o que acontece se a string estiver vazia ou nula? Se você está contando de x até y, o que acontece em x e y?
-Código que pode ser simplificado ou desidratado. Qualquer complexidade desnecessária pode adicionar coisas que podem dar errado.

Parte da habilidade de usar algoritmos é conhecer suas fraquezas e casos patolíticos. A resposta de Victor dá algumas boas dicas, mas, em geral, aconselho que você precise estudar o tópico com mais profundidade para ter uma idéia disso, acho que você não pode seguir as regras práticas para responder a essa pergunta completamente. Por exemplo, veja Cormen ou Skiena (Skiena, em particular, tem uma seção muito boa sobre onde usar algoritmos e o que funciona bem em certos casos, Cormen aborda mais teorias, eu acho).