3357 - beta: Difference between revisions

From Bitnami MediaWiki
Flaviu (talk | contribs)
Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/3357/beta3357 - beta] ---- == Cerinţa == Se dă un număr natural n despre care se cunoaște că este putere de 2. Considerăm inițial șirul numerelor naturale de la 1 la n așezate în ordine crescătoare. Notăm cu A acest șir. Pornind de la acesta, se construiește un nou șir (să îl notăm cu B) astfel: Primele n elemente ale lui B sunt chiar elementele șirului A în aceeași ordine. Următoarele n/2 elemente ale lui B sunt ul...
 
Flaviu (talk | contribs)
No edit summary
Line 10: Line 10:


== Date de ieșire ==  
== Date de ieșire ==  
Fișierul beta.out conține valoarea cerută. Dacă șirul B are mai puțin de poz elemente se va scrie în fișier -1.
Fișierul beta.out conține  
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou '''numărul c''', 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 ==
Line 21: Line 23:
: 8 13
: 8 13
; Ieșire
; Ieșire
: Datele nu corespund restricțiilor impuse.
: Datele sunt introduse correct.
: 7
: 7


Line 27: Line 31:
<syntaxhighlight lang="python" line>
<syntaxhighlight lang="python" line>
# 3357 - beta
# 3357 - beta
def generate_B(n):
def construieste_sir(n):
     B = list(range(1, n+1)) # cream o lista cu elementele initiale din A
     sir = list(range(1, n + 1))
     for p in range(1, n.bit_length()): # parcurgem puterile de 2 de la 1 la log2(n)
     i = 2
         last_n_p = B[-n//2**p:]  # luam ultimele n/p elemente din A
    while i <= n:
         if p % 2 == 1: # daca puterea este impara, le adaugam in ordine inversa
        j = i // 2
             B += last_n_p[::-1]
         k = i // 2 + i
        else:  # daca puterea este para, le adaugam in ordine crescatoare
         inc = 1
             B += last_n_p
        while j < k:
     return B
             sir[j:k] = sir[k-1:j-1:-1][::inc]
            j = k
             k = k + i
            inc = -inc
        i *= 2
     return sir


def validate_input(n, poz):
    if poz <= 0 or poz > n*2:
        print("-1")  # afisam -1 daca pozitia este invalida
        exit()


def solve(n, poz):
def determina_element(n, pozitie):
     B = generate_B(n)
     sir = construieste_sir(n)
    validate_input(len(B), poz)
     return sir[pozitie - 1]
     return B[poz-1] # returnam elementul de pe pozitia ceruta (indexarea incepe de la 0)
 


if __name__ == "__main__":
if __name__ == "__main__":
     n, poz = map(int, input().split())
     n, pozitie = map(int, input().split())
     print(solve(n, poz))
     if n % 2 == 0 and n == 2 ** (n.bit_length() - 1) and 1 <= pozitie <= 2 * n:
        print("Datele sunt introduse corect.")
        element = determina_element(n, pozitie)
        print(element)
    else:
        print("Datele nu corespund restricțiilor impuse.")
 




</syntaxhighlight>
</syntaxhighlight>
== Explicatie Rezolvare ==
== Explicatie Rezolvare ==
Funcția generate_B(n) generează șirul B conform algoritmului descris în cerință. Folosim metoda bit_length() pentru a determina numărul de puteri de 2 (adica p) necesare pentru a completa șirul B. Apoi, pentru fiecare putere de 2, luăm ultimele n/p elemente din A și le adăugăm la finalul lui B în funcție de paritatea lui p.


Funcția validate_input(n, poz) verifică dacă poziția dată este validă și afișează -1 dacă nu este.
Funcția construieste_sir(n) construiește șirul B descris în enunț și îl returnează ca o listă. Algoritmul de construcție este relativ simplu: pornim cu lista A și pe baza acesteia construim B prin concatenarea la sfârșitul lui A a unor subsiruri ale lui A care sunt prelucrate într-un mod specific. Am implementat această prelucrare folosind două indici j și k care indică începutul și sfârșitul subsirului din A pe care îl prelucrăm și un contor inc care indică ordinea de parcurgere a subsirului.


Funcția solve(n, poz) este funcția principală care apelează celelalte două funcții și returnează elementul de pe poziția dată.
Funcția determina_element(n, pozitie) determină elementul de pe poziția dată în șirul B pentru n dat. Ea folosește funcția construieste_sir(n) pentru a construi șirul și apoi returnează elementul corespunzător poziției date.


În blocul if __name__ == "__main__": citim datele de intrare și apelăm funcția solve(), apoi afișăm rezultatul.
În if __name__ == "__main__": citim datele de intrare și verificăm dacă sunt corecte, conform restricțiilor din enunț. Dacă da, calculăm elementul cerut și îl afișăm împreună cu mesajul "Datele sunt introduse corect.". Dacă nu, afișăm mesajul "Datele nu corespund restricțiilor impuse.".

Revision as of 14:19, 28 April 2023

Sursa: - beta


Cerinţa

Se dă un număr natural n despre care se cunoaște că este putere de 2. Considerăm inițial șirul numerelor naturale de la 1 la n așezate în ordine crescătoare. Notăm cu A acest șir. Pornind de la acesta, se construiește un nou șir (să îl notăm cu B) astfel: Primele n elemente ale lui B sunt chiar elementele șirului A în aceeași ordine. Următoarele n/2 elemente ale lui B sunt ultimele n/2 elemente ale lui A dar scrise în ordine inversă (descrescător). Următoarele n/4 elemente ale lui B sunt ultimele n/4 elemente ale lui A scrise în ordine crescătoare, următoarele n/8 elemente ale lui B sunt ultimele n/8 elemente ale lui A scrise în ordine descrescătoare, și tot așa, cu fiecare putere de 2 (notată p) ce apare la numitor, luăm ultimele n/p elemente din A și le adăugăm la finalul lui B alternând ordinea de parcurgere, de la o putere la alta conform modului descris mai sus. Se mai să un număr poz. Se cere determinarea numărului de pe poziția poz din șirul B.


Date de intrare

Fișierul beta.in conține pe prima linie numerele naturale n și poz separate printr-un spațiu.


Date de ieșire

Fișierul beta.out conține Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou numărul c, reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse.".

Restricţii şi precizări

  • 1 ≤ n ≤ 1.000.000.000
  • n se dă putere de 2
  • 1 ≤ poz ≤ 2.000.000.000
  • Pentru 55 de puncte avem n ≤ 100.000

Exemplu

Intrare
8 13
Ieșire
Datele nu corespund restricțiilor impuse.
Datele sunt introduse correct.
7

Rezolvare

Rezolvare ver. 1

<syntaxhighlight lang="python" line>

  1. 3357 - beta

def construieste_sir(n):

   sir = list(range(1, n + 1))
   i = 2
   while i <= n:
       j = i // 2
       k = i // 2 + i
       inc = 1
       while j < k:
           sir[j:k] = sir[k-1:j-1:-1][::inc]
           j = k
           k = k + i
           inc = -inc
       i *= 2
   return sir


def determina_element(n, pozitie):

   sir = construieste_sir(n)
   return sir[pozitie - 1]


if __name__ == "__main__":

   n, pozitie = map(int, input().split())
   if n % 2 == 0 and n == 2 ** (n.bit_length() - 1) and 1 <= pozitie <= 2 * n:
       print("Datele sunt introduse corect.")
       element = determina_element(n, pozitie)
       print(element)
   else:
       print("Datele nu corespund restricțiilor impuse.")


</syntaxhighlight>

Explicatie Rezolvare

Funcția construieste_sir(n) construiește șirul B descris în enunț și îl returnează ca o listă. Algoritmul de construcție este relativ simplu: pornim cu lista A și pe baza acesteia construim B prin concatenarea la sfârșitul lui A a unor subsiruri ale lui A care sunt prelucrate într-un mod specific. Am implementat această prelucrare folosind două indici j și k care indică începutul și sfârșitul subsirului din A pe care îl prelucrăm și un contor inc care indică ordinea de parcurgere a subsirului.

Funcția determina_element(n, pozitie) determină elementul de pe poziția dată în șirul B pentru n dat. Ea folosește funcția construieste_sir(n) pentru a construi șirul și apoi returnează elementul corespunzător poziției date.

În if __name__ == "__main__": citim datele de intrare și verificăm dacă sunt corecte, conform restricțiilor din enunț. Dacă da, calculăm elementul cerut și îl afișăm împreună cu mesajul "Datele sunt introduse corect.". Dacă nu, afișăm mesajul "Datele nu corespund restricțiilor impuse.".