1446 - Memory002: Diferență între versiuni

De la Universitas MediaWiki
Fără descriere a modificării
Fără descriere a modificării
Linia 23: Linia 23:
: 7 2 4 9 8
: 7 2 4 9 8
; Ieșire
; Ieșire
: Datele sunt introduse correct.
: memory002.out
: memory002.out
: Datele sunt introduse correct.
: 15
: 15


Linia 33: Linia 33:
: 1 1 1 1 1  
: 1 1 1 1 1  
; Ieșire
; Ieșire
: memory002.out
: Datele nu corespund restricțiilor impuse.
: Datele nu corespund restricțiilor impuse.


Linia 42: Linia 41:
# 1446 - Memory002
# 1446 - Memory002


def read_input():
def calculate_sum_between_smallest_and_largest(n, numbers):
     n = int(input())
     if n < 2:
    nums = list(map(int, input().split()))
        return 0
    return n, nums


def find_sum(n, nums):
     smallest = min(numbers)
     min_num = min(nums)
     largest = max(numbers)
     max_num = max(nums)
    min_index = nums.index(min_num)
    max_index = nums.index(max_num)
    if min_index > max_index:
        min_index, max_index = max_index, min_index
    result = sum(nums[min_index:max_index+1])
    with open("output.txt", "w") as f:
        f.write(str(result))
    return result


def validate_output(expected_output, actual_output):
    start_index = numbers.index(smallest)
     return int(expected_output) == actual_output
     end_index = numbers.index(largest)


if __name__ == '__main__':
    if start_index > end_index:
    n, nums = read_input()
        start_index, end_index = end_index, start_index
    result = find_sum(n, nums)
 
     try:
    return sum(numbers[start_index:end_index+1])
         with open("expected_output.txt", "r") as f:
 
            expected_output = f.read()
 
         assert validate_output(expected_output, result)
def validate_input(n, numbers):
     if n < 2 or n > 500000:
         return False
 
    if any(num < 0 or num >= 2000000000 for num in numbers):
        return False
 
    return True
 
 
if __name__ == "__main__":
    with open("memory002.in", "r") as file:
        n = int(file.readline())
         numbers = list(map(int, file.readline().split()))
 
    if validate_input(n, numbers):
         print("Datele sunt introduse corect.")
         print("Datele sunt introduse corect.")
     except AssertionError:
        result = calculate_sum_between_smallest_and_largest(n, numbers)
        with open("memory002.out", "w") as file:
            file.write(str(result))
     else:
         print("Datele nu corespund restricțiilor impuse.")
         print("Datele nu corespund restricțiilor impuse.")
    print(result)
 


</syntaxhighlight>
</syntaxhighlight>
== Explicatie Rezolvare ==
== Explicatie Rezolvare ==
Codul de mai sus reprezinta o solutie Python care citeste un numar n si o lista de numere intregi de lungime n, determina suma numerelor din subsecventa care incepe cu cel mai mic numar din lista si se termina cu cel mai mare numar din lista, iar apoi afiseaza aceasta suma.
calculate_sum_between_smallest_and_largest(n, numbers): Această funcție primește numărul n de numere și lista numbers care conține numerele distincte. Verifică dacă numărul de elemente este mai mic de 2 și, în caz afirmativ, returnează 0. Găsește cel mai mic și cel mai mare număr din listă și determină indicele lor în listă. Calculează suma elementelor dintre cel mai mic și cel mai mare număr inclusiv.
 
Mai exact, functia `read_input()` citeste numarul n si lista de numere de la intrarea standard (input-ul) si returneaza cele doua valori sub forma de tuplu. Apoi, functia `find_sum()` determina cel mai mic si cel mai mare numar din lista, apoi determina indicele primului aparitiei ale fiecaruia dintre aceste numere in lista. In continuare, functia calculeaza suma numerelor din subsecventa care incepe cu cel mai mic numar si se termina cu cel mai mare numar, utilizand operatorul de sectiune a listei `[min_index:max_index+1]`. Aceasta subsecventa este determinata astfel incat sa fie in ordinea crescatoare, daca cel mai mic numar se afla dupa cel mai mare numar in lista.


Functia `validate_output()` primeste ca parametri un raspuns asteptat si un raspuns real si returneaza `True` daca acestea sunt egale, si `False` in caz contrar.
validate_input(n, numbers): Această funcție validează datele de intrare. Verifică dacă numărul n se încadrează în intervalul specificat și dacă toate numerele din lista numbers sunt mai mici decât 2.000.000.000.


La final, sunt apelate cele trei functii in ordine pentru a citi datele de intrare, a determina raspunsul si a afisa rezultatul.
În blocul if __name__ == "__main__": se citesc datele de intrare din fișierul "memory002.in". Se validează datele folosind funcția validate_input. Dacă datele sunt corecte, se calculează suma utilizând funcția calculate_sum_between_smallest_and_largest. Rezultatul este scris în fișierul "memory002.out". În caz contrar, se afișează un mesaj corespunzător.

Versiunea de la data 14 mai 2023 21:54

Sursa: 1446 - Memory002

Cerinţa

Se dă un şir format din n numere naturale distincte. Calculați suma elementelor din secvenţa ce uneşte cel mai mic şi cel mai mare element din şir.


Date de intrare

Fișierul de intrare memory002.in conține pe prima linie numărul n, iar pe a doua linie n numere naturale distincte separate prin spații.


Date de ieșire

Fișierul de ieșire memory002.out va conține: Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou pe prima linie numărul S, reprezentând suma numerelor din şir situate în secvenţa ce uneşte cel mai mic şi cel mai mare element din şir, reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse.".

Restricţii şi precizări

  • 2 ≤ n ≤ 500.000
  • numerele din şir vor fi mai mici decât 2.000.000.000

Exemplu 1

Intrare
memory002.in
5
7 2 4 9 8
Ieșire
Datele sunt introduse correct.
memory002.out
15

Exemplu 1

Intrare
memory002.in
5 0 -1 -2
1 1 1 1 1
Ieșire
Datele nu corespund restricțiilor impuse.


Rezolvare

Rezolvare ver. 1

# 1446 - Memory002

def calculate_sum_between_smallest_and_largest(n, numbers):
    if n < 2:
        return 0

    smallest = min(numbers)
    largest = max(numbers)

    start_index = numbers.index(smallest)
    end_index = numbers.index(largest)

    if start_index > end_index:
        start_index, end_index = end_index, start_index

    return sum(numbers[start_index:end_index+1])


def validate_input(n, numbers):
    if n < 2 or n > 500000:
        return False

    if any(num < 0 or num >= 2000000000 for num in numbers):
        return False

    return True


if __name__ == "__main__":
    with open("memory002.in", "r") as file:
        n = int(file.readline())
        numbers = list(map(int, file.readline().split()))

    if validate_input(n, numbers):
        print("Datele sunt introduse corect.")
        result = calculate_sum_between_smallest_and_largest(n, numbers)
        with open("memory002.out", "w") as file:
            file.write(str(result))
    else:
        print("Datele nu corespund restricțiilor impuse.")

Explicatie Rezolvare

calculate_sum_between_smallest_and_largest(n, numbers): Această funcție primește numărul n de numere și lista numbers care conține numerele distincte. Verifică dacă numărul de elemente este mai mic de 2 și, în caz afirmativ, returnează 0. Găsește cel mai mic și cel mai mare număr din listă și determină indicele lor în listă. Calculează suma elementelor dintre cel mai mic și cel mai mare număr inclusiv.

validate_input(n, numbers): Această funcție validează datele de intrare. Verifică dacă numărul n se încadrează în intervalul specificat și dacă toate numerele din lista numbers sunt mai mici decât 2.000.000.000.

În blocul if __name__ == "__main__": se citesc datele de intrare din fișierul "memory002.in". Se validează datele folosind funcția validate_input. Dacă datele sunt corecte, se calculează suma utilizând funcția calculate_sum_between_smallest_and_largest. Rezultatul este scris în fișierul "memory002.out". În caz contrar, se afișează un mesaj corespunzător.

Adus de la „http://wiki.universitas.ro/index.php?title=1446_-_Memory002&oldid=6529”