1155 - Cautare Binara: Difference between revisions

From Bitnami MediaWiki
Andrada378 (talk | contribs)
Pagină nouă: Cerinta Se dă un vector x cu n elemente numere naturale, ordonate crescător, și un vector y cu m elemente, de asemenea numere naturale. Verificați pentru fiecare element al vectorului y dacă apare în x. Date de intrare Programul citește de la tastatură numărul n, iar apoi cele n elemente ale vectorului x. Apoi și citește m și cele m elemente ale lui y. Date de iesire Programul va afișa pe ecran m valori 0 sau 1, separate prin exact un spațiu. A j-a valoare...
 
Andrada378 (talk | contribs)
 
(One intermediate revision by the same user not shown)
Line 1: Line 1:
Cerinta
== Cerința ==
 
Se dă un vector x cu n elemente numere naturale, ordonate crescător, și un vector y cu m elemente, de asemenea numere naturale. Verificați pentru fiecare element al vectorului y dacă apare în x.
Se dă un vector x cu n elemente numere naturale, ordonate crescător, și un vector y cu m elemente, de asemenea numere naturale. Verificați pentru fiecare element al vectorului y dacă apare în x.


Date de intrare
== Date de intrare ==
 
Programul citește de la tastatură numărul n, iar apoi cele n elemente ale vectorului x. Apoi și citește m și cele m elemente ale lui y.
Programul citește de la tastatură numărul n, iar apoi cele n elemente ale vectorului x. Apoi și citește m și cele m elemente ale lui y.


Date de iesire
== Date de ieșire ==
 
Programul va afișa pe ecran m valori 0 sau 1, separate prin exact un spațiu. A j-a valoare afișată este 1, dacă al j-lea element al șirului y apare în x, respectiv 0 în caz contrar.
Programul va afișa pe ecran m valori 0 sau 1, separate prin exact un spațiu. A j-a valoare afișată este 1, dacă al j-lea element al șirului y apare în x, respectiv 0 în caz contrar.


Restrictii si precizari
== Restricții si precizări ==


1 ≤ n ≤ 25000
* 1 ≤ n ≤ 25000
* 1 ≤ m ≤ 200000
* elementele celor 2 vectori vor fi mai mici decât 1.000.000.000


1 ≤ m ≤ 200000
=== Exemplu: ===
 
'''Intrare'''
elementele celor 2 vectori vor fi mai mici decât 1.000.000.000
 
Exemplu
 
Intrare


7
7
Line 31: Line 25:
8 14 9 14 16 15 4 2  
8 14 9 14 16 15 4 2  


Iesire
'''Ieșire'''


0 1 1 1 0 0 0 1
0 1 1 1 0 0 0 1


Rezolvare:
== Rezolvare ==
<syntaxhighlight lang="python">
def validate_input(n, a, m, b):
    # Verificare pentru n
    if not (1 <= n <= 25000):
        print("Valoarea lui n nu respectă restricțiile.")
        return False


def cautare_binara(arr, obiectiv):
    # Verificare pentru elementele vectorului a
    if any(not -1000000000 <= ai <= 1000000000 for ai in a):
        print("Elementele vectorului a depășesc limita de 1.000.000.000.")
        return False


    left, right = 0, len(arr) - 1 #initializam 2 variabile , left va fi indicele de start iar
    # Verificare pentru m
    if not (1 <= m <= 200000):
        print("Valoarea lui m nu respectă restricțiile.")
        return False


    #right indicele de final
    # Verificare pentru elementele vectorului b
    if any(not -1000000000 <= bi <= 1000000000 for bi in b):
        print("Elementele vectorului b depășesc limita de 1.000.000.000.")
        return False


    while left <= right:
    return True
def cautare_binara(arr, obiectiv):


        mij = left + (right - left) // 2
    left, right = 0, len(arr) - 1


        if arr[mij] == obiectiv: #Verificam daca valoarea din mijloc este egala cu obiectivul,
    while left <= right:


            #Daca da, inseamna ca am gasit elementul cautat si returnam True
        mij = left + (right - left) // 2


            return True
        if arr[mij] == obiectiv:


        elif arr[mij] < obiectiv:


            left = mij + 1
            return True


        else:
        elif arr[mij] < obiectiv:


            right = mij - 1
            left = mij + 1


    return False
        else:


def verifica_elementele():
            right = mij - 1


    n = int(input())
    return False


    x = list(map(int, input().split()))
def verifica_elementele():


    m = int(input())
    n = int(input())


    y = list(map(int, input().split()))
    x = list(map(int, input().split()))


    rezultat = []
    m = int(input())


    x.sort()  # Sortăm vectorul x pentru a folosi căutarea binară
    y = list(map(int, input().split()))


    for elem in y:
    rezultat = []


        if cautare_binara(x, elem):
    x.sort()


            rezultat.append(1)
    for elem in y:
        if cautare_binara(x, elem):


        else:
            rezultat.append(1)


            rezultat.append(0)
        else:
            rezultat.append(0)


    return rezultat
    return rezultat


def main():
def main():
 
    rezultat = verifica_elementele()
    rezultat = verifica_elementele()
    print(*rezultat)
 
    print(*rezultat)


if __name__ == "__main__":
if __name__ == "__main__":
 
    main()
    main()
</syntaxhighlight>

Latest revision as of 10:33, 5 January 2024

Cerința[edit | edit source]

Se dă un vector x cu n elemente numere naturale, ordonate crescător, și un vector y cu m elemente, de asemenea numere naturale. Verificați pentru fiecare element al vectorului y dacă apare în x.

Date de intrare[edit | edit source]

Programul citește de la tastatură numărul n, iar apoi cele n elemente ale vectorului x. Apoi și citește m și cele m elemente ale lui y.

Date de ieșire[edit | edit source]

Programul va afișa pe ecran m valori 0 sau 1, separate prin exact un spațiu. A j-a valoare afișată este 1, dacă al j-lea element al șirului y apare în x, respectiv 0 în caz contrar.

Restricții si precizări[edit | edit source]

  • 1 ≤ n ≤ 25000
  • 1 ≤ m ≤ 200000
  • elementele celor 2 vectori vor fi mai mici decât 1.000.000.000

Exemplu:[edit | edit source]

Intrare

7

1 2 5 6 9 10 14

8

8 14 9 14 16 15 4 2

Ieșire

0 1 1 1 0 0 0 1

Rezolvare[edit | edit source]

<syntaxhighlight lang="python"> def validate_input(n, a, m, b):

   # Verificare pentru n
   if not (1 <= n <= 25000):
       print("Valoarea lui n nu respectă restricțiile.")
       return False
   # Verificare pentru elementele vectorului a
   if any(not -1000000000 <= ai <= 1000000000 for ai in a):
       print("Elementele vectorului a depășesc limita de 1.000.000.000.")
       return False
   # Verificare pentru m
   if not (1 <= m <= 200000):
       print("Valoarea lui m nu respectă restricțiile.")
       return False
   # Verificare pentru elementele vectorului b
   if any(not -1000000000 <= bi <= 1000000000 for bi in b):
       print("Elementele vectorului b depășesc limita de 1.000.000.000.")
       return False
   return True

def cautare_binara(arr, obiectiv):

   left, right = 0, len(arr) - 1
   while left <= right:
       mij = left + (right - left) // 2
       if arr[mij] == obiectiv:


           return True
       elif arr[mij] < obiectiv:
           left = mij + 1
       else:
           right = mij - 1
   return False

def verifica_elementele():

   n = int(input())
   x = list(map(int, input().split()))
   m = int(input())
   y = list(map(int, input().split()))
   rezultat = []
   x.sort()
   for elem in y:
       if cautare_binara(x, elem):
           rezultat.append(1)
       else:
           rezultat.append(0)
   return rezultat

def main():

   rezultat = verifica_elementele()
   print(*rezultat)

if __name__ == "__main__":

   main()

</syntaxhighlight>