Почему возникает ошибка сегментации?(язык С)

файл Header.с

#include <memory.h>
#include <minmax.h>
#include "Header.h"

bool isFound( const Set set , const int val ) {
for ( size_t i = 0; i < set.size; ++i )
if ( set.data[ i ] == val )
return true;

return false;
}

void pushback( Set* set , const int val ) {
set->data[ set->size ] = val;
set->size++;
}

void fprintset( FILE* out , const Set set ) {
fprintf( out , "{" );
if ( set.size ) {
for ( size_t i = 0; i < set.size - 1; ++i )
fprintf( out , "%d, " , set.data[ i ] );

fprintf( out , "%d" , set.data[ set.size - 1 ] );
}
fprintf( out , "}" );
}

void fprintbitset( FILE* out , const Bitset set ) {
fprintf( out , "{" );
if ( set.size ) {
for ( size_t i = 0; i < set.size - 1; i++ ) {
if ( set.data[ i ] )
fprintf( out , "%d, " , ( int )i + 1 );

}
if ( set.data[ set.size - 1 ] )
fprintf( out , "%d" , ( int )set.size );
}
fprintf( out , "}" );
}

void unionU( const Set set_1 , const Set set_2 , Set* out_set ) {
memcpy( out_set->data , set_1.data , set_1.size * sizeof( int ) );
out_set->size = set_1.size;

for ( size_t i = 0; i < set_2.size; ++i )
if ( !isFound( set_1 , set_2.data[ i ] ) )
pushback( out_set , set_2.data[ i ] );
}

void unionO( const Set set_1 , const Set set_2 , Set* out_set ) {
out_set->size = 0;
size_t set_1_i = 0;
size_t set_2_i = 0;
while ( set_1_i < set_1.size &&
set_2_i < set_2.size ) {
if ( set_1.data[ set_1_i ] < set_2.data[ set_2_i ] )
pushback( out_set , set_1.data[ set_1_i++ ] );

else if ( set_1.data[ set_1_i ] == set_2.data[ set_2_i ] ) {
pushback( out_set , set_1.data[ set_1_i++ ] );
++set_2_i;
}
else
pushback( out_set , set_2.data[ set_2_i++ ] );

}

while ( set_1_i < set_1.size )
pushback( out_set , set_1.data[ set_1_i++ ] );

while ( set_2_i < set_2.size )
pushback( out_set , set_2.data[ set_2_i++ ] );
}

void unionBitset( const Bitset set_1 , const Bitset set_2 , Bitset* out_set ) {
out_set->size = 0;
for ( size_t i = 0; i < max( set_1.size , set_2.size ); ++i ) {
out_set->data[ i ] = ( ( i < set_1.size ) ? set_1.data[ i ] : 0 ) || ( ( i < set_2.size ) ? set_2.data[ i ] : 0 );

if ( out_set->data[ i ] )
out_set->size = i + 1;
}
}

void intersectionU( const Set set_1 , const Set set_2 , Set* out_set ) {
out_set->size = 0;
for ( size_t i = 0; i < set_2.size; ++i )
if ( isFound( set_1 , set_2.data[ i ] ) )
pushback( out_set , set_2.data[ i ] );
}

void intersectionO( const Set set_1 , const Set set_2 , Set* out_set ) {
out_set->size = 0;
size_t set_1_i = 0;
size_t set_2_i = 0;

while ( set_1_i < set_1.size && set_2_i < set_2.size ) {
if ( set_1.data[ set_1_i ] == set_2.data[ set_2_i ] ) {
pushback( out_set , set_1.data[ set_1_i++ ] );
++set_2_i;
}
else if ( set_1.data[ set_1_i ] < set_2.data[ set_2_i ] )
++set_1_i;
else
++set_2_i;
}
}

void intersectionBitset( const Bitset set_1 , const Bitset set_2 , Bitset* out_set ) {
out_set->size = 0;
for ( size_t i = 0; i < min( set_1.size , set_2.size ); ++i ) {
out_set->data[ i ] = ( ( i < set_1.size ) ? set_1.data[ i ] : 0 ) && ( ( i < set_2.size ) ? set_2.data[ i ] : 0 );

if ( out_set->data[ i ] )
out_set->size = i + 1;
}
}


void differenceU( const Set set_1 , const Set set_2 , Set* out_set ) {
out_set->size = 0;

for ( size_t i = 0; i < set_1.size; i++ )
if ( !isFound( set_2 , set_1.data[ i ] ) )
pushback( out_set , set_1.data[ i ] );
}

void differenceO( const Set set_1 , const Set set_2 , Set* out_set ) {
out_set->size = 0;
size_t set_1_i = 0;
size_t set_2_i = 0;

while ( set_1_i < set_1.size && set_2_i < set_2.size ) {
if ( set_1.data[ set_1_i ] == set_2.data[ set_2_i ] ) {
set_1_i++;
set_2_i++;
}
else if ( set_1.data[ set_1_i ] < set_2.data[ set_2_i ] )
pushback( out_set , set_1.data[ set_1_i++ ] );
else
++set_2_i;
}

while ( set_1_i < set_1.size )
pushback( out_set , set_1.data[ set_1_i++ ] );
}

void differenceBitset( const Bitset set_1 , const Bitset set_2 , Bitset* out_set ) {
out_set->size = 0;
for ( size_t i = 0; i < set_1.size; i++ ) {
out_set->data[ i ] = ( ( i < set_1.size ) ? set_1.data[ i ] : 0 ) && !( ( i < set_2.size ) ? set_2.data[ i ] : 0 );

if ( out_set->data[ i ] )
out_set->size = i + 1;
}
}

void xorU( const Set set_1 , const Set set_2 , Set* out_set ) {
out_set->size = 0;

for ( size_t i = 0; i < set_1.size; ++i )
if ( !isFound( set_2 , set_1.data[ i ] ) )
pushback( out_set , set_1.data[ i ] );

for ( size_t i = 0; i < set_2.size; ++i )
if ( !isFound( set_1 , set_2.data[ i ] ) )
pushback( out_set , set_2.data[ i ] );
}

void xorO( const Set set_1 , const Set set_2 , Set* out_set ) {
out_set->size = 0;
size_t set_1_i = 0;
size_t set_2_i = 0;

while ( set_1_i < set_1.size && set_2_i < set_2.size ) {
if ( set_1.data[ set_1_i ] < set_2.data[ set_2_i ] )
pushback( out_set , set_1.data[ set_1_i++ ] );
else if ( set_1_i == set_1.size || set_1.data[ set_1_i ] > set_2.data[ set_2_i ] )
pushback( out_set , set_2.data[ set_2_i++ ] );
else {
++set_1_i;
++set_2_i;
}
}

while ( set_1_i < set_1.size )
pushback( out_set , set_1.data[ set_1_i++ ] );

while ( set_2_i < set_2.size )
pushback( out_set , set_2.data[ set_2_i++ ] );
}

void xorBitset( const Bitset set_1 , const Bitset set_2 , Bitset* out_set ) {
out_set->size = 0;

for ( size_t i = 0; i < max( set_1.size , set_2.size ); ++i ) {
out_set->data[ i ] = ( ( i < set_1.size ) ? set_1.data[ i ] : 0 ) && !( ( i < set_2.size ) ? set_2.data[ i ] : 0 ) || !( ( i < set_1.size ) ? set_1.data[ i ] : 0 ) && ( ( i < set_2.size ) ? set_2.data[ i ] : 0 );

if ( out_set->data[ i ] )
out_set->size = i + 1;
}
}

bool isSubU( const Set set_1 , const Set set_2 ) {
for ( size_t i = 0; i < set_1.size; ++i )
if ( !isFound( set_2 , set_1.data[ i ] ) )
return false;

return true;
}

bool isSubO( const Set set_1 , const Set set_2 ) {
size_t equal_counter = 0;
size_t set_1_i = 0;
size_t set_2_i = 0;

while ( set_1_i < set_1.size && set_2_i < set_2.size ) {
if ( set_1.data[ set_1_i ] == set_2.data[ set_2_i ] ) {
++set_1_i;
++set_2_i;
++equal_counter;
}
else if ( set_1.data[ set_1_i ] < set_2.data[ set_2_i ] )
++set_1_i;
else
++set_2_i;
}

return equal_counter == set_1.size;
}

bool isSubBitset( const Bitset set_1 , const Bitset set_2 ) {
for ( size_t i = 0; i < max( set_1.size , set_2.size ); ++i )
if ( ( ( i < set_1.size ) ? set_1.data[ i ] : 0 ) && !( ( i < set_2.size ) ? set_2.data[ i ] : 0 ) )
return false;

return true;
}

bool areEqualU( const Set set_1 , const Set set_2 ) {
if ( set_1.size != set_2.size )
return false;

return isSubU( set_1 , set_2 );
}

bool areEqualO( const Set set_1 , const Set set_2 ) {
if ( set_1.size != set_2.size )
return false;

return isSubO( set_1 , set_2 );
}

bool areEqualBitset( const Bitset set_1 , const Bitset set_2 ) {
if ( set_1.size != set_2.size )
return false;

return isSubBitset( set_1 , set_2 );
}

void addToUniverseU( const Set universe , const Set set , Set* out_set ) {
differenceU( universe , set , out_set );
}

void addToUniverseO( Set universe , Set set , Set* out_set ) {
differenceO( universe , set , out_set );
}

void addToUniverseBitset( Bitset universe , Bitset set , Bitset* out_set ) {
differenceBitset( universe , set , out_set );



}

C

#include <memory.h>

#include <minmax.h>

#include "Header.h"



bool isFound( const Set set , const int val ) {

    for ( size_t i = 0; i < set.size; ++i )

        if ( set.data[ i ] == val )

            return true;



    return false;

}



void pushback( Set* set , const int val ) {

    set->data[ set->size ] = val;

    set->size++;

}



void fprintset( FILE* out , const Set set ) {

    fprintf( out , "{" );

    if ( set.size ) {

        for ( size_t i = 0; i < set.size - 1; ++i )

            fprintf( out , "%d, " , set.data[ i ] );



        fprintf( out , "%d" , set.data[ set.size - 1 ] );

    }

    fprintf( out , "}" );

}



void fprintbitset( FILE* out , const Bitset set ) {

    fprintf( out , "{" );

    if ( set.size ) {

        for ( size_t i = 0; i < set.size - 1; i++ ) {

            if ( set.data[ i ] )

                fprintf( out , "%d, " , ( int )i + 1 );



        }

        if ( set.data[ set.size - 1 ] )

            fprintf( out , "%d" , ( int )set.size );

    }

    fprintf( out , "}" );

}



void unionU( const Set set_1 , const Set set_2 , Set* out_set ) {

    memcpy( out_set->data , set_1.data , set_1.size * sizeof( int ) );

    out_set->size = set_1.size;



    for ( size_t i = 0; i < set_2.size; ++i )

        if ( !isFound( set_1 , set_2.data[ i ] ) )

            pushback( out_set , set_2.data[ i ] );

}



void unionO( const Set set_1 , const Set set_2 , Set* out_set ) {

    out_set->size = 0;

    size_t set_1_i = 0;

    size_t set_2_i = 0;

    while ( set_1_i < set_1.size &&

            set_2_i < set_2.size ) {

        if ( set_1.data[ set_1_i ] < set_2.data[ set_2_i ] )

            pushback( out_set , set_1.data[ set_1_i++ ] );



        else if ( set_1.data[ set_1_i ] == set_2.data[ set_2_i ] ) {

            pushback( out_set , set_1.data[ set_1_i++ ] );

            ++set_2_i;

        }

        else

            pushback( out_set , set_2.data[ set_2_i++ ] );



    }



    while ( set_1_i < set_1.size )

        pushback( out_set , set_1.data[ set_1_i++ ] );



    while ( set_2_i < set_2.size )

        pushback( out_set , set_2.data[ set_2_i++ ] );

}



void unionBitset( const Bitset set_1 , const Bitset set_2 , Bitset* out_set ) {

    out_set->size = 0;

    for ( size_t i = 0; i < max( set_1.size , set_2.size ); ++i ) {

        out_set->data[ i ] = ( ( i < set_1.size ) ? set_1.data[ i ] : 0 ) || ( ( i < set_2.size ) ? set_2.data[ i ] : 0 );



        if ( out_set->data[ i ] )

            out_set->size = i + 1;

    }

}



void intersectionU( const Set set_1 , const Set set_2 , Set* out_set ) {

    out_set->size = 0;

    for ( size_t i = 0; i < set_2.size; ++i )

        if ( isFound( set_1 , set_2.data[ i ] ) )

            pushback( out_set , set_2.data[ i ] );

}



void intersectionO( const Set set_1 , const Set set_2 , Set* out_set ) {

    out_set->size = 0;

    size_t set_1_i = 0;

    size_t set_2_i = 0;



    while ( set_1_i < set_1.size && set_2_i < set_2.size ) {

        if ( set_1.data[ set_1_i ] == set_2.data[ set_2_i ] ) {

            pushback( out_set , set_1.data[ set_1_i++ ] );

            ++set_2_i;

        }

        else if ( set_1.data[ set_1_i ] < set_2.data[ set_2_i ] )

            ++set_1_i;

        else

            ++set_2_i;

    }

}



void intersectionBitset( const Bitset set_1 , const Bitset set_2 , Bitset* out_set ) {

    out_set->size = 0;

    for ( size_t i = 0; i < min( set_1.size , set_2.size ); ++i ) {

        out_set->data[ i ] = ( ( i < set_1.size ) ? set_1.data[ i ] : 0 ) && ( ( i < set_2.size ) ? set_2.data[ i ] : 0 );



        if ( out_set->data[ i ] )

            out_set->size = i + 1;

    }

}





void differenceU( const Set set_1 , const Set set_2 , Set* out_set ) {

    out_set->size = 0;



    for ( size_t i = 0; i < set_1.size; i++ )

        if ( !isFound( set_2 , set_1.data[ i ] ) )

            pushback( out_set , set_1.data[ i ] );

}



void differenceO( const Set set_1 , const Set set_2 , Set* out_set ) {

    out_set->size = 0;

    size_t set_1_i = 0;

    size_t set_2_i = 0;



    while ( set_1_i < set_1.size && set_2_i < set_2.size ) {

        if ( set_1.data[ set_1_i ] == set_2.data[ set_2_i ] ) {

            set_1_i++;

            set_2_i++;

        }

        else if ( set_1.data[ set_1_i ] < set_2.data[ set_2_i ] )

            pushback( out_set , set_1.data[ set_1_i++ ] );

        else

            ++set_2_i;

    }



    while ( set_1_i < set_1.size )

        pushback( out_set , set_1.data[ set_1_i++ ] );

}



void differenceBitset( const Bitset set_1 , const Bitset set_2 , Bitset* out_set ) {

    out_set->size = 0;

    for ( size_t i = 0; i < set_1.size; i++ ) {

        out_set->data[ i ] = ( ( i < set_1.size ) ? set_1.data[ i ] : 0 ) && !( ( i < set_2.size ) ? set_2.data[ i ] : 0 );



        if ( out_set->data[ i ] )

            out_set->size = i + 1;

    }

}



void xorU( const Set set_1 , const Set set_2 , Set* out_set ) {

    out_set->size = 0;



    for ( size_t i = 0; i < set_1.size; ++i )

        if ( !isFound( set_2 , set_1.data[ i ] ) )

            pushback( out_set , set_1.data[ i ] );



    for ( size_t i = 0; i < set_2.size; ++i )

        if ( !isFound( set_1 , set_2.data[ i ] ) )

            pushback( out_set , set_2.data[ i ] );

}



void xorO( const Set set_1 , const Set set_2 , Set* out_set ) {

    out_set->size = 0;

    size_t set_1_i = 0;

    size_t set_2_i = 0;



    while ( set_1_i < set_1.size && set_2_i < set_2.size ) {

        if ( set_1.data[ set_1_i ] < set_2.data[ set_2_i ] )

            pushback( out_set , set_1.data[ set_1_i++ ] );

        else if ( set_1_i == set_1.size || set_1.data[ set_1_i ] > set_2.data[ set_2_i ] )

            pushback( out_set , set_2.data[ set_2_i++ ] );

        else {

            ++set_1_i;

            ++set_2_i;

        }

    }



    while ( set_1_i < set_1.size )

        pushback( out_set , set_1.data[ set_1_i++ ] );



    while ( set_2_i < set_2.size )

        pushback( out_set , set_2.data[ set_2_i++ ] );

}



void xorBitset( const Bitset set_1 , const Bitset set_2 , Bitset* out_set ) {

    out_set->size = 0;



    for ( size_t i = 0; i < max( set_1.size , set_2.size ); ++i ) {

        out_set->data[ i ] = ( ( i < set_1.size ) ? set_1.data[ i ] : 0 ) && !( ( i < set_2.size ) ? set_2.data[ i ] : 0 ) || !( ( i < set_1.size ) ? set_1.data[ i ] : 0 ) && ( ( i < set_2.size ) ? set_2.data[ i ] : 0 );



        if ( out_set->data[ i ] )

            out_set->size = i + 1;

    }

}



bool isSubU( const Set set_1 , const Set set_2 ) {

    for ( size_t i = 0; i < set_1.size; ++i )

        if ( !isFound( set_2 , set_1.data[ i ] ) )

            return false;



    return true;

}



bool isSubO( const Set set_1 , const Set set_2 ) {

    size_t equal_counter = 0;

    size_t set_1_i = 0;

    size_t set_2_i = 0;



    while ( set_1_i < set_1.size && set_2_i < set_2.size ) {

        if ( set_1.data[ set_1_i ] == set_2.data[ set_2_i ] ) {

            ++set_1_i;

            ++set_2_i;

            ++equal_counter;

        }

        else if ( set_1.data[ set_1_i ] < set_2.data[ set_2_i ] )

            ++set_1_i;

        else

            ++set_2_i;

    }



    return equal_counter == set_1.size;

}



bool isSubBitset( const Bitset set_1 , const Bitset set_2 ) {

    for ( size_t i = 0; i < max( set_1.size , set_2.size ); ++i )

        if ( ( ( i < set_1.size ) ? set_1.data[ i ] : 0 ) && !( ( i < set_2.size ) ? set_2.data[ i ] : 0 ) )

            return false;



    return true;

}



bool areEqualU( const Set set_1 , const Set set_2 ) {

    if ( set_1.size != set_2.size )

        return false;



    return isSubU( set_1 , set_2 );

}



bool areEqualO( const Set set_1 , const Set set_2 ) {

    if ( set_1.size != set_2.size )

        return false;



    return isSubO( set_1 , set_2 );

}



bool areEqualBitset( const Bitset set_1 , const Bitset set_2 ) {

    if ( set_1.size != set_2.size )

        return false;



    return isSubBitset( set_1 , set_2 );

}



void addToUniverseU( const Set universe , const Set set , Set* out_set ) {

    differenceU( universe , set , out_set );

}



void addToUniverseO( Set universe , Set set , Set* out_set ) {

    differenceO( universe , set , out_set );

}



void addToUniverseBitset( Bitset universe , Bitset set , Bitset* out_set ) {

    differenceBitset( universe , set , out_set );







}

--- Сообщение объединено с предыдущим 19 апр 2022

#ifndef sets_h
#define sets_h

#include <stdio.h>
#include <stdbool.h>

#define MAX_SET_SIZE 10

#define ARRAY_SIZE(ARR) (sizeof(ARR) / sizeof(*ARR))

#define SET(ARR) ((Set) {(ARR), ARRAY_SIZE(ARR)})

#define BITSET(ARR) ((Bitset) {(ARR), ARRAY_SIZE(ARR)})

typedef struct Set {
int* data;
size_t size;
} Set;

typedef struct Bitset {
bool* data;
size_t size;
} Bitset;

void fprintset( FILE* out , Set set );

void fprintbitset( FILE* out , Bitset set );

void unionU( Set set_1 , Set set_2 , Set* out_set );

void unionO( Set set_1 , Set set_2 , Set* out_set );

void unionBitset( Bitset set_1 , Bitset set_2 , Bitset* out_set );

void intersectionU( Set set_1 , Set set_2 , Set* out_set );

void intersectionO( Set set_1 , Set set_2 , Set* out_set );

void intersectionO2( const Set set_1 , const Set set_2 , Set* out_set );

void intersectionBitset( Bitset set_1 , Bitset set_2 , Bitset* out_set );

void differenceU( Set set_1 , Set set_2 , Set* out_set );

void differenceO( Set set_1 , Set set_2 , Set* out_set );

void differenceBitset( Bitset set_1 , Bitset set_2 , Bitset* out_set );

void xorU( Set set_1 , Set set_2 , Set* out_set );

void xorO( Set set_1 , Set set_2 , Set* out_set );

void xorBitset( Bitset set_1 , Bitset set_2 , Bitset* out_set );

bool isSubU( Set set_1 , Set set_2 );

bool isSubO( Set set_1 , Set set_2 );

bool isSubBitset( Bitset set_1 , Bitset set_2 );

bool areEqualU( Set set_1 , Set set_2 );

bool areEqualO( Set set_1 , Set set_2 );

bool areEqualBitset( Bitset set_1 , Bitset set_2 );

void addToUniverseU( Set universe , Set set , Set* out_set );

void addToUniverseO( Set universe , Set set , Set* out_set );

void addToUniverseBitset( Bitset universe , Bitset set , Bitset* out_set );

#endif

C

#ifndef sets_h

#define sets_h



#include <stdio.h>

#include <stdbool.h>



#define MAX_SET_SIZE 10



#define ARRAY_SIZE(ARR) (sizeof(ARR) / sizeof(*ARR))



#define SET(ARR) ((Set) {(ARR), ARRAY_SIZE(ARR)})



#define BITSET(ARR) ((Bitset) {(ARR), ARRAY_SIZE(ARR)})



typedef struct Set {

    int* data;

    size_t size;

} Set;



typedef struct Bitset {

    bool* data;

    size_t size;

} Bitset;



void fprintset( FILE* out , Set set );



void fprintbitset( FILE* out , Bitset set );



void unionU( Set set_1 , Set set_2 , Set* out_set );



void unionO( Set set_1 , Set set_2 , Set* out_set );



void unionBitset( Bitset set_1 , Bitset set_2 , Bitset* out_set );



void intersectionU( Set set_1 , Set set_2 , Set* out_set );



void intersectionO( Set set_1 , Set set_2 , Set* out_set );



void intersectionO2( const Set set_1 , const Set set_2 , Set* out_set );



void intersectionBitset( Bitset set_1 , Bitset set_2 , Bitset* out_set );



void differenceU( Set set_1 , Set set_2 , Set* out_set );



void differenceO( Set set_1 , Set set_2 , Set* out_set );



void differenceBitset( Bitset set_1 , Bitset set_2 , Bitset* out_set );



void xorU( Set set_1 , Set set_2 , Set* out_set );



void xorO( Set set_1 , Set set_2 , Set* out_set );



void xorBitset( Bitset set_1 , Bitset set_2 , Bitset* out_set );



bool isSubU( Set set_1 , Set set_2 );



bool isSubO( Set set_1 , Set set_2 );



bool isSubBitset( Bitset set_1 , Bitset set_2 );



bool areEqualU( Set set_1 , Set set_2 );



bool areEqualO( Set set_1 , Set set_2 );



bool areEqualBitset( Bitset set_1 , Bitset set_2 );



void addToUniverseU( Set universe , Set set , Set* out_set );



void addToUniverseO( Set universe , Set set , Set* out_set );



void addToUniverseBitset( Bitset universe , Bitset set , Bitset* out_set );



#endif

--- Сообщение объединено с предыдущим 19 апр 2022

main

--- Сообщение объединено с предыдущим 19 апр 2022

#include "C:\\\CLionProjects/untitled1\test\Header.h"

Set universe = {(int[]) {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 10};

Set solve(Set *A, Set *B, Set *C) {
Set differenceResFirst = {(int[]) {}, 0};
Set differenceResSecond = {(int[]) {}, 0};
Set symmetricalDifferenceRes = {(int[]) {}, 0};
Set additionRes = {(int[]) {}, 0};
Set subtractionRes = {(int[]) {}, 0};
differenceO(*B, *C, &differenceResFirst);
differenceO(*C, *B, &differenceResSecond);
unionO(differenceResFirst, differenceResSecond, &symmetricalDifferenceRes);
addToUniverseO(universe, symmetricalDifferenceRes, &additionRes);
intersectionO(*A, additionRes, &subtractionRes);
Set unionResSec, additionResSec, subtractionResSec, res;
unionO(*B, *C, &unionResSec);
addToUniverseO(universe, *A, &additionResSec);
intersectionO(unionResSec, additionResSec, &subtractionResSec);
unionO(subtractionRes, subtractionResSec, &res);
return (Set) res;
}


int main() {
Set A = {(int[]) {1, 2, 3, 4, 6, 7}, 6};
Set B = {(int[]) {1, 3, 6, 7}, 4};
Set C = {(int[]) {3, 4, 5, 6, 8}, 5};
Set result = solve(&A, &B, &C);
fprintset(stdout, result);
return 0;

Код

#include "C:\\\CLionProjects/untitled1\test\Header.h"



Set universe = {(int[]) {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 10};



Set solve(Set *A, Set *B, Set *C) {

    Set differenceResFirst = {(int[]) {}, 0};

    Set differenceResSecond = {(int[]) {}, 0};

    Set symmetricalDifferenceRes = {(int[]) {}, 0};

    Set additionRes = {(int[]) {}, 0};

    Set subtractionRes = {(int[]) {}, 0};

    differenceO(*B, *C, &differenceResFirst);

    differenceO(*C, *B, &differenceResSecond);

    unionO(differenceResFirst, differenceResSecond, &symmetricalDifferenceRes);

    addToUniverseO(universe, symmetricalDifferenceRes, &additionRes);

    intersectionO(*A, additionRes, &subtractionRes);

    Set unionResSec, additionResSec, subtractionResSec, res;

    unionO(*B, *C, &unionResSec);

    addToUniverseO(universe, *A, &additionResSec);

    intersectionO(unionResSec, additionResSec, &subtractionResSec);

    unionO(subtractionRes, subtractionResSec, &res);

    return (Set) res;

}





int main() {

    Set A = {(int[]) {1, 2, 3, 4, 6, 7}, 6};

    Set B = {(int[]) {1, 3, 6, 7}, 4};

    Set C = {(int[]) {3, 4, 5, 6, 8}, 5};

    Set result = solve(&A, &B, &C);

    fprintset(stdout, result);

    return 0;