Kombinieren und sortieren Sie zwei Arrays mit unterschiedlicher Größe. Dann ersetzen Sie sie durch 0 und 1 in C-Programm

Question

Dies ist der letzte Teil in einem großen Projekt. Die Frage meines Projekts ist, das Programm in C zu programmieren, das von dezimal in binär konvertieren kann. Ich habe alles gemacht, aber ich blieb bei einem Teil. Nach der Trennung in zwei Arrays - ein Array enthält die Positionen von 1 und ein anderes enthält die Positionen von 0. Zum Beispiel mit Nummer 19. Meine Arrays haben:

array1 = {4,1,0} //which are pow(2,4),pow(2,1), and pow(1,0). Natürlich sollten diese Zahlen mit der Nummer 1.

Ähnlich ersetzt werden, zeigen array2 = {3,2} // which are pow(2,3) and pow(2,2) die Zahlen sollten mit der Nummer 0.

Meine Frage ersetzt werden ist: Gibt es eine Möglichkeit, zu kombinieren und zu sortieren, diese beiden Arrays in eine neue Array. Schließlich müssen wir den Wert des neuen Arrays vergleichen, um nach dem wiederholten Wert zu suchen, der 0 und 1 ersetzt.

Beispiel: Lassen Sie uns Nummer 19 ansehen;

Unten ist mein Code, um von dezimal zu binär zu konvertieren, aber es wird aufgrund der ungelösten Frage oben nicht erreicht.

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <ctype.h> 
#include <math.h> 

int main(){ 
    int number,number1,y,i,total=0,z,a,ya,a1,m,n,count1=0,count2=0; 
    int array1[10]; 
    int array2[10]; 
    float x,xa; 
    printf("Enter the number you want to convert from decimal integer to binary: \n"); 
    scanf(" %d",&number1); 
    number = number1; 

x = log2f(number1); 
y = floor(x); 



while(y!=0){ 
    for (m=0;m<=100;m++){ 


     x = log2f(number1); 
     y = floor(x); 







     number1 = number1 - pow(2,y); 

     //array1 = (int *)malloc(y * sizeof(int)); 

     array1[m] = y; 

     count1 += 1; 


     if (number1==0){ 
      break; 
     } 
    } 

} 


x = log2f(number); 
y = floor(x); 



for (i=0;i<=y;i++){ 
    z = pow(2,i); 
    total += z; 

} 
a = total - number; 
a1=a; 
xa = log2f(a); 
ya = floor(xa); 

while(ya!=0){ 
    for (n=0;n<=100;n++){ 


     xa = log2f(a); 
     ya = floor(xa); 







     a = a - pow(2,ya); 



     array2[n] = ya; 

     count2 += 1; 


     if (a==0){ 
      ya = 0; 
      break; 
     } 
    } 

} 

Answer 1

sowohl array1 und array2 Unter der Annahme, sortiert sind in absteigender Reihenfolge, ein Ansatz des binären Array zu erstellen expectedoutput indem kontinuierlich ist, um die ersten Elemente der array1 und array2 vergleicht. Der größere Wert der beiden ersten Elemente ist der Wert, der an expectedoutput als 1 oder 0 gesendet wird. Das größere erste Element wird dann aus seinem enthaltenden Array entfernt. Hier ist eine Abbildung:

/* 
    expectedoutput = {} 
    array1 = {4, 1, 0} 
    array2 = {3, 2} 

    procedure: -------------------------------------------------------------------- 
    (any element from array1 is added to expectedoutput as 1, and from array2 as 0) 

     {4, 1, 0} ------- ------- {3, 2} 
     ^    |  ^
         4 > 3  --> array1 = {1, 0} , expectedoutput = {1} 
         | 
      {1, 0} ------- ------- {3, 2} 
      ^   |  ^
         1 < 3  --> array2 = {2}, expectedoutput = {1, 0} 
         | 
      {1, 0} ------- ------- {2} 
      ^   |  ^
         1 < 2  --> array2 = {}, expectedoutput = {1, 0, 0} 
         | 
      {1, 0} ------- ------- {} 
         | 
         ----------> array2 is empty, so add 1 to expectedoutput 
             until array1 becomes empty 
            Now: array1 = {}, array2 = {}, 
              expectedoutput = {1, 0, 0, 1, 1} 
*/ 

Da wir mit 1 und 0 zu tun hat, wäre es eine gute Idee, um leere Arrays zu einem gewissen ungültigen Wert wie -1 gesetzt. Sie können memset bei der ersten Deklaration als int array1[10]; memset(array1, -1, sizeof(array1)); verwenden, so dass später array1 = {4, 1, 0, -1, -1, -1, -1, -1, -1, -1}. Ähnlich wie bei jedem anderen Array.

Jetzt können wir das obige Verfahren implementieren, indem wir zwei Funktionen schreiben: eine, die das erste Element aus einem Array entfernt, und eine andere, die expectedoutput mit zwei Arrays erstellt.

Zum ersten Element eines Arrays zu entfernen:

// remove_first(arr, len) removes the first element of arr[len] 
// For example: arr[5] = {3, 2, 6, -1, -1} 
//    remove_first(arr, 5) 
//    arr[5] == {2, 6, -1, -1, -1} 
void remove_first(int *arr, int len) { 
    for (int i = 0; i < len-1; ++i) { 
     arr[i] = arr[i+1]; 
    } 
    arr[len-1] = -1; 
} 

Binärfeldes zu erstellen:

// create_binary_array(arr, arr1, len1, arr2, len2) updates arr by setting 
// its elements to either 1 or 0, using arr1 and arr2 
// For example: arr[10] = {}, arr1[10] = {3, 1}, arr2[10] = {2} 
//    create_binary_array(arr, arr1, 10, arr2, 10) 
//    arr == {1, 0, 1}, arr1 == {}, arr2 == {} 
void create_binary_array(int *arr, int *arr1, int len1, int *arr2, int len2) { 
    int i = 0; 
    while (arr1[0] != -1 || arr2[0] != -1) { 
     if (arr1[0] == -1) { 
      while (arr2[0] != -1) { 
       arr[i] = 0; 
       ++i; 
       remove_first(arr2, len2); 
      } 
     } else if (arr2[0] == -1) { 
      while (arr1[0] != -1) { 
       arr[i] = 1; 
       ++i; 
       remove_first(arr1, len1); 
      } 
     } else if (arr1[0] > arr2[0]) { 
      arr[i] = 1; 
      ++i; 
      remove_first(arr1, len1); 
     } else if (arr1[0] < arr2[0]) { 
      arr[i] = 0; 
      ++i; 
      remove_first(arr2, len2); 
     } 
    } 
} 

so können Sie jetzt haben:

int expectedoutput[10]; 
memset(expectedoutput, -1, sizeof(expectedoutput)); 

int array1[10] = {4, 1, 0, -1, -1, -1, -1, -1, -1, -1}; 
int array2[10] = {3, 2, -1, -1, -1, -1, -1, -1, -1, -1}; 

create_binary_array(expectedoutput, array1, 10, array2, 10); 

// Now: expectedoutput == {1, 0, 0, 1, 1, -1, -1, -1, -1, -1}