1156 - InaltimiQ: Difference between revisions

From Bitnami MediaWiki
No edit summary
Line 37: Line 37:
<syntaxhighlight lang="python3" line="1">
<syntaxhighlight lang="python3" line="1">
def merge_sort(arr):
def merge_sort(arr):
     if len(arr) > 1:
     if len(arr) <= 1:
         mid = len(arr) // 2
         return arr
        left_half = arr[:mid]
        right_half = arr[mid:]


        merge_sort(left_half)
    mid = len(arr) // 2
        merge_sort(right_half)
    left = arr[:mid]
    right = arr[mid:]


        i = j = k = 0
    left = merge_sort(left)
    right = merge_sort(right)


        while i < len(left_half) and j < len(right_half):
    return merge(left, right)
            if left_half[i] <= right_half[j]:
 
                arr[k] = left_half[i]
def merge(left, right):
    result = []
    i = j = 0
 
    while i < len(left) and j < len(right):
        if left[i][1] < right[j][1]:
            result.append(left[i])
            i += 1
        elif left[i][1] == right[j][1]:
            if left[i][0] < right[j][0]:
                result.append(left[i])
                 i += 1
                 i += 1
             else:
             else:
                 arr[k] = right_half[j]
                 result.append(right[j])
                 j += 1
                 j += 1
             k += 1
        else:
             result.append(right[j])
            j += 1


        while i < len(left_half):
    result.extend(left[i:])
            arr[k] = left_half[i]
    result.extend(right[j:])
            i += 1
   
            k += 1
    return result
 
        while j < len(right_half):
            arr[k] = right_half[j]
            j += 1
            k += 1


def afiseaza_ordinea_copiilor(n, inaltimi):
# Citire date de intrare
    copii = list(range(1, n + 1))
n = int(input())
    merge_sort(inaltimi)
inaltimi = list(map(int, input().split()))


    # Creează un dicționar pentru a ține legătura dintre înălțimi și numerele de ordine
# Adaugare numere de ordine și înălțimi într-o listă de tupluri
    inaltimi_dict = dict(zip(inaltimi, copii))
copii = list(enumerate(inaltimi, start=1))


    # Afișează numerele de ordine ale copiilor în ordinea crescătoare a înălțimii
# Sortare folosind MergeSort
    for inaltime in inaltimi:
copii_sortati = merge_sort(copii)
        print(inaltimi_dict[inaltime], end=" ")


# Citirea datelor de intrare
# Afișare rezultat
n = int(input("Introduceți numărul de copii: "))
for copil in copii_sortati:
inaltimi = list(map(int, input("Introduceți înălțimile copiilor separate prin spațiu: ").split()))
    print(copil[0], end=" ")


# Afișarea rezultatului
afiseaza_ordinea_copiilor(n, inaltimi)


</syntaxhighlight>
</syntaxhighlight>

Revision as of 10:46, 27 December 2023

Cerinta

Se dau înălțimile a n copii, numerotați de la 1 la n, exprimate prin numere naturale. Afișați numerele de ordine ale copiilor în ordinea crescătoare a înălțimii lor.

Pentru sortare se va folosit metoda QuickSort sau MergeSort.

Date de intrare

Programul citește de la tastatură numărul n, iar apoi n numere naturale, separate prin spații, reprezentând, în ordine, înălțimile copiilor.

Date de iesire

Programul va afișa pe ecran n numere naturale distincte cuprinse între 1 și n, separate prin exact un spațiu, reprezentând numerele de ordine ale copiilor în ordinea crescătoare a înălțimii.

Restrictii si precizari

  • 1 ⩽ n ⩽ 1000
  • înălțimile copiilor vor fi numere naturale distincte din intervalul [1 , 10000]

Exemplul 1

Intrare
7
8 20 16 14 10 4 12
Iesire
Datele introduse corespund restrictiilor impuse
6 1 5 7 4 3 2

Exemplul 2

Intrare
4
-6 0 -10 25
Iesire
Datele introduse nu corespund restrictiilor impuse


Rezolvare

<syntaxhighlight lang="python3" line="1"> def merge_sort(arr):

   if len(arr) <= 1:
       return arr
   mid = len(arr) // 2
   left = arr[:mid]
   right = arr[mid:]
   left = merge_sort(left)
   right = merge_sort(right)
   return merge(left, right)

def merge(left, right):

   result = []
   i = j = 0
   while i < len(left) and j < len(right):
       if left[i][1] < right[j][1]:
           result.append(left[i])
           i += 1
       elif left[i][1] == right[j][1]:
           if left[i][0] < right[j][0]:
               result.append(left[i])
               i += 1
           else:
               result.append(right[j])
               j += 1
       else:
           result.append(right[j])
           j += 1
   result.extend(left[i:])
   result.extend(right[j:])
   
   return result
  1. Citire date de intrare

n = int(input()) inaltimi = list(map(int, input().split()))

  1. Adaugare numere de ordine și înălțimi într-o listă de tupluri

copii = list(enumerate(inaltimi, start=1))

  1. Sortare folosind MergeSort

copii_sortati = merge_sort(copii)

  1. Afișare rezultat

for copil in copii_sortati:

   print(copil[0], end=" ")


</syntaxhighlight>