3381 - K Sir 1: Difference between revisions

From Bitnami MediaWiki
Paul Ungur (talk | contribs)
Pagină nouă: Se dă următorul şir de numere: <span style=“color: red”>1 1 2 2 1 2 3 3 3 1 2 3 4 4 4 4 1 2 3 4 5 5 5 5 5...</span> În şir avem grupe formate după următoarea regulă: grupa <span style=“color: red”>g</span> conţine numerele naturale de la <span style=“color: red”>1</span> la <span style=“color: red”>g</span> în ordine crescătoare, urmate de <span style=“color: red”>g-1</span> valori egale cu <span style=“color: red”>g (g=1, 2, ...)</sp...
 
Paul Ungur (talk | contribs)
No edit summary
 
(3 intermediate revisions by the same user not shown)
Line 10: Line 10:


==Date de ieșire==
==Date de ieșire==
Fișierul de ieșire <span style=“color: red”>ksir.out</span> va conţine o singură linie pe care va fi scris un număr natural ce reprezintă al <span style=“color: red”>k</span>-lea element din şir.
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi fișierul de ieșire <span style=“color: red”>ksir.out</span> va conţine o singură linie pe care va fi scris un număr natural ce reprezintă al <span style=“color: red”>k</span>-lea element din şir. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide"'''.


==Restricții și precizări==
==Restricții și precizări==
Line 18: Line 18:
==Exemplu:==
==Exemplu:==
<span style=“color: red”>ksir.in</span>
<span style=“color: red”>ksir.in</span>
8
: 8


: Date de intrare valide
ksir.out
ksir.out
3
: 3


==Explicație==
==Explicație==
Line 28: Line 29:
==Rezolvare==
==Rezolvare==
<syntaxhighlight lang="python" line>
<syntaxhighlight lang="python" line>
def validate(k):
def validare(k):
     if not isinstance(k, int):
     if not isinstance(k, int):
         raise ValueError("k trebuie sa fie un numar intreg")
         raise ValueError("k trebuie sa fie un numar intreg")
Line 35: Line 36:
         raise ValueError("k trebuie sa fie intre 1 si 20.000.000.000")
         raise ValueError("k trebuie sa fie intre 1 si 20.000.000.000")


    return True


def read_input():
    with open("ksir.in", "r") as f:
        k = int(f.readline().strip())
        validate(k)
        return k


def k_sir(k):
    n, cnt = 1, 1
    while (1 * (n + 1) * (n + 1) // 4 < k):
        n += 2
        cnt += 1
    n -= 2
    k -= 1 * (n + 1) * (n + 1) // 4
    nr = 0
    while k:
        if nr != cnt:
            nr += 1
        k -= 1
    fout.write(str(nr))


def main():
    fin.close()
     k = read_input()
     fout.close()


    group = 1
    count = 1
    while k > count:
        group += 1
        count += group - 1


     offset = k - count + group - 1
if __name__ == "__main__":
     result = group + offset // group
     fin = open("ksir.in")
     fout = open("ksir.out", "w")


     with open("ksir.out", "w") as f:
     k = int(fin.readline().strip())
        f.write(str(result))
    if validare(k):
 
        print("Date de intrare valide")
 
        k_sir(k)
if __name__ == "__main__":
    else:
    main()
        print("Date de intrare invalide")
</syntaxhighlight>
</syntaxhighlight>
 
==Explicatie cod:==
==Explicatie==
Funcția validare(k) primește un număr întreg k și verifică dacă acesta este un întreg și se încadrează în intervalul [1, 20.000.000.000]. Dacă k nu respectă aceste condiții, funcția aruncă o excepție de tip ValueError cu un mesaj corespunzător. În caz contrar, returnează True.
Acest cod este o soluție pentru problema "Șir k" descrisă mai sus. Este împărțit în trei funcții:
Funcția k_sir(k) primește un număr întreg k și efectuează un set de operații. Folosind o buclă while, se calculează valorile n și cnt până când expresia 1 * (n + 1) * (n + 1) // 4 < k devine falsă. Apoi, se ajustează valorile n și k în funcție de formula specificată. Se parcurge o buclă while în care se scade valoarea k până când acesta devine zero, în timp ce nr este incrementat cu 1 în fiecare iterație. La final, se scrie rezultatul în fișierul de ieșire.
 
În blocul if __name__ == "__main__":, se deschid fișierele de intrare și de ieșire (ksir.in și ksir.out). Se citește prima linie din fișierul de intrare pentru a obține valoarea k. Apoi, se verifică dacă datele de intrare sunt valide utilizând funcția validare(k). Dacă datele sunt valide, se afișează un mesaj de confirmare, se apelează funcția k_sir() și se efectuează operațiile corespunzătoare. În final, se închid fișierele de intrare și de ieșire.
validate(k): această funcție validează intrarea k și verifică dacă k este un număr întreg și se încadrează în intervalul specificat (1 - 20.000.000.000). Dacă nu îndeplinește aceste condiții, se va genera o excepție.
 
read_input(): această funcție citește datele de intrare din fișierul "ksir.in", validează intrarea cu ajutorul funcției validate() și returnează valoarea k.
 
main(): această funcție este punctul de intrare în program și utilizează datele citite de la read_input() pentru a determina elementul k din șir. Utilizează o buclă while pentru a găsi cea mai mică grupă care conține elementul k și calculează elementul k folosind formule aritmetice simple. Apoi, scrie rezultatul în fișierul "ksir.out".
 
În general, codul folosește metode simple pentru a calcula elementul k din șir fără a fi nevoie să genereze efectiv șirul întreg. Validarea datelor de intrare asigură că programul funcționează corect și nu se blochează sau generează erori din cauza datelor invalide.

Latest revision as of 19:00, 29 June 2023

Se dă următorul şir de numere: 1 1 2 2 1 2 3 3 3 1 2 3 4 4 4 4 1 2 3 4 5 5 5 5 5... În şir avem grupe formate după următoarea regulă: grupa g conţine numerele naturale de la 1 la g în ordine crescătoare, urmate de g-1 valori egale cu g (g=1, 2, ...).

Cerința[edit | edit source]

Scrieţi un program care citeşte o valoare k şi afişează al k-lea termen al şirului de mai sus.

Date de intrare[edit | edit source]

Fișierul de intrare ksir.in conţine pe prima linie numărul natural k.

Date de ieșire[edit | edit source]

Dacă datele sunt introduse corect, pe ecran se va afișa: "Date de intrare valide.", apoi fișierul de ieșire ksir.out va conţine o singură linie pe care va fi scris un număr natural ce reprezintă al k-lea element din şir. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: "Date de intrare invalide".

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

1 ≤ k ≤ 20.000.000.000 Poziţiile termenilor din şir sunt numerotate începând cu 1.

Exemplu:[edit | edit source]

ksir.in

8
Date de intrare valide

ksir.out

3

Explicație[edit | edit source]

Al 8-lea element din şir este 3.

Rezolvare[edit | edit source]

<syntaxhighlight lang="python" line> def validare(k):

   if not isinstance(k, int):
       raise ValueError("k trebuie sa fie un numar intreg")
   if k < 1 or k > 20000000000:
       raise ValueError("k trebuie sa fie intre 1 si 20.000.000.000")
   return True


def k_sir(k):

   n, cnt = 1, 1
   while (1 * (n + 1) * (n + 1) // 4 < k):
       n += 2
       cnt += 1
   n -= 2
   k -= 1 * (n + 1) * (n + 1) // 4
   nr = 0
   while k:
       if nr != cnt:
           nr += 1
       k -= 1
   fout.write(str(nr))
   fin.close()
   fout.close()


if __name__ == "__main__":

   fin = open("ksir.in")
   fout = open("ksir.out", "w")
   k = int(fin.readline().strip())
   if validare(k):
       print("Date de intrare valide")
       k_sir(k)
   else:
       print("Date de intrare invalide")

</syntaxhighlight>

Explicatie cod:[edit | edit source]

Funcția validare(k) primește un număr întreg k și verifică dacă acesta este un întreg și se încadrează în intervalul [1, 20.000.000.000]. Dacă k nu respectă aceste condiții, funcția aruncă o excepție de tip ValueError cu un mesaj corespunzător. În caz contrar, returnează True. Funcția k_sir(k) primește un număr întreg k și efectuează un set de operații. Folosind o buclă while, se calculează valorile n și cnt până când expresia 1 * (n + 1) * (n + 1) // 4 < k devine falsă. Apoi, se ajustează valorile n și k în funcție de formula specificată. Se parcurge o buclă while în care se scade valoarea k până când acesta devine zero, în timp ce nr este incrementat cu 1 în fiecare iterație. La final, se scrie rezultatul în fișierul de ieșire. În blocul if __name__ == "__main__":, se deschid fișierele de intrare și de ieșire (ksir.in și ksir.out). Se citește prima linie din fișierul de intrare pentru a obține valoarea k. Apoi, se verifică dacă datele de intrare sunt valide utilizând funcția validare(k). Dacă datele sunt valide, se afișează un mesaj de confirmare, se apelează funcția k_sir() și se efectuează operațiile corespunzătoare. În final, se închid fișierele de intrare și de ieșire.