Cuente cuántas veces aparece un número en la matriz si aparece más de una vez, devuelva verdadero?

Sería mucho más fácil hacerlo, si la lista está ordenada, no importa, en orden ascendente o descendente. Porque, entonces encontrarás los mismos números lado a lado.

Ej. Array – [1,5,6,8,7,1,6,5,9]

el código para C sería como: (función)

int Check_Repeat_Number (int _Number)
{
int _Count = 0;
para (i = 0; i if (_Number == Array [i]) {
_Count ++;
}
}
si (_Count> 1) {
devuelve 1;
} else {
devuelve 0;
}

Quizás haya algunos errores de sintaxis, ya que estoy más involucrado en la programación de lotes ( archivo de lotes ) en estos días. Por lo tanto, la sintaxis está fuera de mi mente. Pero, la lógica sigue siendo la misma incluso en el antiguo lenguaje de piedra.

Preguntas que hacer:

1. ¿Es un número o un número específico para verificar?
2. ¿Está ordenada la matriz?

Suponiendo que hay un número específico para buscar y que la matriz no está ordenada … la idea más sencilla (usando C #):

público bool FindDupes (número int, int [] array)
{
var encontrado = falso;
para (int i = 0; i si (número == matriz [i]) {
si se encuentra) {
devuelve verdadero
}
encontrado = verdadero;
}
}
falso retorno;
}

O utilizando el método Exists integrado en una matriz, y un delegado para verificar si se encuentra un segundo número:

public bool FindDupesDelegate (número int, int [] array)
{
var encontrado = falso;
devuelve Array.Exists (array, delegate (int a) {
si (numero == a) {
si se encuentra) {
devuelve verdadero
}
encontrado = verdadero;
}
falso retorno;
});
}

O realizar lo mismo a través de Linq en un enumerable (no solo una matriz sino cualquier tipo de colección):

public bool FindDupesLinq (número int, colección IEnumerable )
{
var encontrado = falso;
return return collection.Contains (número, delegado (int a, int b) {
si (a == b) {
si se encuentra) {
devuelve verdadero
}
encontrado = verdadero;
}
falso retorno;
});
}

El más óptimo utilizando la búsqueda lineal más rápida posible dependiendo del sistema, incluso podría estar usando instrucciones especiales de la CPU como SSE2 (dependiendo de la configuración del compilador y la optimización):

public bool FindDupesOptimal (número int, int [] array)
{
var found = Array.IndexOf (array, number);
return (encontrado> = 0) && (Array.IndexOf (matriz, número, encontrado + 1)> 0);
}

Si la matriz está ordenada, los duplicados se colocarán uno al lado del otro. Por lo tanto, realizar una búsqueda binaria podría ser incluso más rápido. Luego simplemente verifique si el valor antes / después también es el mismo:

public bool FindDupesSorted (int number, int [] array)
{
if (array.Length> 1) {
var found = Array.BinarySearch (array, número);
si (encontrado <0) {
falso retorno;
}
si (encontrado == 0) {
matriz de retorno [1] == número;
} else if (found == (array.Length – 1)) {
matriz de retorno [encontrado – 1] == número;
}
retorno (matriz [encontrado – 1] == número) || (matriz [encontrado + 1] == número);
}
falso retorno;
}

La respuesta más simple:

int resultado = 0;
para (int num: array)
si (num == numero)
resultado ++;
resultado de retorno> 1

Este es probablemente el más rápido, ya que no tiene ifs.