> 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/ud2-programacion-estructurada/estructuras-repetivas/contadores-acumuladores-e-conmutadores-flags.md).

# Contadores, acumuladores e conmutadores/flags

Contadores, acumuladores e conmutadores/flags responden a nomes de variables auxiliares empregadas dentro dun bucle, que se denominan de esta forma por que cada unha se emprega dunha forma específica.

## Contadores

Un **CONTADOR** é unha variable (case sempre de tipo enteiro) na que o seu valor increméntase ou decreméntase en cada repetición do bucle. É habitual chamarlle ***cont*** de contador, ou ***i*** de índice. Emprégase habitualmente deste modo:

* **Primeiro** dáselle un valor inicial (inicialízase) antes de que comence o bucle. No bucle PARA dentro do mesmo, no MENTRAS xusto antes. Por exemplo:

```java
	int cont = 5;
	int veces = 0;
	int i = 3;
```

* **Segundo**, modifícase o valor da variable dentro do corpo do bucle. O máis frecuente é que se incremente o seu valor nunha unidade. Por exemplo:

```java
 	cont = cont + 1;   
	veces++;
	i+=1;
```

Isto quere dicir que o valor que tiña a variable cont aumenta nunha unidade, e é asignado de novo o valor á variable contador. Como cont valía 5 agora valerá 6, como veces valía 0 agora valerá 1, e como i valía 3 agora valerá 4.

Outra forma típica do contador é:

```java
	cont = cont – 1;
	cont--;
	cont-=1;
```

Neste caso, a variable decreméntase nunha unidade, se cont valía 5 antes, despois de esta execución do bucle valerá 4.

{% hint style="info" %}
O incremento ou decremento nun bucle for non ten que ser dunha unidade. Mostrar pares menores que 100:

```java
for( int i = 2; i < 100; i = i + 2){
    System.out.println(i);
    }
```

{% endhint %}

* **Terceiro**, é frecuente empregar o contador na condición de saída do bucle. Normalmente compárase co valor máximo (ou mínimo ) que debe acadar o contador para deixar de repetir as instruccións do bucle.

Exemplo: Escribir a táboa de multiplicar ata o 10 dun número n introducido polo usuario

```java
import java.util.Scanner;

public class Taboa10 {

    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        System.out.println("Introduce un número para facer a súa táboa");
        int numero = entrada.nextInt();
        int produto;
        for (int  cont = 1; cont <= 10; cont++){
            produto = numero * cont; 
            System.out.println(numero +" x "+ cont +" = "+produto);
        }
    }
}
```

O uso de contadores é case obrigado nos bucles **while** e **for** que se deben executar un determinado número de veces. Lembra que hai que asignar ao contador un VALOR INICIAL para a primeira execución do bucle (cont = 1 no noso exemplo) e ir incrementando (ou decrementando) en cada repetición, para non entrar nun bucle infinito.

Por último, temos que prestar atención á condición de saída, que debe estar asociada ao valor do contador na última repetición do bucle (no noso caso, cando cont = 10).

## Acumuladores

As variables acumuladoras teñen como misión almacenar resultados sucesivos, isto é , acumular resultados. As variables acumuladoras tamén deben estar inicializadas. Dependendo da operación a realizar, escribiremos antes do bucle:

```java
int acum = 0;
int produto = 1;
```

bucle, a modificación do valor de acumulador será:

```java
acum = acum + n;
produto = produto * n;
```

sendo **n** outra variable. Estas instruccións poderían vir seguidas doutras:

```java
acum = acum + m;
acum = acum + p;
```

de xeito que estaríamos almacenando en aum os valores das variables **n**, **m**, e **p**, o cal resulta ás veces moi útil para resolver problemas repetitivos.

Exemplo: Escribir un algoritmo que pida 10 números por teclado e os sume, escribindo o resultado

```java
import java.util.Scanner;

public class Suma10numeros {

    public static void main(String[] args) {     
        
        Scanner entrada = new Scanner(System.in);
    
        int numeroEnteiro;
        int suma = 0;
        for(int i = 0; i < 10 ; i++){
            System.out.println("Introduce un número");
            numeroEnteiro = entrada.nextInt();
            suma = suma + numeroEnteiro;
       }
       System.out.println(" A suma dos 10 números vale "+ suma );

    }
}
```

Neste algoritmo, **i** é unha variable contador típica de bucle. Empregouse un bucle **for** porque sabemos o número de repeticións do bucle (10 veces). A variable **suma** é o acumulador, onde se van sumando os diferentes valores que toma **numeroEnteiro** en cada repetición.

Antes de entrar no **for** temos que asignarlle ao acumulador o valor 0 porque imos sumar, se fóra unha multiplicación o valor inicial deberá ser 1.

## Interruptor, conmutador ou bandeira

Un conmutador ou interruptor (ou flag en inglés) é unha variable que pode tomar 2 valores: **verdadeiro/falso** ou normalmente **1 / 0**.

A variable conmutador recibirá un dos dous valores posibles antes de entrar no bucle. Dentro do corpo do bucle, cambiarase ese valor baixo certas condicións. Empregando o valor do conmutador ao final do bucle poderemos saber se algo se executou ou non.

Exemplo: mostrar os números primos desde 2 ata 100:

```java
import java.util.Scanner;

public class Primos100primeiros {
    public static void main(String[] args) {  
        int flag;
        for(int numero = 2; numero <= 100; numero++) {
            flag = 0;
            for(int i = 2; i <= numero / 2  ; i++){
                if(numero % i == 0){
                     flag = 1;
                     break;  /* XA ATOPAMOS ALGÚN DIVISOR*/
                }
            }
            if(flag == 0){
                 System.out.println(numero+" é primo");
            } 
        }
    }
}
```

Para cada número **numero** percorremos todos os números desde 2 ata o **numero/2**. Si algún é divisor o número non é primo, polo que poñemos o conmutador a 1. Ao finalizar o bucle, comprobamos o valor do conmutador. Se continúa valendo 0, o número é primo, porque non se atopou ningún divisor. Se vale 1, é porque se atopou algún divisor, e non é primo.

Fíxate que o conmutador é posto a 0 xusto despois de cambiar o valor de **numero**: para que ao final vaia 1 ten que cumplirse con algún número a condición **numero % i == 0**.


---

# 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/ud2-programacion-estructurada/estructuras-repetivas/contadores-acumuladores-e-conmutadores-flags.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.