分区负和正，不与0比较-yiteyi-C++库

给定一个由n个整数组成的数组，包括负整数和正整数，将它们分成两个不同的数组，而不将任何元素与0进行比较。

null

例如：

Input : arr[] = [1, -2, 6, -7, 8]Output : a[] = [1, 6, 8]          b[] = [-2, -7]

推荐：请尝试你的方法 {IDE} 首先，在进入解决方案之前。

算法：

初始化两个空向量。将数组的第一个元素推入两个向量中的任意一个。假设第一个向量。让它用x表示。
对于每一个其他元素，arr[1]到arr[n-1]，检查其符号和x的符号是否相同。如果符号相同，则将元素推到同一向量中。否则，将元素推入另一个向量。
完成两个向量的遍历后，打印两个向量。

如何检查他们的标志是否相反？检查整数是否由x和y表示。负数的符号位为1，正数的符号位为0。x和y的异或将有符号位为1，当且仅当它们有相反的符号。换句话说，x和y的XOR将是一个负数，当且仅当x和y有相反的符号。

CPP

                         // CPP program to rearrange positive and                       
                         // negative numbers without comparison                       
                         // with 0.                       
                         #include <bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         bool                                     oppositeSigns(                                     int                                     x,                                     int                                     y)                       
                         {                       
                                                 return                                     ((x ^ y) < 0);                       
                         }                       
           
                         void                                     partitionNegPos(                                     int                                     arr[],                                     int                                     n)                       
                         {                       
                                                 vector<                                     int                                     > a, b;                       
           
                                                 // Push first element to a.                       
                                                 a.push_back(arr[0]);                       
           
                                                 // Now put all elements of same sign                       
                                                 // in a[] and opposite sign in b[]                       
                                                 for                                     (                                     int                                     i = 1; i < n; i++) {                       
                                                 if                                     (oppositeSigns(a[0], arr[i]))                       
                                                 b.push_back(arr[i]);                       
                                                 else                       
                                                 a.push_back(arr[i]);                       
                                                 }                       
           
                                                 // Print a[] and b[]                       
                                                 for                                     (                                     int                                     i = 0; i < a.size(); i++)                       
                                                 cout << a[i] <<                                     ' '                                     ;                       
                                                 cout <<                                     ''                                     ;                       
                                                 for                                     (                                     int                                     i = 0; i < b.size(); i++)                       
                                                 cout << b[i] <<                                     ' '                                     ;                       
                         }                       
           
                         int                                     main()                       
                         {                       
                                                 int                                     arr[] = { 1, -2, 6, -7, 8 };                       
                                                 int                                     n =                                     sizeof                                     (arr) /                                     sizeof                                     (arr[0]);                       
                                                 partitionNegPos(arr, n);                       
                                                 return                                     0;                       
                         }                       

JAVA

                         // Java program to rearrange positive and                       
                         // negative numbers without comparison                       
                         // with 0.                       
                         import                                     java.util.*;                       
           
                         class                                     GFG                       
                         {                       
                                   
                         static                                     boolean                                     oppositeSigns(                                     int                                     x,                                     int                                     y)                       
                         {                       
                                                 return                                     ((x ^ y) <                                     0                                     );                       
                         }                       
           
                         static                                     void                                     partitionNegPos(                                     int                                     arr[],                                     int                                     n)                       
                         {                       
                                                 Vector<Integer> a =                                     new                                     Vector<Integer>();                       
                                                 Vector<Integer> b =                                     new                                     Vector<Integer>();                       
           
                                                 // Push first element to a.                       
                                                 a.add(arr[                                     0                                     ]);                       
           
                                                 // Now put all elements of same sign                       
                                                 // in a[] and opposite sign in b[]                       
                                                 for                                     (                                     int                                     i =                                     1                                     ; i < n; i++)                       
                                                 {                       
                                                 if                                     (oppositeSigns(a.get(                                     0                                     ), arr[i]))                       
                                                 b.add(arr[i]);                       
                                                 else                       
                                                 a.add(arr[i]);                       
                                                 }                       
           
                                                 // Print a[] and b[]                       
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < a.size(); i++)                       
                                                 System.out.print(a.get(i) +                                     " "                                     );                       
                                                 System.out.println(                                     ""                                     );                       
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < b.size(); i++)                       
                                                 System.out.print(b.get(i) +                                     " "                                     );                       
                         }                       
           
                         public                                     static                                     void                                     main(String[] args)                       
                         {                       
                                                 int                                     arr[] = {                                     1                                     , -                                     2                                     ,                                     6                                     , -                                     7                                     ,                                     8                                     };                       
                                                 int                                     n = arr.length;                       
                                                 partitionNegPos(arr, n);                       
                         }                       
                         }                       
           
                         // This code has been contributed by 29AjayKumar                       

Python3

                         # Python3 program to rearrange positive                       
                         # and negative numbers without comparison                       
                         # with 0.                       
           
                         def                                     oppositeSigns(x, y):                       
                                   
                                                 return                                     ((x ^ y) <                                     0                                     )                       
           
                         def                                     partitionNegPos(arr, n):                       
                                   
                                                 a                                     =                                     []                       
                                                 b                                     =                                     []                       
                                   
                                                 # Push first element to a.                       
                                                 a                                     =                                     a                                     +                                     [arr[                                     0                                     ]]                       
                                   
                                                 # Now put all elements of same sign                       
                                                 # in a[] and opposite sign in b[]                       
                                                 for                                     i                                     in                                     range                                     (                                     1                                     , n) :                       
                                                 if                                     (oppositeSigns(a[                                     0                                     ], arr[i])):                       
                                                 b                                     =                                     b                                     +                                     [arr[i]]                       
                                                 else                                     :                       
                                                 a                                     =                                     a                                     +                                     [arr[i]]                       
                                   
                                                 # Print a[] and b[]                       
                                                 for                                     i                                     in                                     range                                     (                                     0                                     ,                                     len                                     (a)):                       
                                                 print                                     (a[i], end                                     =                                     ' '                                     )                       
                                                 print                                     ("")                       
                                   
                                                 for                                     i                                     in                                     range                                     (                                     0                                     ,                                     len                                     (b)):                       
                                                 print                                     (b[i], end                                     =                                     ' '                                     )                       
           
                         # Driver code                       
                         arr                                     =                                     [                                     1                                     ,                                     -                                     2                                     ,                                     6                                     ,                                     -                                     7                                     ,                                     8                                     ]                       
                         n                                     =                                     len                                     (arr)                       
                         partitionNegPos(arr, n)                       
           
                         # This code is contributed by Smitha                       

C#

                         // C# program to rearrange positive and                       
                         // negative numbers without comparison                       
                         // with 0.                       
                         using                                     System;                       
                         using                                     System.Collections.Generic;                       
           
                         class                                     GFG                       
                         {                       
                                   
                         static                                     bool                                     oppositeSigns(                                     int                                     x,                                     int                                     y)                       
                         {                       
                                                 return                                     ((x ^ y) < 0);                       
                         }                       
           
                         static                                     void                                     partitionNegPos(                                     int                                     []arr,                                     int                                     n)                       
                         {                       
                                                 List<                                     int                                     > a =                                     new                                     List<                                     int                                     > ();                       
                                                 List<                                     int                                     > b =                                     new                                     List<                                     int                                     > ();                       
           
                                                 // Push first element to a.                       
                                                 a.Add(arr[0]);                       
           
                                                 // Now put all elements of same sign                       
                                                 // in a[] and opposite sign in b[]                       
                                                 for                                     (                                     int                                     i = 1; i < n; i++)                       
                                                 {                       
                                                 if                                     (oppositeSigns(a[0], arr[i]))                       
                                                 b.Add(arr[i]);                       
                                                 else                       
                                                 a.Add(arr[i]);                       
                                                 }                       
           
                                                 // Print a[] and b[]                       
                                                 for                                     (                                     int                                     i = 0; i < a.Count; i++)                       
                                                 Console.Write(a[i] +                                     " "                                     );                       
                                                 Console.WriteLine(                                     ""                                     );                       
                                                 for                                     (                                     int                                     i = 0; i < b.Count; i++)                       
                                                 Console.Write(b[i] +                                     " "                                     );                       
                         }                       
           
                         // Driver code                       
                         public                                     static                                     void                                     Main()                       
                         {                       
                                                 int                                     []arr = { 1, -2, 6, -7, 8 };                       
                                                 int                                     n = arr.Length;                       
                                                 partitionNegPos(arr, n);                       
                         }                       
                         }                       
           
                         /* This code contributed by PrinciRaj1992 */                       

Javascript

                         <script>                       
           
                         // Javascript program to rearrange positive and                       
                         // negative numbers without comparison                       
                         // with 0.                       
           
                         function                                     oppositeSigns(x, y)                       
                         {                       
                                                 return                                     ((x ^ y) < 0);                       
                         }                       
           
                         function                                     partitionNegPos(arr, n)                       
                         {                       
                                                 var                                     a = [], b = [];                       
           
                                                 // Push first element to a.                       
                                                 a.push(arr[0]);                       
           
                                                 // Now put all elements of same sign                       
                                                 // in a[] and opposite sign in b[]                       
                                                 for                                     (                                     var                                     i = 1; i < n; i++) {                       
                                                 if                                     (oppositeSigns(a[0], arr[i]))                       
                                                 b.push(arr[i]);                       
                                                 else                       
                                                 a.push(arr[i]);                       
                                                 }                       
           
                                                 // Print a[] and b[]                       
                                                 for                                     (                                     var                                     i = 0; i < a.length; i++)                       
                                                 document.write( a[i] +                                     ' '                                     );                       
                                                 document.write(                                     "<br>"                                     );                       
                                                 for                                     (                                     var                                     i = 0; i < b.length; i++)                       
                                                 document.write( b[i] +                                     ' '                                     );                       
                         }                       
           
                         var                                     arr = [1, -2, 6, -7, 8];                       
                         var                                     n = arr.length;                       
                         partitionNegPos(arr, n);                       
           
           
                         </script>                       

输出：

1 6 8-2 -7

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章