> For the complete documentation index, see [llms.txt](https://educacion.gitbook.io/programacion/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://educacion.gitbook.io/programacion/exercicios-java/ud2-solucions/arrays/arrays.md).

# Arrays

1. Escribe unha función que reciba como parámetro un array de enteiros e un valor enteiro, e que devolva un enteiro que represente o número de veces que aparece o enteiro no array.

```java
static int contarAparicions(int[] array, int valor) {
    int contador = 0;
    for (int i = 0; i < array.length; i++) {
        if (array[i] == valor) {
            contador++;
        }
    }
    return contador;
```

2. Escribe unha función que reciba como parámetro un array de Strings e que devolva a lonxitude do String con maior numero de caracteres. Se un String non ten caracteres (""), a función lanzará unha excepción que debe de ser xestionada polo programa

```java
static int lonxitudeMaior(String[] cadeas) throws Exception {
    int max = 0;
    for (int i = 0; i < cadeas.length; i++) {
        if (cadeas[i].equals("")) {
            throw new Exception("Atopouse unha cadea baleira.");
        }
        if (cadeas[i].length() > max) {
            max = cadeas[i].length();
        }
    }
    return max;
```

3. Escribe un procedemento que reciba como parámetro un array de Strings e un char. Deberá de mostrar por pantalla todas a cadeas do array que conteñan o carácter. Se ningunha o contén, deberá de mostrar unha mesaxe indicando "Caracter non atopado".

```java
static void mostrarCadeasConChar(String[] cadeas, char caracter) {
    boolean atopado = false;
    String busca = String.valueOf(caracter); // converter o char en String

    for (int i = 0; i < cadeas.length; i++) {
        if (cadeas[i].contains(busca)) {
            System.out.println(cadeas[i]);
            atopado = true;
        }
    }

    if (!atopado) {
        System.out.println("Caracter non contido.");
    }
```

4. Escribe unha función que reciba como parámetro dous array de enteiros de igual lonxitude, e que devolva un array composto polo valor menor de cada unha das posicions (Exemplo: \[4,8,15,1] e \[7,2,11,18] devolve \[4,2,11,1]). Se os arrays non teñen a mesma lonxitude, a función lanzará unha excepción que debe de ser xestionada polo programa.

```java
static int[] menoresDeCadaPos(int[] a1, int[] a2) throws Exception {
    if (a1.length != a2.length) {
        throw new Exception("Os arrays deben ter a mesma lonxitude.");
    }

    int[] resultado = new int[a1.length];
    for (int i = 0; i < a1.length; i++) {
        resultado[i] = Math.min(a1[i], a2[i]);
    }
    return resultado;
}
```

5. Primitiva

```java
public class Primitiva {

    // --- Función que xera unha combinación aleatoria de 6 números (poden repetirse) ---
    public static int[] xerarCombinacion() {
        int[] combinacion = new int[6];
        Random rnd = new Random();

        for (int i = 0; i < 6; i++) {
            combinacion[i] = rnd.nextInt(50); // número entre 0 e 49
        }

        return combinacion;
    }

    // --- Conta cantos números coinciden entre dúas combinacións ---
    public static int contarAciertos(int[] boleto, int[] gañadora) {
        int acertos = 0;
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 6; j++) {
                if (boleto[i] == gañadora[j]) {
                    acertos++;
                    break; // evita contar o mesmo número gañador dúas veces
                }
            }
        }
        return acertos;
    }

    // --- Simula o sorteo ---
    public static int[] simularSorteo(int nBoletos, int[] gañadora) {
        int[] resultados = new int[4]; // índices: [3 acertos, 4 acertos, 5 acertos, 6 acertos]

        for (int i = 0; i < nBoletos; i++) {
            int[] boleto = xerarCombinacion();
            int acertos = contarAciertos(boleto, gañadora);

            if (acertos >= 3 && acertos <= 6) {
                resultados[acertos - 3]++;
            }

            System.out.print("Boleto " + (i + 1) + ": ");
            mostrarCombinacion(boleto);
            System.out.println(" → " + acertos + " acertos");
        }

        return resultados;
    }

    // --- Mostra unha combinación por pantalla ---
    public static void mostrarCombinacion(int[] comb) {
        for (int i = 0; i < comb.length; i++) {
            System.out.print(comb[i] + (i < comb.length - 1 ? ", " : ""));
        }
    }

    // --- Programa principal ---
    public static void main(String[] args) {
        int[] gañadora = xerarCombinacion();

        System.out.print("Combinación gañadora: ");
        mostrarCombinacion(gañadora);
        System.out.println("\n");

        int nBoletos = 10; // número de boletos a xerar
        int[] resultados = simularSorteo(nBoletos, gañadora);

        System.out.println("\n--- RESULTADOS ---");
        System.out.println("Boletos con 3 acertos: " + resultados[0]);
        System.out.println("Boletos con 4 acertos: " + resultados[1]);
        System.out.println("Boletos con 5 acertos: " + resultados[2]);
        System.out.println("Boletos con 6 acertos: " + resultados[3]);
    }
}
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://educacion.gitbook.io/programacion/exercicios-java/ud2-solucions/arrays/arrays.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.