3156 - perm min max: Difference between revisions

Latest revision as of 23:40, 2 June 2024

Cerința[edit | edit source]

Se citește o mulțime cu n numere naturale. Afișați în ordine lexicografică toate permutările mulțimii citite în care elementul minim și cel maxim nu își schimbă poziția.

Date de intrare[edit | edit source]

Programul citește de la tastatură numărul n, iar apoi n numere naturale distincte, separate prin spații.

Date de ieșire[edit | edit source]

Programul va afișa pe ecran permutările cerute, pe rânduri separate, fiecare permutare având elementele separate prin câte un spațiu.

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

1 ≤ n ≤ 10
cele n numere citite vor fi mai mici decât 1.000.000.000 și vor fi distincte

4 2 5 9 7 8
4 2 5 9 8 7
4 2 7 9 5 8
4 2 7 9 8 5
4 2 8 9 5 7
4 2 8 9 7 5
5 2 4 9 7 8
5 2 4 9 8 7
5 2 7 9 4 8
5 2 7 9 8 4
5 2 8 9 4 7
5 2 8 9 7 4
7 2 4 9 5 8
7 2 4 9 8 5
7 2 5 9 4 8
7 2 5 9 8 4
7 2 8 9 4 5
7 2 8 9 5 4
8 2 4 9 5 7
8 2 4 9 7 5
8 2 5 9 4 7
8 2 5 9 7 4
8 2 7 9 4 5
8 2 7 9 5 4

Rezolvare[edit | edit source]

<syntaxhighlight lang="python" line> from itertools import permutations

def main():

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

   min_value = min(arr)
   max_value = max(arr)

   min_index = arr.index(min_value)
   max_index = arr.index(max_value)

   # To store the results
   results = set()

   # Generate permutations
   for perm in permutations(arr):
       if perm[min_index] == min_value and perm[max_index] == max_value:
           results.add(perm)

   # Sort results lexicographically
   results = sorted(results)

   # Print results
   for result in results:
       print(" ".join(map(str, result)))

if __name__ == "__main__":

   main()

</syntaxhighlight>

@@ Line 1: / Line 1: @@
 == Cerința ==
-Să se genereze toate permutările posibile ale unui șir de numere naturale, cu restricția ca permutarea să conțină numărul minim și numărul maxim din șir în poziții consecutive.
+Se citește o mulțime cu n numere naturale. Afișați în ordine lexicografică toate permutările mulțimii citite în care elementul minim și cel maxim nu își schimbă poziția.
 == Date de intrare ==
-Programul citește de la tastatură un șir de n numere naturale.
+Programul citește de la tastatură numărul n, iar apoi n numere naturale distincte, separate prin spații.
 == Date de ieșire ==
-Pe ecran se vor afișa toate permutările șirului care respectă restricția dată, câte una pe linie.
+Programul va afișa pe ecran permutările cerute, pe rânduri separate, fiecare permutare având elementele separate prin câte un spațiu.
 == Restricții și precizări ==
-*1 &les; '''n''' &les; 10
+*1 ≤ n ≤ 10
-* 'x' Numerele din șir sunt naturale și distincte
+*cele n numere citite vor fi mai mici decât 1.000.000.000 și vor fi distincte
 == Exemplu 1 ==
 ;Intrare
-1 2
+<br>
+2 7 9 4 5
 ;Iesire
-3 2<br>
+2 5 9 7 8<br>
-3 1<br>
+2 5 9 8 7<br>
-1 2<br>
+2 7 9 5 8<br>
-2 1
+2 7 9 8 5<br>
+2 8 9 5 7<br>
+2 8 9 7 5<br>
+2 4 9 7 8<br>
+2 4 9 8 7<br>
+2 7 9 4 8<br>
+2 7 9 8 4<br>
+2 8 9 4 7<br>
+2 8 9 7 4<br>
+2 4 9 5 8<br>
+2 4 9 8 5<br>
+2 5 9 4 8<br>
+2 5 9 8 4<br>
+2 8 9 4 5<br>
+2 8 9 5 4<br>
+2 4 9 5 7<br>
+2 4 9 7 5<br>
+2 5 9 4 7<br>
+2 5 9 7 4<br>
+2 7 9 4 5<br>
+2 7 9 5 4
@@ Line 24: / Line 45: @@
 from itertools import permutations
-def citeste_date():
+def main():
-     try:
+     n = int(input())
-        sir = list(map(int, input("Introduceți șirul de numere naturale, separate prin spațiu: ").split()))
+    arr = list(map(int, input().split()))
-        return sir
-    except ValueError:
-        return None
-def valideaza_date(sir):
+     min_value = min(arr)
-     if not (1 <= len(sir) <= 10):
+     max_value = max(arr)
-        return False
-    if not all(isinstance(num, int) and num >= 0 for num in sir):
-        return False
-     if len(sir) != len(set(sir)):
-        return False
-    return True
-def permutari_cu_min_max(sir):
+     min_index = arr.index(min_value)
-     min_val = min(sir)
+     max_index = arr.index(max_value)
-     max_val = max(sir)
-    permutari = permutations(sir)
-    permutari_valide = []
-    for perm in permutari:
-        for i in range(len(perm) - 1):
-            if (perm[i] == min_val and perm[i + 1] == max_val) or (perm[i] == max_val and perm[i + 1] == min_val):
-                permutari_valide.append(perm)
-                break
-    return permutari_valide
-def main():
+    # To store the results
-     sir = citeste_date()
+     results = set()
-     if sir is None or not valideaza_date(sir):
+     # Generate permutations
-         print("Datele de intrare nu corespund restricțiilor impuse.")
+     for perm in permutations(arr):
-        return
+         if perm[min_index] == min_value and perm[max_index] == max_value:
+            results.add(perm)
-     print("Datele de intrare corespund restricțiilor impuse.")
-    permutari = permutari_cu_min_max(sir)
+     # Sort results lexicographically
+     results = sorted(results)
-     for perm in permutari:
-         print(" ".join(map(str, perm)))
+     # Print results
+     for result in results:
+         print(" ".join(map(str, result)))
 if __name__ == "__main__":