1994 - Vanatoare: Difference between revisions

From Bitnami MediaWiki
Paul Ungur (talk | contribs)
Pagină nouă: ==Enunț== Vânătorul şef al regelui Arthur a primit însărcinare să vâneze primele raţe ce se întorc din ţările calde. Regele fiind un tip cu idei fixe i-a cerut vânătorului să vâneze raţele albe cu săgeţi albe, iar raţele negre cu săgeţi negre. Raţele vin în stoluri din ce în ce mai mari: mai întâi una, apoi două, trei , cinci, opt ş.a.m.d. Raţele fiind nişte creaturi ordonate zboară în rânduri lungi, în care nu vei putea găsi două raţe de...
 
Paul Ungur (talk | contribs)
No edit summary
 
(2 intermediate revisions by the same user not shown)
Line 27: Line 27:
<syntaxhighlight lang="python" line>
<syntaxhighlight lang="python" line>
def validare(ka, kb):
def validare(ka, kb):
     if ka < 0 or kb < 0:
     if 0 <= ka <= 2_000_000_000 and 0 <= kb <= 2_000_000_000:
        return True
    else:
         return False
         return False
    return True


def citire():
    ka = int(input())
    kb = int(input())
    return ka, kb


def main():
def creare(v):
     ka, kb = citire()
     v[1] = 1
    if not validare(ka, kb):
    v[2] = 2
        print("Date de intrare invalide")
    for i in range(3, 101):
        return
        v[i] = v[i-1] + v[i-2]
      
 
     r = 0
 
     while ka >= r+1 and kb >= r:
def vanatoare(ka, kb):
         r += 1
    v = [0] * 101
         ka -= r
    creare(v)
         kb -= r-1
    cka = ka
   
     ckb = kb
     print(r)
     i = 1
     while cka >= 0 and ckb >= 0:
         ka = cka
        kb = ckb
         if v[i] % 2 == 0:
            cka -= v[i] // 2
            ckb -= v[i] // 2
         else:
            cka -= v[i] // 2 + 1
            ckb -= v[i] // 2
        i += 1
     print(i-2)
     print(ka)
     print(ka)
     print(kb)
     print(kb)


if __name__ == "__main__":
if __name__ == "__main__":
     main()
     ka, kb = map(int, input().split())
    if validare(ka, kb):
        print("Date de intrare valide")
        vanatoare(ka, kb)
    else:
        print("Date de intrare invalide")
</syntaxhighlight>
</syntaxhighlight>
==Explicatie cod:==
Acest cod Python are următoarele funcționalități:


==Explicatie==
Funcția validare(ka, kb) primește două numere întregi ka și kb și verifică dacă acestea sunt în intervalul [0, 2.000.000.000]. Dacă ambele numere respectă această condiție, funcția returnează True, altfel returnează False.
Programul primește ca input numerele ka și kb reprezentând numărul de săgeți albe și negre pe care le are vânătorul. Se verifică dacă valorile introduse sunt valabile, adică pozitive. Dacă da, se folosește o buclă while pentru a determina numărul de rânduri doborâte, r. La fiecare rând doborât, numărul de săgeți albe scade cu valoarea rândului, iar numărul de săgeți negre scade cu valoarea rândului minus unu. Când nu mai sunt suficiente săgeți pentru a doborî întregul rând, programul iese din buclă și afișează răspunsul: numărul de rânduri doborâte, urmat de numărul de săgeți albe rămase și de numărul de săgeți negre rămase.
Funcția creare(v) primește un vector v și atribuie primele 100 de elemente ale vectorului v conform unei secvențe predefinite.
Funcția vanatoare(ka, kb) primește două numere întregi ka și kb și efectuează următoarele operații:
Inițializează un vector v și apelează funcția creare(v) pentru a genera primele 100 de elemente ale vectorului v.
Inițializează variabilele cka și ckb cu valorile lui ka și kb.
Inițializează un contor i cu 1.
Într-un buclă while, se actualizează valorile lui ka și kb pe baza condiției și a valorii curente din vectorul v.
La final, se afișează rezultatele.
În blocul if __name__ == "__main__":, se citește de la intrarea standard două numere întregi ka și kb. Apoi, se verifică dacă datele de intrare sunt valide utilizând funcția validare(ka, kb). Dacă datele sunt valide, se afișează un mesaj de confirmare, se apelează funcția vanatoare(ka, kb) și se efectuează operațiile corespunzătoare. În caz contrar, se afișează un mesaj de eroare.
Codul primește valorile ka și kb de la intrarea standard, validează datele și efectuează operațiile specifice pentru a determina și afișa rezultatele.

Latest revision as of 17:30, 15 May 2023

Enunț[edit | edit source]

Vânătorul şef al regelui Arthur a primit însărcinare să vâneze primele raţe ce se întorc din ţările calde. Regele fiind un tip cu idei fixe i-a cerut vânătorului să vâneze raţele albe cu săgeţi albe, iar raţele negre cu săgeţi negre. Raţele vin în stoluri din ce în ce mai mari: mai întâi una, apoi două, trei , cinci, opt ş.a.m.d. Raţele fiind nişte creaturi ordonate zboară în rânduri lungi, în care nu vei putea găsi două raţe de aceeaşi culoare alăturate, fiecare rând începînd cu o raţă albă. Vânătorul ştie că dacă a început să doboare un rând de raţe trebuie să le doboare pe toate deoarece supravieţuitoarele vor alerta celelalte raţe şi ele nu se vor mai întoarce niciodată, iar vânătorul nostru îşi va pierde slujba.

Cerința[edit | edit source]

Ştiind că vânătorul a primit ka săgeţi albe şi kb săgeţi negre trebuie să determinaţi câte rânduri de raţe a doborât şi câte săgeţi de fiecare tip i-au rămas ştiind că el vrea să-şi păstreze slujba.

Date de intrare[edit | edit source]

Se citesc de la tastatură numerele ka şi kb (în această ordine).

Date de ieșire[edit | edit source]

Se va afişa pe prima linie a ecranului numărul de rânduri doborâte, pe a doua linie numărul de săgeți albe rămase, iar pe cea de-a treia numărul de săgeți negre.

Restricții și precizări[edit | edit source]

0 ≤ ka, kb ≤ 2.000.000.000

Exemplu:[edit | edit source]

Intrare 9 10

Ieșire 4 2 6

Rezolvare[edit | edit source]

<syntaxhighlight lang="python" line> def validare(ka, kb):

   if 0 <= ka <= 2_000_000_000 and 0 <= kb <= 2_000_000_000:
       return True
   else:
       return False


def creare(v):

   v[1] = 1
   v[2] = 2
   for i in range(3, 101):
       v[i] = v[i-1] + v[i-2]


def vanatoare(ka, kb):

   v = [0] * 101
   creare(v)
   cka = ka
   ckb = kb
   i = 1
   while cka >= 0 and ckb >= 0:
       ka = cka
       kb = ckb
       if v[i] % 2 == 0:
           cka -= v[i] // 2
           ckb -= v[i] // 2
       else:
           cka -= v[i] // 2 + 1
           ckb -= v[i] // 2
       i += 1
   print(i-2)
   print(ka)
   print(kb)


if __name__ == "__main__":

   ka, kb = map(int, input().split())
   if validare(ka, kb):
       print("Date de intrare valide")
       vanatoare(ka, kb)
   else:
       print("Date de intrare invalide")

</syntaxhighlight>

Explicatie cod:[edit | edit source]

Acest cod Python are următoarele funcționalități:

Funcția validare(ka, kb) primește două numere întregi ka și kb și verifică dacă acestea sunt în intervalul [0, 2.000.000.000]. Dacă ambele numere respectă această condiție, funcția returnează True, altfel returnează False. Funcția creare(v) primește un vector v și atribuie primele 100 de elemente ale vectorului v conform unei secvențe predefinite. Funcția vanatoare(ka, kb) primește două numere întregi ka și kb și efectuează următoarele operații: Inițializează un vector v și apelează funcția creare(v) pentru a genera primele 100 de elemente ale vectorului v. Inițializează variabilele cka și ckb cu valorile lui ka și kb. Inițializează un contor i cu 1. Într-un buclă while, se actualizează valorile lui ka și kb pe baza condiției și a valorii curente din vectorul v. La final, se afișează rezultatele. În blocul if __name__ == "__main__":, se citește de la intrarea standard două numere întregi ka și kb. Apoi, se verifică dacă datele de intrare sunt valide utilizând funcția validare(ka, kb). Dacă datele sunt valide, se afișează un mesaj de confirmare, se apelează funcția vanatoare(ka, kb) și se efectuează operațiile corespunzătoare. În caz contrar, se afișează un mesaj de eroare. Codul primește valorile ka și kb de la intrarea standard, validează datele și efectuează operațiile specifice pentru a determina și afișa rezultatele.