---
# System prepended metadata

title: 'Seminario I: Lenguajes de programación'
tags: [Estudiantes, UAX]

---

###### tags: `UAX` `Estudiantes`
 <font color = 'gray'>
    <p style="text-align:right;">Prof.: Laura J. Marcos-Zambrano </font>
    
# Seminario I: Lenguajes de programación

### Actividad práctica: Contando nucleótidos en una secuencia de ADN
> Actividad para hacer en parejas o grupos de tres. 

**Objetivo:** Aprender a implementar la misma tarea en distintos lenguajes de programación y reflexionar sobre las diferencias entre ellos.

**Tarea:** Dada la secuencia de ADN `ATGCTTCAGAAAGGTCTTACG` , escribe un programa que:

- Cuente cuántas veces aparece cada nucleótido (A, T, C, G).
- Imprima el resultado en pantalla.
- Trabajarás con R (base), Python y Java usando un compilador online como [Programiz](https://www.programiz.com/r/online-compiler/). 

:::info
Puedes usar modelos de Inteligencia artificial para ayudarte. Pero recuerda que el que tiene que pensar eres tú, no el modelo :wink: 
:::

## Parte 1: Completa el código

**1. Python** :snake: 

```python=1

sequence = "ATGCTTCAGAAAGGTCTTACG"

# Completar: usar un bucle para contar A, T, C y G
counts = {}
for n in "ATCG":
    counts[n] = ________(n)   # Completar con la función adecuada

print(counts)

```

**2. R (solo base)** :abcd: 

```r=1
sequence <- "ATGCTTCAGAAAGGTCTTACG"
letters <- c("A","T","C","G")

# Completar: usar sapply o un bucle para contar
counts <- sapply(letters, function(n) {
  sum(________(sequence, "")[[1]] == n)   # Completar
})

print(counts)
```

**3. Java** :coffee: 

```java=1
public class Main {
    public static void main(String[] args) {
        String sequence = "ATGCTTCAGAAAGGTCTTACG";
        int A = 0, T = 0, C = 0, G = 0;

        // Completar el bucle
        for (char c : sequence.toCharArray()) {
            if (c == 'A') ______;
            else if (c == 'T') ______;
            else if (c == 'C') ______;
            else if (c == 'G') ______;
        }

        System.out.println("A:" + A + " T:" + T + " C:" + C + " G:" + G);
    }
}
```

## Parte 2: Preguntas de reflexión

**Antes de ejecutar el código:**
1. ¿Qué diferencias notas en la estructura general de cada lenguaje?
2. ¿Cuál de los tres te parece más fácil de leer? ¿Por qué?

**Después de ejecutar el código:**
3. ¿Qué lenguaje necesitó más líneas de código para hacer lo mismo?
4. ¿Cuál crees que es más adecuado para análisis rápidos en bioinformática? ¿Y cuál para programas muy grandes y rápidos?
5. Si cambias la secuencia por "AAAAAA", ¿qué resultado esperas obtener? ¿Qué ocurre al probarlo?

## Parte 3: Mini-experimentos (obligatorios)

* Modifica el código en dos lenguajes distintos para que también muestre la longitud total de la secuencia.
* Agrega la letra "N" a la secuencia, por ejemplo "ATGCNATGC". Modifica el código para que también cuente "N".
* En R y Python, intenta ordenar los resultados de mayor a menor frecuencia.

## 📝 Entrega - Semana próxima 

Sube un documento al campus con:
* Los tres programas corregidos.
* Captura de pantalla de al menos dos ejecuciones exitosas (puede ser en lenguajes distintos).
* Respuestas a las preguntas de reflexión.
* Código modificado de la "Parte 3".
* Una breve conclusión personal:
    * ¿Qué lenguaje fue más sencillo para ti?
    * ¿Cuál usarías si tuvieras que analizar genomas completos y por qué?

