¿Cómo identifica los casos de "borde" en los algoritmos?

Básicamente, ¿cómo saber cuál podría ser su peor o mejor caso y cualquier otro caso "marginal" que pueda tener ANTES de tenerlos? Entonces, ¿cómo prepara su código para ellos?

Según el contenido del algoritmo, puede identificar qué estructuras de datos / tipos / construcciones se utilizan. Luego, trata de comprender los (posibles) puntos débiles de esos e intenta llegar a un plan de ejecución que lo haga funcionar en esos casos.

Por ejemplo, el algoritmo toma una cadena y un número entero como entrada y ordena los caracteres de la cadena.

Aquí tenemos:

Cadena con algunos casos especiales conocidos:

• Cuerda vacía
• Cuerda larga
• Cadena Unicode (caracteres especiales)
• Si se limita a un conjunto específico de caracteres, ¿qué sucede cuando algunos no están en el rango?
• Cadena de longitud impar / par
• Nulo (como argumento)
• No nulo terminado

Entero con casos especiales conocidos:

• 0 0
• Min / MaxInt
• Negativo positivo

Algoritmo de clasificación que podría fallar en los siguientes casos límite:

• Entrada vacía
• Entrada de 1 elemento
• Entrada muy larga (tal vez de longitud máxima (tipo de datos utilizado para el índice))
• Basura dentro de la colección que se ordenará
• Entrada nula
• Elementos duplicados
• Colección con todos los elementos iguales
• Entrada de longitud impar / par

Luego, tome todos estos casos y cree una larga lista tratando de entender cómo se superponen. Ex:

• El estuche de cuerda vacío cubre el estuche de colección vacío
• Cadena nula == colección nula
• etc.

Ahora cree casos de prueba para ellos :)

Breve resumen : divida el algoritmo en bloques básicos para los que conoce los casos límite y luego vuelva a ensamblarlos, creando casos límite globales

No creo que haya ningún algoritmo para determinar las condiciones de borde ... solo experiencia.

Ejemplo: para un parámetro de byte, desearía probar números como 0, 127, 128, 255, 256, -1, cualquier cosa que pueda causar problemas.

Un "borde" tiene dos significados, y ambos son relevantes cuando se trata de casos extremos. Un borde es un área donde un pequeño cambio en la entrada conduce a un gran cambio en la salida o al final de un rango.

Entonces, para identificar los casos extremos de un algoritmo, primero miro el dominio de entrada. Sus valores de borde podrían conducir a casos de borde del algoritmo.

En segundo lugar, miro el dominio de salida y miro hacia atrás a los valores de entrada que podrían crearlos. Esto es un problema menos común con los algoritmos, pero ayuda a encontrar problemas en los algoritmos que están diseñados para generar resultados que abarcan un dominio de salida determinado. Por ejemplo, un generador de números aleatorios debería poder generar todos los valores de salida previstos.

Finalmente, verifico el algoritmo para ver si hay casos de entrada que son similares, pero que conducen a salidas diferentes. Encontrar estos casos extremos es lo más difícil, porque involucra tanto dominios como un par de entradas.

Esta es una pregunta muy general, así que todo lo que puedo hacer es descartar algunas ideas generales y vagas :)

-Examinar casos límite. Ex. si está analizando una cadena, ¿qué sucede si la cadena está vacía o nula? Si cuentas de x a y, ¿qué sucede en x e y?
-Código que podría simplificarse o SECARSE. Cualquier complejidad innecesaria podría agregar cosas que podrían salir mal.

Parte de la habilidad de usar algoritmos es conocer sus debilidades y casos patológicos. La respuesta de Victor ofrece algunos buenos consejos, pero en general le aconsejaría que necesitara estudiar el tema con más profundidad para tener una idea de esto, no creo que pueda seguir las reglas generales para responder a esta pregunta en su totalidad. Por ejemplo, vea Cormen o Skiena (Skiena en particular tiene una muy buena sección sobre dónde usar algoritmos y qué funciona bien en ciertos casos, creo que Cormen aborda más teoría).