# 1258 - Camisetas

## Descrição

{% embed url="<https://www.urionlinejudge.com.br/judge/pt/problems/view/1258>" %}

## Solução

Veja a seção de [critérios customizados](/solucoes-da-beecrowd/base-teorica/estruturas-e-bibliotecas/ordenacao.md#customizacao-de-criterios) para entender como customizar a ordenação que está presente em bibliotecas da sua linguagem de programação.

{% hint style="danger" %}
Em Python, resolvi implementar um algoritmo de ordenação eficiente por não saber lidar com os critérios de ordenação tão específicos deste problema.
{% endhint %}

{% tabs %}
{% tab title="C99" %}

```c
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

struct Camiseta
{
    char nome[100], cor[10], tamanho[10];
};

int comp(const void *a, const void *b)
{
    struct Camiseta *cA = (struct Camiseta *)a;
    struct Camiseta *cB = (struct Camiseta *)b;

    if (strcmp(cA->cor, cB->cor) == 0)
    {
        if (strcmp(cA->tamanho, cB->tamanho) == 0)
        {
            return strcmp(cA->nome, cB->nome);
        }
        return -strcmp(cA->tamanho, cB->tamanho);
    }
    return strcmp(cA->cor, cB->cor);
}

int main()
{
    int N, first;
    struct Camiseta camisetas[60];

    first = 1;
    while (scanf("%d\n", &N))
    {
        if (!N)
            break;

        if (first)
            first = 0;
        else
            printf("\n");

        for (int i = 0; i < N; ++i)
        {
            scanf("%[^\n]\n", &(camisetas[i].nome));
            scanf("%s %s\n", &(camisetas[i].cor), &(camisetas[i].tamanho));
        }

        qsort(camisetas, N, sizeof(struct Camiseta), comp);

        for (int i = 0; i < N; ++i)
        {
            printf("%s %s %s\n", camisetas[i].cor, camisetas[i].tamanho, camisetas[i].nome);
        }
    }

    return 0;
}
```

{% endtab %}

{% tab title="C++17" %}

```cpp
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Camiseta
{
public:
    string nome, cor, tamanho;

    Camiseta()
    {
        nome = "";
        cor = "";
        tamanho = "";
    }

    Camiseta(string n, string c, string t)
    {
        nome = n;
        cor = c;
        tamanho = t;
    }
};

bool comp(Camiseta a, Camiseta b)
{
    if (a.cor == b.cor)
    {
        if (a.tamanho == b.tamanho)
        {
            return a.nome < b.nome;
        }
        return a.tamanho > b.tamanho;
    }
    return a.cor < b.cor;
}

int main()
{
    int N;
    bool first;
    vector<Camiseta> camisetas;

    first = true;
    while (cin >> N)
    {
        if (!N)
            break;
        cin.ignore();

        if (first)
            first = false;
        else
            cout << endl;

        camisetas.assign(N, Camiseta());
        for (int i = 0; i < N; ++i)
        {
            getline(cin, camisetas[i].nome);
            cin >> camisetas[i].cor >> camisetas[i].tamanho;
            cin.ignore();
        }

        sort(camisetas.begin(), camisetas.end(), comp);

        for (int i = 0; i < N; ++i)
        {
            cout << camisetas[i].cor << " " << camisetas[i].tamanho << " " << camisetas[i].nome << endl;
        }
    }

    return 0;
}
```

{% endtab %}

{% tab title="JavaScript 12.18" %}

```javascript
var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var lines = input.trim().split('\n');

lines.pop();

class Camiseta{
    constructor(n, c, t){
        this.nome = n;
        this.cor = c;
        this.tamanho = t;
    }
}

const comp = (a, b) => {
    if(a.cor === b.cor){
        if(a.tamanho === b.tamanho){
            if(a.nome < b.nome) return -1;
            if(a.nome > b.nome) return 1;
            return 0;
        }
        if(a.tamanho > b.tamanho)   return -1;
        return 1;
    }
    if(a.cor < b.cor)   return -1;
    return 1;
};

let first = true;
while(lines.length){
    let N = parseInt(lines.shift());

    if(first)
        first = false;
    else
        console.log("");

    let camisetas = [];
    for(let i = 0; i < N; ++i){
        let nome = lines.shift().trim();
        let [cor, tamanho] = lines.shift().trim().split(' ');

        camisetas.push(new Camiseta(nome, cor, tamanho));
    }

    camisetas.sort(comp);

    for(let i = 0; i < N; ++i){
        console.log(`${camisetas[i].cor} ${camisetas[i].tamanho} ${camisetas[i].nome}`);
    }
}#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Camiseta
{
public:
    string nome, cor, tamanho;

    Camiseta()
    {
        nome = "";
        cor = "";
        tamanho = "";
    }

    Camiseta(string n, string c, string t)
    {
        nome = n;
        cor = c;
        tamanho = t;
    }
};

bool comp(Camiseta a, Camiseta b)
{
    if (a.cor == b.cor)
    {
        if (a.tamanho == b.tamanho)
        {
            return a.nome < b.nome;
        }
        return a.tamanho > b.tamanho;
    }
    return a.cor < b.cor;
}

int main()
{
    int N;
    bool first;
    vector<Camiseta> camisetas;

    first = true;
    while (cin >> N)
    {
        if (!N)
            break;
        cin.ignore();

        if (first)
            first = false;
        else
            cout << endl;

        camisetas.assign(N, Camiseta());
        for (int i = 0; i < N; ++i)
        {
            getline(cin, camisetas[i].nome);
            cin >> camisetas[i].cor >> camisetas[i].tamanho;
            cin.ignore();
        }

        sort(camisetas.begin(), camisetas.end(), comp);

        for (int i = 0; i < N; ++i)
        {
            cout << camisetas[i].cor << " " << camisetas[i].tamanho << " " << camisetas[i].nome << endl;
        }
    }

    return 0;
}#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Camiseta
{
public:
    string nome, cor, tamanho;

    Camiseta()
    {
        nome = "";
        cor = "";
        tamanho = "";
    }

    Camiseta(string n, string c, string t)
    {
        nome = n;
        cor = c;
        tamanho = t;
    }
};

bool comp(Camiseta a, Camiseta b)
{
    if (a.cor == b.cor)
    {
        if (a.tamanho == b.tamanho)
        {
            return a.nome < b.nome;
        }
        return a.tamanho > b.tamanho;
    }
    return a.cor < b.cor;
}

int main()
{
    int N;
    bool first;
    vector<Camiseta> camisetas;

    first = true;
    while (cin >> N)
    {
        if (!N)
            break;
        cin.ignore();

        if (first)
            first = false;
        else
            cout << endl;

        camisetas.assign(N, Camiseta());
        for (int i = 0; i < N; ++i)
        {
            getline(cin, camisetas[i].nome);
            cin >> camisetas[i].cor >> camisetas[i].tamanho;
            cin.ignore();
        }

        sort(camisetas.begin(), camisetas.end(), comp);

        for (int i = 0; i < N; ++i)
        {
            cout << camisetas[i].cor << " " << camisetas[i].tamanho << " " << camisetas[i].nome << endl;
        }
    }

    return 0;
}#include <stdlib.h>
#include <string.h>
#include <stdio.h>

struct Camiseta
{
    char nome[100], cor[10], tamanho[10];
};

int comp(const void *a, const void *b)
{
    struct Camiseta *cA = (struct Camiseta *)a;
    struct Camiseta *cB = (struct Camiseta *)b;

    if (strcmp(cA->cor, cB->cor) == 0)
    {
        if (strcmp(cA->tamanho, cB->tamanho) == 0)
        {
            return strcmp(cA->nome, cB->nome);
        }
        return -strcmp(cA->tamanho, cB->tamanho);
    }
    return strcmp(cA->cor, cB->cor);
}

int main()
{
    int N, first;
    struct Camiseta camisetas[60];

    first = 1;
    while (scanf("%d\n", &N))
    {
        if (!N)
            break;

        if (first)
            first = 0;
        else
            printf("\n");

        for (int i = 0; i < N; ++i)
        {
            scanf("%[^\n]\n", &(camisetas[i].nome));
            scanf("%s %s\n", &(camisetas[i].cor), &(camisetas[i].tamanho));
        }

        qsort(camisetas, N, sizeof(struct Camiseta), comp);

        for (int i = 0; i < N; ++i)
        {
            printf("%s %s %s\n", camisetas[i].cor, camisetas[i].tamanho, camisetas[i].nome);
        }
    }

    return 0;
}#include <stdlib.h>
#include <string.h>
#include <stdio.h>

struct Camiseta
{
    char nome[100], cor[10], tamanho[10];
};

int comp(const void *a, const void *b)
{
    struct Camiseta *cA = (struct Camiseta *)a;
    struct Camiseta *cB = (struct Camiseta *)b;

    if (strcmp(cA->cor, cB->cor) == 0)
    {
        if (strcmp(cA->tamanho, cB->tamanho) == 0)
        {
            return strcmp(cA->nome, cB->nome);
        }
        return -strcmp(cA->tamanho, cB->tamanho);
    }
    return strcmp(cA->cor, cB->cor);
}

int main()
{
    int N, first;
    struct Camiseta camisetas[60];

    first = 1;
    while (scanf("%d\n", &N))
    {
        if (!N)
            break;

        if (first)
            first = 0;
        else
            printf("\n");

        for (int i = 0; i < N; ++i)
        {
            scanf("%[^\n]\n", &(camisetas[i].nome));
            scanf("%s %s\n", &(camisetas[i].cor), &(camisetas[i].tamanho));
        }

        qsort(camisetas, N, sizeof(struct Camiseta), comp);

        for (int i = 0; i < N; ++i)
        {
            printf("%s %s %s\n", camisetas[i].cor, camisetas[i].tamanho, camisetas[i].nome);
        }
    }

    return 0;
}
```

{% endtab %}

{% tab title="Python 3.9" %}

```python
class Camiseta:
    def __init__(self, n, c, t):
        self.nome = n
        self.cor = c
        self.tamanho = t


def comp(a, b):
    if(a.cor == b.cor):
        if(a.tamanho == b.tamanho):
            if(a.nome < b.nome):
                return -1
            if(a.nome > b.nome):
                return 1
            return 0
        if(a.tamanho > b.tamanho):
            return -1
        return 1
    if(a.cor < b.cor):
        return -1
    return 1


def particao(V, inicio, fim):
    pivo = V[fim - 1]
    i = inicio
    for j in range(inicio, fim):
        if(comp(V[j], pivo) < 0):
            V[j], V[i] = V[i], V[j]
            i += 1

    if(comp(pivo, V[i]) < 0):
        V[fim - 1], V[i] = V[i], V[fim - 1]

    return i


def quickSort(V, inicio, fim):
    if(fim > inicio):
        posicaoPivo = particao(V, inicio, fim)
        quickSort(V, inicio, posicaoPivo)
        quickSort(V, posicaoPivo + 1, fim)


first = True
while True:
    try:
        N = int(input())

        if(N == 0):
            break

        if(first):
            first = False
        else:
            print('')

        camisetas = []
        for _ in range(N):
            nome = input()
            cor, tamanho = input().strip().split(' ')

            camisetas.append(Camiseta(nome, cor, tamanho))

        quickSort(camisetas, 0, len(camisetas))

        for camiseta in camisetas:
            print(f'{camiseta.cor} {camiseta.tamanho} {camiseta.nome}')
    except EOFError:
        break

```

{% endtab %}
{% endtabs %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://xtecna.gitbook.io/solucoes-da-beecrowd/estruturas-e-bibliotecas/1258-camisetas.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.