Pensamiento Computacional · Guía Primer Parcial

La estructura del parcial Balbiano

El parcial de Pensamiento Computacional tiene 9 o 10 preguntas de opción múltiple con una sola respuesta correcta. La duración es de 1:30 h.

Las preguntas 1-5 (o 1-7) valen 1 punto cada una. Las últimas 4 (o 3) valen 2 puntos o 0 (sin puntos intermedios). La nota se calcula según una escala fija: de 13 puntos máximos posibles a nota del 1 al 10.

Los tipos de preguntas del parcial 21/4/2025

Cada tema (1 a 8) repite la misma estructura de 9 ejercicios. Los tipos que aparecen:

Las 3 preguntas que te tenés que hacer antes de cada ejercicio

Pregunta 1: ¿Qué tipo de ejercicio es?

Mirá la primera oración. Las palabras clave te dicen todo:

• "¿Qué muestra el siguiente programa?" → Trazá la ejecución línea a línea (Ej 2 y 6).
• "¿Cuál de los siguientes programas muestra X?" → Probá cada opción A/B/C/D con los valores dados; descartá las que tiren error o resultado distinto (Ej 1, 4, 7).
• "¿Con qué contenido acabará la lista?" → Simulá el bucle paso a paso en papel (Ej 3).
• "¿Qué devuelve la función fun?" → Trazá el for/while interno y mirá qué tipo devuelve el return (Ej 5).
• "¿Cuál es la versión correcta de la función?" → Chequeá nombre, cantidad y orden de parámetros, y que el return devuelva lo correcto (Ej 8).
• "¿Cuál condición es candidata a ser equivalente?" → Probá con los valores que da el enunciado: la equivalente da el mismo V/F que la original en todos los casos (Ej 9).

Pregunta 2: ¿Cuáles son los valores iniciales?

Antes de trazar, anotá en un margen todos los valores iniciales de las variables. Nunca trates de tener los valores "en la cabeza": escribilos.

Pregunta 3: ¿Hay trampa de precedencia o de tipo?

• ¿Hay potencia (**)? Se evalúa antes que * y /.
• ¿Hay división entera (//) o módulo (%)? Mismo nivel que *.
• ¿Hay int(num) == num? Es la forma de detectar si un float es entero.
• ¿El índice de lista es negativo? lista[-1] es el último elemento.

Orden de precedencia de operadores Python

a=1; b=0; c=2.5; d=-2
print((a+d**2)/(c-b))

Tipos de datos fundamentales

Operadores aritméticos

El operador * con strings y listas

En Python el operador * aplicado a una string o lista con un entero repite:

'hola' * 2  →  'holahola'
'*' * 5     →  '*****'
[0] * 3     →  [0, 0, 0]
[1, 2] * 2  →  [1, 2, 1, 2]

a=0; b=1; c=2; d=-2
cant = d - b*b + c*2/b + 4
print('&' * int(cant))

a=0; b=1; c=2; d=-2
cant = d*d + b**(2+c)*a
print('0' * cant)

Contar cuántas condiciones se evalúan

No es un ejercicio fijo del parcial, pero la idea te sirve para trazar cualquier if sin equivocarte. La lógica es:

• Si la primera condición de un if es verdadera y usa or, Python no evalúa la segunda (cortocircuito).
• Si la primera condición de un if es falsa y usa and, Python no evalúa la segunda (cortocircuito).
• Una vez que entra a un if, los elif que siguen no se evalúan.
• Un else no es una condición evaluada (es el caso "restante"), así que no suma al conteo.

a=10; ok=True
if a==1 and ok:      # evalúa a==1 (False) → cortocircuito: ok NO se evalúa
  ...
elif a>1:            # se evalúa (True) → entra
  print('Segundo')
else:                # no se llega
  ...

Leer datos del usuario: input()

La función input() lee lo que el usuario escribe por teclado. Regla clave: input() SIEMPRE devuelve un str (una string), aunque el usuario escriba un número.

nombre = input('Tu nombre: ')   # si tipea Ana  → nombre = 'Ana'  (str)
edad   = input('Tu edad: ')     # si tipea 30   → edad   = '30'   (str, NO 30)

Por eso, para hacer cuentas hay que convertir la entrada con int() o float():

n = int(input('Un entero: '))     # tipea 7    → n = 7      (int)
p = float(input('Un decimal: '))  # tipea 2.5  → p = 2.5    (float)

n = int(input('Numero: '))   # usuario escribe 7
resultado = n * 3 + 1
print(resultado)

Estructura básica

if condicion1:
    # se ejecuta si condicion1 es True
elif condicion2:
    # se ejecuta si condicion1 fue False y condicion2 es True
else:
    # se ejecuta si ninguna condición anterior fue True

Operadores de comparación y lógicos

El operador in con range()

a in range(1, 8, 2) es equivalente a a in (1, 3, 5, 7). Esto aparece en preguntas de equivalencia de condiciones.

producto='birome'; unidad='caja'; precio=60
if producto in ('block A4','etiqueta'):
    ...
elif producto in ('plasticola','hoja','birome'):
    if unidad in ('ciento','docena','bolsa'):
        print('barato')
    else:
        print('caro')

(num in sel) and (num!=int(num) or num>0 or num%3==0)

((num>=1 or not(int(num)==num) or
  (num%3!=1 and num%3!=2)) and (num in sel))

Condicionales anidados: conteo de condiciones paso a paso

Para contar condiciones evaluadas con valores dados, seguí este método:

1. Copiá el programa en papel con los valores iniciales.
2. Evaluá la primera condición. Anotá si es True o False.
3. Si es True: marcá las líneas que se ejecutan, tachá los elif/else siguientes al mismo nivel.
4. Si es False: pasá al siguiente elif (que sí se evalúa). Sumás 1 al contador.
5. Los else sin condición no suman al contador.
6. Repetí para todos los bloques anidados.

El ciclo for

for variable in secuencia:
    # cuerpo del bucle

El cuerpo se ejecuta una vez por cada elemento de la secuencia. La secuencia puede ser una lista, una string, un range, una tupla.

range(): la función más importante del parcial

El ciclo while

while condicion:
    # cuerpo del bucle
    # (la condición se reevalúa antes de cada iteración)

El cuerpo se ejecuta mientras la condición sea True. Cuidado con el bucle infinito: siempre tiene que haber algo dentro del bucle que modifique la condición.

impares='13579'
for i in range(len(impares)):
    linea=''
    for j in range(len(impares)*2):
        if j%2!=0:
            linea+=impares[j//2]
        else:
            linea+=' '
    print(linea)

digitos='123456'
izq=''
for i in range(len(digitos)):
    print(izq+digitos)
    digitos=digitos[1:]
    izq+=' '

cartel='desde'
print(cartel.upper())
izq=' '
for i in range(1,len(cartel)-1):
    print(izq+cartel[i])
    izq+=' '
print(cartel.upper())

for i in range(1,15,5):
    i=0  # ¡esto NO afecta al rango!

Lista: colección mutable de elementos

numeros = [4, 3, 1, 2]
numeros[0]   →  4        # primer elemento (índice 0)
numeros[-1]  →  2        # último elemento
numeros[1:3] →  [3, 1]  # slicing: posiciones 1 y 2 (3 no entra)

Índices negativos

Un índice negativo cuenta desde el final de la lista:

a = [10, 20, 30, 40]
a[-1] →  40   # último
a[-2] →  30   # penúltimo
a[-(len(a))] →  a[0] → 10  # primer elemento

Métodos de lista más usados en parciales

indicador=[1,2,3,4,5,6]
numeros=[1,2,3,4,5,6]
final=[0]*6          # [0,0,0,0,0,0]
for i in range(len(numeros)):
    final[-(indicador[i])] = numeros[i]

indicador=[7,5,1,3,2,4,6]
numeros=[1,2,3,4,5,6,7]
final=[0]*7
for i in range(len(numeros)):
    final[indicador[i]-1]=numeros[i]

impares=[15,7,11,3]
pares=[22,14]
numeros=[]
numeros.extend(impares)
numeros.extend(pares)
numeros.sort()

numeros=[-3.36,10,2,0.25,-3]
enteros=[]
fraccionarios=[]
for num in numeros:
    if num==int(num):    # ¿es entero?
        enteros.append(num)
    else:
        fraccionarios.append(num)
enteros.sort()
enteros.reverse()
fraccionarios.sort()
fraccionarios.reverse()

Tuplas

Las tuplas son como listas pero inmutables (no se pueden modificar). Se crean con paréntesis:

t = (1, 2, 3)
t[0]  →  1     # acceso igual que lista
t[-1] →  3     # índice negativo igual que lista

En los parciales las tuplas aparecen principalmente como secuencias en for y como argumentos del operador in.

Acceso a caracteres y slicing

pal = 'GEMELO'
pal[0]    →  'G'     # primer carácter (índice 0)
pal[-1]   →  'O'     # último carácter
pal[2:]   →  'MELO'  # desde posición 2 hasta el final
pal[:3]   →  'GEM'   # desde el inicio hasta posición 2 (3 no entra)
pal[1:4]  →  'EME'   # posiciones 1, 2, 3
pal[::-1] →  'OLEMEG' # invertir la string

palabra='anaconda'
txt='la vocal: '
frase='Siempre '
frase=frase+txt+palabra[-1].upper()
frase=frase+' está varias veces en '
frase=frase+palabra.upper()
print(frase)

mens='LA PLACA DENTAL SE QUITA CON'
nom='Agustín'
tipo='bacteriana'
producto='plakout'
textoMens=nom+', '+mens[:8]+' '+tipo.upper()
textoMens=textoMens+mens[8:]
textoMens=textoMens+': '+producto.upper()
print(textoMens)

Métodos de string más usados en parciales

frase = 'hola mundo'
frase.replace('hola','chau')  # ← ¡NO modifica frase!
print(frase)  # sigue siendo 'hola mundo'

frase = frase.replace('hola','chau')  # ← esto SÍ funciona
print(frase)  # ahora es 'chau mundo'

frase='Las abejas vuelan y las ovejas balan'
animal1='abeja'; animal2='oveja'
frase=frase.replace(animal1,'ABEJA')
frase=frase.replace(animal2,'OVEJA')
for voc in 'eiou':
    frase=frase.replace(voc,'A')
print(frase.upper())

def edita(t, palabras):
    t=t.lower()
    lista=t.split()
    for i in range(len(lista)):
        if lista[i] in palabras:
            lista[i]=lista[i].upper()
    return ' '.join(lista)

txt='argumentar caos en cualquier situación no es compromiso'
resalta=['compromiso','caos']
print(edita(txt, resalta))

def fun(t):
    vocales='AEIOUÁÉÍÓÚÜ'
    repetidas=''
    for letra in t:
        if letra in vocales and t.count(letra)>0:
            if letra not in repetidas:
                repetidas+=letra
    return repetidas.lower()
txt='Estaba LA RANA cantando debajo del AGUA'
print(fun(txt))

Estructura básica de una función

def nombre_funcion(parametro1, parametro2):
    # cuerpo de la función
    resultado = parametro1 + parametro2
    return resultado

Para llamar a la función y usar su resultado:

valor = nombre_funcion(3, 5)   # valor = 8
print(nombre_funcion(10, 2))   # imprime 12

Tipo de pregunta: "¿cuál función es adecuada?"

El parcial te muestra un programa que llama a una función con ciertos argumentos y una salida esperada. Tenés que encontrar la definición correcta. Estrategia:

1. Mirá cómo se llama la función: producto(lista[i], factor[i]) → recibe 2 parámetros.
2. Mirá la salida esperada y deducí qué operación hace: si da 3, 0, 6 con (1,3), (0,6), (3,2) → es multiplicación.
3. Eliminá opciones con número de parámetros incorrecto.
4. Verificá que el return devuelva lo correcto.

def fun(t):
    vocales='AEIOUÁÉÍÓÚÜ'
    t=t.upper()
    cont=0
    for letra in t:
        if letra in vocales:
            cont+=1
    return cont>6

txt='Una oruga NEGRA en un PAJAR'
print(fun(txt))

txt='hasta la vista baby!!!'
print(edita(txt,',- .!?'))

def edita(t, carEsp):
    lista=list(t)
    for i in range(len(lista)):
        if lista[i] in carEsp:
            lista[i]='<esp>'
    t=''.join(lista)
    return t.upper()

Alcance de variables (scope)

Las variables definidas dentro de una función solo existen dentro de ella. Las variables definidas fuera (globales) pueden leerse dentro pero no modificarse sin global.

Ejemplo integrador: función + strings + listas

def solo_pares(numeros):
    resultado = []
    for n in numeros:
        if n % 2 == 0:
            resultado.append(n)
    return resultado

datos = [1, 4, 7, 8, 3, 6]
print(solo_pares(datos))  # [4, 8, 6]