# data[].attributes.attachment_link.title
Cronograma: Introducción a la Programación (2022)

# data[].attributes.headline
¿Qué vamos a aprender en Introducción a la Programación?

# data[].attributes.subject
¿Qué vamos a aprender en Introducción a la Programación?

# data[].attributes.attachment_link.title
11071 - Introducción a la Programación - Apunte VIEJO

# data[].attributes.headline
Instalación del entorno de trabajo (Windows y Linux)

# data[].attributes.subject
Instalación del entorno de trabajo (Windows y Linux)

# data[].attributes.attachment_link.title
[ADICIONAL] Instalación y configuración del entorno de trabajo (Windows)

# data[].attributes.attachment_link.title
Cursillo Tecnicatura- Introduccion a la programacion 2020

# data[].attributes.attachment_link.title
¿Qué son los paradigmas de programación?

# data[].attributes.attachment_link.title
TP I - Conceptos Teóricos Básicos(falta 6, 7 ,8)

# data[].attributes.attachment_link.description
Curso del año 2021 de la asignatura Introducción a la Programación de la UNLu - 2021/01-Empezando_a_Programar.ipynb at main · introprog-unlu/2021

# data[].attributes.attachment_link.title
[T2B] Piezas de un programa (Conceptos Básicos #2)

# data[].attributes.attachment_link.title
[T2C] Depuración de programas (Parte II)

# data[].attributes.attachment_link.title
[ADICIONAL] Control de Versiones con GIT

# data[].attributes.attachment_link.title
[ADICIONAL] Resolución de HomeWorks directamente en VSCode

# data[].attributes.attachment_link.description
Curso del año 2021 de la asignatura Introducción a la Programación de la UNLu - 2022/02-Datos_y_Operaciones.ipynb at main · introprog-unlu/2022

# data[].attributes.headline
Buenas prácticas y su utilización dentro de un programa

# data[].attributes.subject
Buenas prácticas y su utilización dentro de un programa

# data[].attributes.attachment_link.title
[ADICIONAL] Resolución de HomeWorks (parte 1)

# data[].attributes.attachment_link.title
[ADICIONAL] Resolución de HomeWorks (parte 2)

# data[].attributes.attachment_link.description
FUNCIONES Parte I UNIDAD 3 Introducción a la Programación (11071) Departamento de Ciencias Básicas Universidad Nacional de Luján

# data[].attributes.attachment_link.description
FUNCIONES PROPIAS Introducción a la Programación (11071) Departamento de Ciencias Básicas Universidad Nacional de Luján

# data[].attributes.attachment_link.description
You can't perform that action at this time. You signed in with another tab or window. You signed out in another tab or window. Reload to refresh your session. Reload to refresh your session.

# data[].attributes.attachment_link.title
Universidad Nacional de Luján __ Aulas Virtuales [Evaluacion 2 prog]

# data[].attributes.attachment_link.description
Curso del año 2021 de la asignatura Introducción a la Programación de la UNLu - 2022/04-Condicionales.ipynb at main · introprog-unlu/2022

# data[].attributes.attachment_link.title
[T6A] Introducción a ciclos interactivos y con centinela

# data[].attributes.attachment_link.description
Curso del año 2021 de la asignatura Introducción a la Programación de la UNLu - 2022/05-Ciclos.ipynb at main · introprog-unlu/2022

# data[].attributes.attachment_link.title
TP VII - Estructuras repetitivas incondicionales.pdf

# data[].attributes.attachment_link.title
TP VIII - Estructuras repetitivas condicionales.pdf

# data[].attributes.attachment_link.description
You can't perform that action at this time. You signed in with another tab or window. You signed out in another tab or window. Reload to refresh your session. Reload to refresh your session.

# data[].attributes.attachment_link.readable_text
# Cree un script que almacene un número entero en una variable, y luego
# muestre en pantalla su valor absoluto, con el mensaje “El valor absoluto de N
# es |N|”. Finalmente, verifique que su programa funciona correctamente,
# ejecutándolo con el valor 10 en la variable (la salida debería ser 10), y luego
# con el valor -10 (la salida debería ser 10 nuevamente).




from itertools import count
from urllib.parse import ParseResultBytes

def valor_absoluto(n):
    n = int(input("ingrese un numero entero: "))
    n = abs(n)  
    print ("El valor absoluto de N es", n) 
pass

# Cree un script que almacene su nombre de pila en una variable, y luego
# muestre en pantalla la cantidad de letras de ese nombre, con el mensaje “El
# nombre [NOMBRE] tiene [N] letras.”.

def nombre_pila(nombre):
    nombre = input("Ingrese su nombre de pila: ")
    n = count(nombre)
    print ("El nombre ", nombre,"tiene ", n, "letras" )
pass

# Cree un script que almacene, en dos variables, una base y un exponente, y
# luego muestre en pantalla el resultado de elevar el número base a la
# potencia exponente

def potenciacion():
    base = int(input("ingrese su base: "))
    exponente = int(input("ingrese su exponente: "))
    n = base**exponente
    print (n)
pass

# Implemente un algoritmo en Python para calcular el perímetro de un
# rectángulo, conociendo su base y altura. Los datos se deben almacenar en
# variables, y el resultado se debe mostrar en pantalla.
# perímetro = 2 * (base + altura)

def perimetro_rectangulo():
    base = int(input("ingrese su base: "))
    altura = int(input("ingrese su altura: "))
    resultado = 2 * (base + altura)
    print (resultado)
pass

# Implemente un algoritmo en Python para calcular el área de un rectángulo,
# conociendo su base y altura. Los datos se deben almacenar en variables, y 
# el resultado se debe mostrar en pantalla. área = base * altura

def area_rectangulo():
    base = int(input("ingrese su base: "))
    altura = int(input("Ingrese su altura: "))
    area = base * altura 
    print (area)
pass

# Implemente un algoritmo que intercambie los valores entre dos variables a y b
# cualesquiera. Por ejemplo, si a = 10 y b = 5, luego de ejecutar el algoritmo, la
# variable a debería ser igual 5, y la variable b debería ser igual a 10

def intercambio_variables():
    A = input("ingrese variable A: ")
    B = input("ingrese variable B: ")
    b= A
    a= B 
    print ("La variable A, ahora es: ", b, "La variable B, ahora es: ", a)
pass

# Escriba un algoritmo que, conociendo las notas de los dos parciales de un
# alumno de la asignatura Introducción a la Programación, muestre en
# pantalla su promedio.

def promedio_programacion():
    nota1 = int(input("primera nota:"))
    nota2 = int(input("Segunda nota: "))
    promedio = (nota1 + nota2)/2
    print (promedio)
pass

# Cree un script que, sabiendo cuántos pesos argentinos tiene una persona
# ahorrada en su cuenta (almacenando ese monto en una variable), muestre
# en pantalla los montos convertidos en dólares (U$1 = $102.5), reales ($R1 =
# $14.1), y euros (€1 = $104.5). La salida del programa debe tener el siguiente
# formato:

def conversion_dinero():
    pesos = int(input("Ingrese cuantos pesos ARS: "))
    dolares = pesos / (102.5) 
    reales = pesos / (14.1)
    euros = pesos / (104.5) 
    print ("Tienes", dolares,"dolares, tienes", reales, "reales, tienes", euros, "euros.")
pass








# data[].attributes.attachment_link.description
Curso del año 2021 de la asignatura Introducción a la Programación de la UNLu - 2022/03-Variables_y_Funciones.ipynb at main · introprog-unlu/2022

# data[].attributes.attachment_link.readable_text
################################################################################################
# Nombre de archivo: hw3.py (No cambiar el nombre de este archivo)
# El repositorio donde esta tu HW3 es: github.com/unlu-edu-ar/homework-3-TuNombreDeUsuarioGithub
#
# Completa con tu nombre, apellido y DNI
# Nombre y Apellido: Lucia Vanini
# DNI: 44242654
################################################################################################


#################################################
# Funciones que tenés que programar
#################################################

# Cree una función que recibe dos números enteros positivos n1 y n2 como 
# parámetros, donde n1 < n2, y retorna el resultado de sumar los números enteros 
# contenidos en el intervalo [n1...n2]
def sumatoria(n1, n2):
    total = 0 
    if n1 < n2 and n1 > 0 and n2 > 0:
        for x in range (n1, n2 + 1): 
            total += x
    return total

# Cree una función que recibe un número entero n mayor o igual a cero como 
# parámetro, y retorna el factorial de dicho número. Recuerde que el factorial 
# de 0 es 0!=1, el factorial de 1 es 1!=1, y el factorial de n = n! = 
# 1 * 2 * 3 * … * (n - 1) * n
def factorial(n):
    factorial = 1
    if n != 0:
        for i in range(1, n+1):
            factorial = factorial*i
    elif n == 0:
        factorial = 1
    return  factorial 

# Cree una función que recibe como parámetros dos números enteros positivos n1 y 
# n2, donde n1 < n2, y un booleano. Si el booleano fuese True, la función retorna 
# el resultado de sumar los números enteros pares contenidos en el intervalo 
# [n1...n2]. Si el booleano fuese False, la función retorna el resultado de sumar 
# los números enteros impares contenidos en el intervalo [n1...n2].
def sumaParesOImpares(n1, n2, pares):
    result = 0
    for i in range (n1, n2+1):
        if i %2 == 0 and pares == True:
            result += i
        elif i %2 != 0 and pares == False:
            result += i
    return result


# Cree una función que recibe como parámetro un número entero n, donde 0 <= n < 100, 
# y retorna la sumatoria de los números enteros contenidos en el intervalo [1...100], 
# espaciados por n números.
def sumaEspaciadaDel1al100(n):
    suma = 0
    if 0 <= n < 100:
        for x in range(1, 101, n+1):
            suma += x
    return suma 

# Cree una función que recibe como parámetros un string y un número entero 
# positivo n, y retorna el string pasado como parámetro concatenado n veces.
def teLoRepitoNVeces(mensaje, n):
    x = ''
    for i in range (n):
        x += mensaje
    return x 

#################################################
# Funciones de Test (no modificar)
#################################################

def testSumatoria():
    print('Testeando testSumatoria()... ', end='')
    assert sumatoria(1, 3) == 6 
    assert sumatoria(5, 6) == 11
    assert sumatoria(3, 7) == 25
    print('Pasó!')

def testFactorial():
    print('Testeando testFactorial()... ', end='')
    assert factorial(0) == 1
    assert factorial(1) == 1
    assert factorial(2) == 2
    assert factorial(3) == 6
    assert factorial(5) == 120
    print('Pasó!')

def testSumaParesOImpares():
    print('Testeando testSumaParesOImpares()... ', end='')
    assert sumaParesOImpares(1, 5, True) == 6
    assert sumaParesOImpares(1, 5, False) == 9
    assert sumaParesOImpares(10, 20, True) == 90
    assert sumaParesOImpares(11, 12, False) == 11    
    print('Pasó!')

def testSumaEspaciadaDel1al100():
    print('Testeando testSumaEspaciadaDel1al100()... ', end='')
    assert sumaEspaciadaDel1al100(0) == 5050
    assert sumaEspaciadaDel1al100(99) == 1
    assert sumaEspaciadaDel1al100(9) == 460 
    print('Pasó!')

def testTeLoRepitoNVeces():
    print(' Testeando testTeLoRepitoNVeces()... ', end='')
    assert teLoRepitoNVeces('Hello world', 1) == 'Hello world'
    assert teLoRepitoNVeces('CambioDolar', 3) == 'CambioDolarCambioDolarCambioDolar'
    assert teLoRepitoNVeces('Hola mundo! ', 4) == 'Hola mundo! Hola mundo! Hola mundo! Hola mundo! '
    print('Pasó!')

#################################################
# testearTodo y main
#################################################

def testearTodo():
    # comentá los tests que no querés correr!
    testSumatoria()
    testFactorial()
    testSumaParesOImpares()
    testSumaEspaciadaDel1al100()
    testTeLoRepitoNVeces()

def main():
    testearTodo()

if __name__ == '__main__':
    main()

# data[].attributes.attachment_link.title
Introducción a la Programación - Aprendiendo a programar usando Python.pdf Ciclos

# data[].attributes.attachment_link.readable_text
################################################################################################
# Nombre de archivo: hw1.py (No cambiar el nombre de este archivo)
# El repositorio donde esta tu HW1 es: github.com/unlu-edu-ar/homework-1-TuNombreDeUsuarioGithub
#
# Completa con tu nombre, apellido y DNI
# Nombre y Apellido: Lucia Vanini
# DNI: 44242654
################################################################################################

#################################################
# Funciones que tenés que programar
#################################################

# Cree una función que recibe un número entero N, y retorna un string de
# su valor absoluto, con el mensaje “El valor absoluto de N es |N|”.

def valorAbsoluto(x):
    valor = f"El valor absoluto de {x} es {abs(x)}"
    return valor
pass

# Cree una función que reciba su nombre de pila, y luego retorne un string
# con la cantidad de letras de ese nombre, con el mensaje “El nombre [NOMBRE]
# tiene [N] letras.”.

def contarLetrasNombre(x):
    numero_de_letras= len(x)
    resultado= "El nombre "+ x + " tiene " + str(numero_de_letras)+ " letras."
    return resultado
    pass

# Cree una función que recibe dos números, una base y un exponente, y
# retorna el resultado de elevar el número base a la potencia exponente

def potenciacion(base, exponente):
        potencia = pow(base, exponente) 
        return potencia 
        


# Implemente una función para calcular el perímetro de un
# rectángulo, conociendo su base y altura:
# perímetro = 2 * (base + altura)
def perimetro(base, altura):
    perimetro = (base + altura) * 2 
    return perimetro


# Escriba una función que reciba las notas de los dos parciales de un
# alumno de la asignatura Introducción a la Programación, y retorne su promedio.
def promedioNotas(parcial1, parcial2):
    promedio = (parcial1 + parcial2)/2
    return promedio



# Escriba una función que reciba un monto numérico en pesos argentinos y
# retorne un string con la conversión en dólares, conteniendo la leyenda:
# "Si me das N pesos, te doy M dolares"
# Asuma un tipo de cambio U$1 = $90
def cambioDolar(pesos):
    cambio = (pesos) // 90
    dolar = (f"Si me das {pesos} pesos, te doy {cambio} dolares")
    return dolar 



#################################################
# Funciones de Test (no modificar)
#################################################


def testValorAbsoluto():
    print("Testeando testValorAbsoluto()... ", end="")
    assert valorAbsoluto(10) == "El valor absoluto de 10 es 10"
    assert valorAbsoluto(-10) == "El valor absoluto de -10 es 10"
    assert valorAbsoluto(0) == "El valor absoluto de 0 es 0"
    print("Pasó!")


def testContarLetrasNombre():
    print("Testeando testContarLetrasNombre()... ", end="")
    assert contarLetrasNombre("Maria") == "El nombre Maria tiene 5 letras."
    assert contarLetrasNombre("Nicolás") == "El nombre Nicolás tiene 7 letras."
    print("Pasó!")


def testPotenciacion():
    print("Testeando testPotenciacion()... ", end="")
    assert potenciacion(2, 1) == 2
    assert potenciacion(2, 3) == 8
    assert potenciacion(2, 0) == 1
    print("Pasó!")


def testPerimetro():
    print("Testeando testPerimetro()... ", end="")
    assert perimetro(2, 1) == 6
    print("Pasó!")


def testPromedioNotas():
    print("Testeando testPromedioNotas()... ", end="")
    assert promedioNotas(2, 4) == 3
    assert promedioNotas(0, 10) == 5
    assert promedioNotas(10, 10) == 10
    print("Pasó!")


def testCambioDolar():
    print("Testeando testCambioDolar()... ", end="")
    assert cambioDolar(90) == "Si me das 90 pesos, te doy 1 dolares"
    assert cambioDolar(0) == "Si me das 0 pesos, te doy 0 dolares"
    assert cambioDolar(180) == "Si me das 180 pesos, te doy 2 dolares"
    print("Pasó!")


#################################################
# testearTodo y main
#################################################


def testearTodo():
    # comentá los tests que no querés correr!
    testValorAbsoluto()
    testContarLetrasNombre()
    testPotenciacion()
    testPerimetro()
    testPromedioNotas()
    testCambioDolar()


def main():
    testearTodo()


if __name__ == "__main__":
    main()

# data[].attributes.attachment_link.readable_text
0:00 / 24:19•Watch full video

# data[].attributes.attachment_link.readable_text
0:00 / 10:57•Watch full video

# data[].attributes.attachment_link.title
TP IX - Validación de entrada (anterior)

# data[].attributes.attachment_link.title
[T8] Strings: definición y operaciones básicas

# data[].attributes.attachment_link.readable_text
Permalink

Cannot retrieve contributors at this time

Sorry, something went wrong. Reload?

Sorry, we cannot display this file.

Sorry, this file is invalid so it cannot be displayed.

# data[].attributes.attachment_link.description
Curso del año 2021 de la asignatura Introducción a la Programación de la UNLu - 2022/06-Strings.ipynb at main · introprog-unlu/2022

# data[].attributes.attachment_link.readable_text
Sign in to GitHub
to continue to GitHub Classroom

Username or email address

Password Forgot password?

New to GitHub? Create an account.

# data[].attributes.attachment_link.description
You can't perform that action at this time. You signed in with another tab or window. You signed out in another tab or window. Reload to refresh your session. Reload to refresh your session.

# data[].attributes.attachment_link.readable_text
################################################################################################
# Nombre de archivo: hw4.py (No cambiar el nombre de este archivo)
# El repositorio donde esta tu HW4 es: github.com/unlu-edu-ar/homework-4-TuNombreDeUsuarioGithub
#
# Completa con tu nombre, apellido y DNI
# Nombre y Apellido: Lucia vanini
# DNI: 44242654
################################################################################################


#################################################
# Funciones que tenés que programar
#################################################

# Cree una función que recibe un string s de longitud > 0, y dos números enteros 
# naturales n y m, donde 0<=n<=m<len(s), y retorna un nuevo string t que 
# es el string s sin la subcadena s[n1..n2].
# Ejemplo: s="Hola", n=1, m=2, retorna "Ha"
# Ejemplo: s="Hola", n=1, m=1, retorna "Hla" 
# Ejemplo: s="Hola", n=3, m=3, retorna "Hol"
# Ejemplo: s="Hola", n=0, m=3, retorna ""
# string, que es el resultado 
def borrarSubcadena(s,n,m):
    return s[:n] + s[m+1:]
    pass


# Cree una función que recibe un string s, y retorna dos enteros n y m, siendo
# n la cantidad de vocales minúsculas, y m la cantidad de vocales mayúsculas,
# que tiene el string s.
def contadorVocales(s):
    n = 0 
    m = 0 
    for letra in s: 
        if letra == "a" or letra == "e" or letra == "i" or letra == "o" or letra== "u": 
            n += 1
        elif letra == "A" or letra == "E" or letra == "I" or letra == "O" or letra == "U":
            m += 1
    return n, m 

    

#################################################
# Funciones de Test (no modificar)
#################################################

def testBorrarSubcadena():
    print('Testeando borrarSubcadena()... ', end='')
    assert borrarSubcadena("Hola", 1, 2) == "Ha"
    assert borrarSubcadena("Hola", 1, 1) == "Hla"
    assert borrarSubcadena("Hola", 3, 3) == "Hol"
    assert borrarSubcadena("Hola", 0, 3) == ""
    print('Pasó!')

def testContadorVocales():
    print('Testeando contadorVocales()... ', end='')
    assert contadorVocales("Argentina") == (3,1)
    assert contadorVocales("hola") == (2,0)
    assert contadorVocales("mmm") == (0,0)
    assert contadorVocales("B") == (0,0)
    assert contadorVocales("e") == (1,0)
    assert contadorVocales("U") == (0,1)
    print('Pasó!')

#################################################
# testearTodo y main
#################################################

def testearTodo():
    # comentá los tests que no querés correr!
    testBorrarSubcadena()
    testContadorVocales()

def main():
    testearTodo()

if __name__ == '__main__':
    main()

# data[].attributes.headline
Listas: definición y operaciones básicas

# data[].attributes.subject
Listas: definición y operaciones básicas

# data[].attributes.attachment_link.title
[T9] Listas: definición y operaciones básicas

# data[].attributes.attachment_link.readable_text
Permalink

Cannot retrieve contributors at this time

Sorry, something went wrong. Reload?

Sorry, we cannot display this file.

Sorry, this file is invalid so it cannot be displayed.

# data[].attributes.attachment_link.description
Curso del año 2021 de la asignatura Introducción a la Programación de la UNLu - 2022/07-Listas.ipynb at main · introprog-unlu/2022

# data[].attributes.attachment_link.readable_text
Sign in to GitHub
to continue to GitHub Classroom

Username or email address

Password Forgot password?

New to GitHub? Create an account.

# data[].attributes.attachment_link.description
You can't perform that action at this time. You signed in with another tab or window. You signed out in another tab or window. Reload to refresh your session. Reload to refresh your session.

# data[].attributes.attachment_link.readable_text
################################################################################################
# Nombre de archivo: hw2.py (No cambiar el nombre de este archivo)
# El repositorio donde esta tu HW2 es: github.com/unlu-edu-ar/homework-2-TuNombreDeUsuarioGithub
#
# Completa con tu nombre, apellido y DNI
# Nombre y Apellido: Lucia Vanini
# DNI: 44242654
################################################################################################


#################################################
# Funciones que tenés que programar
#################################################

# Cree una función que recibe un número entero N como parámetro, y retorna un 
# booleano. Si el número N es mayor que cero, retorna True. Si el número N es 
# menor o igual a cero, retorna False

def numeroPositivo(N):
    if N>0: 
     return True
    else: N<=0
    return False


# Cree una función que recibe un string como parámetro, y retorna un string con 
# la leyenda "Sos Maria", si el string recibido de argumento fuese "Maria", 
# "Sos Pedro" si el string recibido fuese "Pedro", "No sos Maria ni Pedro. Quien sos?" 
# si el string recibido como argumento no fuese "Maria" ni "Pedro"

def quienSos(x):
    if x=="Maria":
     return "Sos Maria"
    elif x=="Pedro": 
     return "Sos Pedro"
    else:
     return "No sos Maria ni Pedro. Quien sos?"

    
    
# Cree una función que recibe dos números de parámetro, y retorna el menor de 
# ellos, si los números fuesen distintos. Si los números fuesen iguales, debe 
# retornar el string "Son iguales!"
def dameElMenorODecimeSiSonIguales(x, y):
    if (y<x):
        return y
    elif x<y:
        return x
    if x==y:
        return "Son iguales!"

# Cree una función que recibe un número entero entre 1 y 12 de parámetro, 
# correspondiente a un mes y retorna un  string, con el nombre del mes en 
# lenguaje natural. La relación entre números y meses es la siguiente: 1 Enero, 
# 2 Febrero, 3 Marzo, 4 Abril, 5 Mayo, 6 Junio, 7 Julio, 8 Agosto, 9 Septiembre, 
# 10 Octubre, 11 Noviembre, 12 Diciembre
def decimeElMes(x):
    if 0<x<=12:
     if x==1:
      return "Enero"
     elif x==2:
      return "Febrero"
     elif x==3:
      return "Marzo"
     elif x==4: 
      return "Abril"
     elif x==5: 
      return "Mayo"
     elif x==6:
      return "Junio"
     elif x==7:
      return "Julio"
     elif x==8:
      return "Agosto"
     elif x==9: 
       return "Septiembre"
     elif x==10:
      return "Octubre"
     elif x==11: 
      return "Noviembre"
     else: 
      return "Diciembre"
    


# Cree una función que recibe un número entero, entre 1 y 12, correspondiente a
# un mes y retorna un  string, con el nombre de la estación. Considera la 
# relación entre números y estaciones de la siguiente forma: 1, 2, 3: "Verano", 
# 4, 5, 6: "Otoño", 7, 8, 9: "Invierno", 10, 11, 12: "Primavera"
def estacion(x):
    if 0<x<=12:
        if x==1 or x==2 or x==3:
            return "Verano"
        elif x==4 or x==5 or x==6:
            return "Otoño"
        elif x==7 or x==8 or x==9:
            return "Invierno"
        else:
            return "Primavera"
   

# Cree una función que recibe un número entero, entre 1 y 12, correspondiente a
# un mes, y retorna un booleano, que es True si el número del mes fuese par, 
# y False si el número del mes fuese impar
def mesPar(x):
    if 0<x<=12:
        if x%2==0:
            return True
        else:
            return False

# Cree una función que recibe dos números entre 0 y 10, correspondientes a las
# notas de los exámenes, y retorna un string con la leyenda "Promovido", si el 
# promedio de dichos númueros, fuese mayor o igual a 8, "Regular", si el promedio
# fuese mayor o igual a 4 pero menor a 8, y "Libre" si el promedio de las notas
# fuese menor a 4
def situacionAlumno(p1, p2):
    if 0<p1<=10 and 0<p2<=10:
      promedio = (p1+p2)/2 
      if promedio >=8:
          return "Promovido"
      elif promedio >=4:
          return "Regular"
      else:
          return "Libre"


# En un triángulo la longitud de cada lado es menor que la suma de los otros dos.
# Cree una función que recibe 3 enteros como parámetros, y retorna un booleano 
# que es True en el caso de que los valores recibidos puedan corresponder a las 
# longitudes de los lados de un triángulo y False en caso contrario. Recuerde 
# que ninguna de las longitudes de los lados de un triángulo puede ser cero, 
# o números negativos.
def esTriangulo(x, y, z):
    if (x <= 0 or y <=0 or z<=0):
        return False
    elif x>= (y+z) or y>=(z+x) or z>=(x+y):
        return False 
    else:
        return True 



# Cree una función que recibe 3 números enteros como parámetros, y retorna un 
# string con la leyenda:
# "No es un triangulo", si los longitudes no pueden corresponder a un triángulo
# "Equilatero", si puede ser un triángulo y todos las longitudes son iguales
# "Isosceles", si puede ser un triángulo y tiene dos longitudes iguales
# "Escaleno", si puede ser un triángulo y todas las longitudes son diferentes
def tipoTriangulo(x, y, z):
    resultado = x + y 
    if resultado <= z:
        texto = "No es un triangulo"
    elif x == y == z:
        texto = "Equilatero"
    elif (x == y != z) or (x != y == z) or (x == y != z):
        texto = "Isosceles"
    else:
        texto = "Escaleno"
    return texto 

#################################################
# Funciones de Test (no modificar)
#################################################

def testNumeroPositivo():
    print('Testeando testNumeroPositivo()... ', end='')
    assert numeroPositivo(10) == True
    assert numeroPositivo(-10) == False
    assert numeroPositivo(0) == False
    print('Pasó!')

def testQuienSos():
    print('Testeando testQuienSos()... ', end='')
    assert quienSos("Maria") == "Sos Maria"
    assert quienSos("Pedro") == "Sos Pedro"
    assert quienSos("Juan") == "No sos Maria ni Pedro. Quien sos?"
    print('Pasó!')

def testDameElMenorODecimeSiSonIguales():
    print('Testeando testDameElMenorODecimeSiSonIguales()... ', end='')
    assert dameElMenorODecimeSiSonIguales(4,1) == 1
    assert dameElMenorODecimeSiSonIguales(-1, 4) == -1
    assert dameElMenorODecimeSiSonIguales(4,4) == "Son iguales!"
    print('Pasó!')

def testDecimeElMes():
    print('Testeando testDecimeElMes()... ', end='')
    assert decimeElMes(1) == "Enero"
    assert decimeElMes(2) == "Febrero"
    assert decimeElMes(3) == "Marzo"
    assert decimeElMes(4) == "Abril"
    assert decimeElMes(5) == "Mayo"
    assert decimeElMes(6) == "Junio"
    assert decimeElMes(7) == "Julio"
    assert decimeElMes(8) == "Agosto"
    assert decimeElMes(9) == "Septiembre"
    assert decimeElMes(10) == "Octubre"
    assert decimeElMes(11) == "Noviembre"
    assert decimeElMes(12) == "Diciembre"
    print('Pasó!')

def testEstacion():
    print('Testeando testEstacion()... ', end='')
    assert estacion(1) == "Verano"
    assert estacion(2) == "Verano"
    assert estacion(3) == "Verano"        
    assert estacion(4) == "Otoño"
    assert estacion(5) == "Otoño"
    assert estacion(6) == "Otoño"
    assert estacion(7) == "Invierno"
    assert estacion(8) == "Invierno"
    assert estacion(9) == "Invierno"    
    assert estacion(10) == "Primavera"
    assert estacion(11) == "Primavera"
    assert estacion(12) == "Primavera"
    print('Pasó!')

def testMesPar():
    print('Testeando testMesPar()... ', end='')
    assert mesPar(1) == False
    assert mesPar(7) == False
    assert mesPar(12) == True
    print('Pasó!')

def testSituacionAlumno():
    print('Testeando testSituacionAlumno()... ', end='')
    assert situacionAlumno(1,3) == "Libre"
    assert situacionAlumno(9,10) == "Promovido"
    assert situacionAlumno(5,7) == "Regular"
    print('Pasó!')

def testEsTriangulo():
    print('Testeando testEsTriangulo()... ', end='')
    assert esTriangulo(6,6,3) == True
    assert esTriangulo(3,0,1) == False
    assert esTriangulo(1,2,3) == False
    assert esTriangulo(-1, 1, 2) == False
    print('Pasó!')

def testTipoTriangulo():
    print('Testeando testTipoTriangulo()... ', end='')
    assert tipoTriangulo(6,6,3) == "Isosceles"
    assert tipoTriangulo(2,2,2) == "Equilatero"
    assert tipoTriangulo(5,3,7) == "Escaleno"
    assert tipoTriangulo(1,2,3) == "No es un triangulo"
    print('Pasó!')

#################################################
# testearTodo y main
#################################################

def testearTodo():
    # comentá los tests que no querés correr!
    testNumeroPositivo()
    testQuienSos()
    testDameElMenorODecimeSiSonIguales()
    testDecimeElMes()
    testEstacion()
    testMesPar()
    testSituacionAlumno()
    testEsTriangulo()
    testTipoTriangulo()

def main():
    testearTodo()

if __name__ == '__main__':
    main()

# data[].attributes.attachment_link.readable_text
################################################################################################
# Nombre de archivo: hw5.py (No cambiar el nombre de este archivo)
# El repositorio donde esta tu HW5 es: github.com/unlu-edu-ar/homework-5-TuNombreDeUsuarioGithub
#
# Completa con tu nombre, apellido y DNI
# Nombre y Apellido: vanini lucia
# DNI: 44242654
################################################################################################


#################################################
# Funciones que tenés que programar
#################################################

# Cree una función que recibe una lista l de números enteros y retorna una lista
# de los números pares de la lista l, conservando el orden que tenían dichos
# números pares en la lista l. Si no hay ningún número par en la lista l, deberá
# retornar una lista vacía.
# Ejemplo, si l=[1,0,-4,-5,2,0] deberá retornar la lista [0,-4,2,0]
def extraePares(l):
    pares = []
    for x in l: 
        if x % 2 == 0:
            pares.append(x)
    return pares 



# Cree una función que recibe una lista no vacía l de números enteros y retorna 
# un entero m con la multiplicación de todos los números de la lista, y un número 
# entero s con la sumatoria de los elementos de la lista l.
# Ejemplo: l=[-1,2,3] debe retornar (-6,4)
# Ejemplo: l=[-1,0,3] debe retornar (0,2)
def productoriaYSumatoria(l):
    m = 1 
    s = 0 
    for x in l:
        m *= x
        s += x
    return m, s

# Cree una función que recibe como parámetros una lista l no vacía de números 
# enteros, dos números enteros naturales n1 y n2, donde 0<=n1<=n2<len(l), y 
# un booleano. Si el booleano fuese True, la función retorna 
# el resultado de sumar los números enteros pares contenidos en el intervalo 
# l[n1...n2] (si no hay ningún número par en el intervalo retorna 0). Si el 
# booleano fuese False, la función retorna el resultado de sumar los números 
# enteros impares contenidos en el intervalo l[n1...n2] (si no hay ningún número 
# impar en el intervalo retorna 0).
def sumaSubcadena(l, n1, n2, pares):
    result1 = 0 
    for i in range(n1, len(l)):
        if (pares == True):
            if l[i]%2 ==0 :
                result1 = result1 + l[i]
        if (pares == False):
            if l[i]%2 != 0:
                result1 = result1 + l[i]
    return result1

    


#################################################
# Funciones de Test (no modificar)
#################################################

def testExtraePares():
    print('Testeando extraePares()... ', end='')
    assert extraePares([1,0,-4,-5,2,0])==[0,-4,2,0]
    assert extraePares([])==[]
    assert extraePares([0])==[0]
    assert extraePares([3,1])==[]
    assert extraePares([2,4,2])==[2,4,2]
    print('Pasó!')

def testProductoriaYSumatoria():
    print('Testeando productoriaYSumatoria()... ', end='')
    assert productoriaYSumatoria([-1,2,3])==(-6,4)
    assert productoriaYSumatoria([-1,0,3])==(0,2)
    assert productoriaYSumatoria([0])==(0,0) 
    assert productoriaYSumatoria([2])==(2,2)   
    print('Pasó!')

def testSumaSubcadena():
    print('Testeando sumaSubcadena()... ', end='')
    assert sumaSubcadena([1,2,3],0,1,True)==2
    assert sumaSubcadena([1,2,3],2,2,False)==3  
    assert sumaSubcadena([1,2,2],2,2,False)==0  
    assert sumaSubcadena([0],0,0,True)==0   
    assert sumaSubcadena([1],0,0,False)==1 
    assert sumaSubcadena([1,2,3,4],1,3,True)==6
    print('Pasó!')

#################################################
# testearTodo y main
#################################################

def testearTodo():
    # comentá los tests que no querés correr!
    testExtraePares()
    testProductoriaYSumatoria()
    testSumaSubcadena()

def main():
    testearTodo()

if __name__ == '__main__':
    main()
