Arpakuutiot

input/code.cpp: In function 'uint64_t parseCube()':
input/code.cpp:131:33: warning: array subscript has type 'char' [-Wchar-subscripts]
     pairs[1] = {sides[smallFaseI], sides[oppositeSide(smallFaseI)]};
                                 ^
input/code.cpp: In function 'int oppositeSide(char)':
input/code.cpp:46:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^
input/code.cpp: In function 'uint64_t parseCube()':
input/code.cpp:122:44: warning: 'smallRot' may be used uninitialized in this function [-Wmaybe-uninitialized]
     Spec third = getClosebySide(F(smallRot + 1) ,i, 0);
                                            ^
input/code.cpp:38:5: warning: 'smallFaseI' may be used uninitialized in this function [-Wmaybe-uninitialized]
     switch(side){
     ^~~~~~
input/code.cpp:111:10: note: 'smallFaseI' was declared here
     char smallFaseI, smallRot, val = '7';
          ^~~~~~~~~~

#include<bits/stdc++.h>

using namespace std;

enum Side{
    UP = 0, RIGHT, DOWN, LEFT
};

struct Spec{
    int side;
    int rot;
};

#define F(x) ((x) & 0x03)


Spec getClosebySide(int side, int of, int rot){
    side = F(side + rot);

    if(of < 4){
        if(side == UP){
            return { F(of-1), rot };
        }else if(side == RIGHT){
            return {5, F(rot - of) };
        }else if(side == DOWN){
            return { F(of+1), rot };
        }else{ //LEFT
            return {4, F( rot + of ) };
        }
    }else if(of == 4){
        return {F(side - 1), F(1 - side + rot) };
    }else{
        return {F(3-side), F(3-side + rot) };
    }
}

int oppositeSide(char side){
    switch(side){
    case 0: return 2;
    case 1: return 3;
    case 2: return 0;
    case 3: return 1;
    case 4: return 5;
    case 5: return 4;
    }
}

uint64_t parseCube(){
    char line[42] = { 0 }; // Pad the 0th and the 6th rows
    int i;

    for(i = 6; i < 36; i+=6){
        cin >> (line + i);
    }


    // Find the first character...
    for(i = 6; i < 36; i++){
        if(line[i] != '.' && line[i] != 0) break;
    }

    Spec current = {0, 0};
    char sides[6] = { 0 };

    int nextLineI = -1;
    Spec nextLine;

    do{
        assert(!sides[current.side]);
        sides[current.side] = line[i];

        if(line[i + 6] > '0'){
            nextLineI = i + 6;
            nextLine = getClosebySide(DOWN, current.side, current.rot);
        }

        int row = i;
        Spec left = current;
        while(line[--row] > '0'){
            left = getClosebySide(LEFT, left.side, left.rot);
            assert(!sides[left.side]);
            sides[left.side] = line[row];
            if(line[row + 6] > '0'){
                nextLineI = row + 6;
                nextLine = getClosebySide(DOWN, left.side, left.rot);
            }
        }

        while(line[++i] > '0'){
            current = getClosebySide(RIGHT, current.side, current.rot);
            assert(!sides[current.side]);
            sides[current.side] = line[i];
            if(line[i + 6] > '0'){
                nextLineI = i + 6;
                nextLine = getClosebySide(DOWN, current.side, current.rot);
            }
        }

        if(nextLineI == -1) break;

        i = nextLineI;
        current = nextLine;
        nextLineI = -1;

    }while(1);

    // Find location of '1'
    for(i = 0; sides[i] != '1'; i++);

    // Look for the smallest value next to it...
    char smallFaseI, smallRot, val = '7';
    for(int iclose = UP; iclose <= LEFT; iclose++){
        Spec info = getClosebySide(iclose, i, 0);
        if(sides[info.side] < val){
            smallFaseI = info.side;
            smallRot = iclose;
            val = sides[info.side];
        }
    }

    //Get third side index
    Spec third = getClosebySide(F(smallRot + 1) ,i, 0);

    // Now align one and six vertically, so that 1 is on place one.
    struct Pair{
        char a; char b;
    };

    Pair pairs[4];
    pairs[0] = {sides[i], sides[oppositeSide(i)]};
    pairs[1] = {sides[smallFaseI], sides[oppositeSide(smallFaseI)]};
    pairs[2] = {sides[third.side], sides[oppositeSide(third.side)]};
    pairs[3] = { 0 };


    //printf("Cube faces: %.6s\n", reinterpret_cast<char*>(pairs) );

    //return (uint64_t) pairs[0] | (uint64_t) pairs[1] << 16 | (uint64_t) pairs[2] << 32;

    return *reinterpret_cast<uint64_t*>(pairs);
}

int main(int argc, char *argv[]){
    int n;
    cin >> n;

    uint64_t *cubes = new uint64_t[n];

    for(int i = 0; i < n; i++){
        cubes[i] = parseCube();
    }

    //puts("Cubes:");

    for(int i = 0; i < n; i++){
        int found = 0;
        for(int ii = 0; ii < n; ii++){
            if(ii == i) continue;
            if(cubes[i] == cubes[ii]){
                //if(found++) cout << ' ';
                found++;
                cout << (ii + 1) << ' ';
            }
        }
        if(!found) cout << '-';
        /*if(n - i > 1)*/ cout << '\n';
    }

    return EXIT_SUCCESS;
}

Test 1

Group: 1, 2

Verdict: ACCEPTED

Test 2

Group: 1, 2

Verdict: ACCEPTED

Test 3

Group: 1, 2

Verdict: ACCEPTED

Test 4

Group: 1, 2

Verdict: ACCEPTED

Test 5

Group: 1, 2

Verdict: ACCEPTED

Test 6

Group: 1, 2

Verdict: ACCEPTED

Test 7

Group: 1, 2

Verdict: ACCEPTED

Test 8

Group: 1, 2

Verdict: ACCEPTED

Test 9

Group: 1, 2

Verdict: ACCEPTED

Test 10

Group: 1, 2

Verdict: ACCEPTED

Test 11

Group: 2

Verdict: ACCEPTED

Test 12

Group: 2

Verdict: ACCEPTED

Test 13

Group: 2

Verdict: ACCEPTED

Test 14

Group: 2

Verdict: ACCEPTED

Test 15

Group: 2

Verdict: ACCEPTED

Test 16

Group: 2

Verdict: ACCEPTED

Test 17

Group: 2

Verdict: ACCEPTED

Test 18

Group: 2

Verdict: ACCEPTED

Test 19

Group: 2

Verdict: ACCEPTED

Test 20

Group: 2

Verdict: ACCEPTED

Test 21

Group: 2

Verdict: ACCEPTED

Test 22

Group: 2

Verdict: ACCEPTED

Test 23

Group: 2

Verdict: ACCEPTED

Test 24

Group: 2

Verdict: ACCEPTED

Test 25

Group: 2

Verdict: ACCEPTED

Test 26

Group: 2

Verdict: ACCEPTED

Test 27

Group: 2

Verdict: ACCEPTED

Test 28

Group: 2

Verdict: ACCEPTED

Test 29

Group: 2

Verdict: ACCEPTED

Test 30

Group: 2

Verdict: ACCEPTED

Test 31

Group: 1, 2

Verdict: ACCEPTED