1446 - Memory002: Difference between revisions

From Bitnami MediaWiki
Flaviu (talk | contribs)
Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/1446/memory002 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ț...
 
 
(3 intermediate revisions by one other user not shown)
Line 10: Line 10:


== Date de ieșire ==  
== Date de ieșire ==  
Fișierul de ieșire memory002.out va conține 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.
 
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."'''  memory002.out va conține 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 ==
== Restricţii şi precizări ==
* 2 ≤ n ≤ 500.000
* 2 ≤ n ≤ 500.000
* numerele din şir vor fi mai mici decât 2.000.000.000
* numerele din şir vor fi mai mici decât 2.000.000.000
== Exemplu ==
== Exemplu 1 ==
; Intrare
; Intrare
: memory002.in
: 5
: 5
: 7 2 4 9 8
: 7 2 4 9 8
; Ieșire
; Ieșire
: Datele sunt introduse correct.
: memory002.out
: 15
: 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 ==  
Line 27: Line 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)
     start_index = numbers.index(smallest)
     max_index = nums.index(max_num)
     end_index = numbers.index(largest)
     if min_index > max_index:
 
         min_index, max_index = max_index, min_index
     if start_index > end_index:
     return sum(nums[min_index:max_index+1])
         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.")


def validate_output(expected_output, actual_output):
    return int(expected_output) == actual_output


if __name__ == '__main__':
    n, nums = read_input()
    result = find_sum(n, nums)
    print(result)
</syntaxhighlight>
</syntaxhighlight>
== Explicatie Rezolvare ==
== Explicatie Rezolvare ==
În această soluție, funcția read_input citește numărul n și lista de n numere de la intrare și le returnează ca o pereche. Funcția find_sum găsește cel mai mic și cel mai mare număr din listă, apoi determină intervalul dintre acestea și calculează suma elementelor din acest interval. Funcția validate_output compară rezultatul așteptat cu cel real și returnează True dacă sunt egale și False altfel. În funcția main, apelăm funcția read_input pentru a obține datele de intrare, apoi apelăm funcția find_sum pentru a găsi suma elementelor din secvența cerută și o afișăm la ieșire.
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.

Latest revision as of 22:37, 14 May 2023

Sursa: 1446 - Memory002


Cerinţa[edit | edit source]

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[edit | edit source]

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[edit | edit source]

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." memory002.out va conține 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[edit | edit source]

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

Exemplu 1[edit | edit source]

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

Exemplu 1[edit | edit source]

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


Rezolvare[edit | edit source]

Rezolvare ver. 1[edit | edit source]

<syntaxhighlight lang="python" line>

  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.")


</syntaxhighlight>

Explicatie Rezolvare[edit | edit source]

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.