Desafio - Gincana no Acampamento - Ordenação e Filtros em JavaScript

 

Nas férias de Dezembro, várias escolas se organizam e levam seus alunos para um acampamento de férias por uma semana.

Nestes acampamentos os alunos são divididos em cabanas coletivos por gênero e idade, sempre com um adulto que, além de dormir com o grupo no cabana, também são responsáveis por criar e executar várias atividades, como por exemplo jogos, excursões, Gincanas Noturnas, etc.

No primeiro dia foi realizada uma gincana em que a atividade constituia em agrupar os alunos em um círculo (organizado no sentido anti-horário) do qual seriam retiradas uma a uma até que sobrasse apenas um aluno, que seria o vencedor.

No momento em que entra no círculo, cada aluno recebe uma pequena ficha que contém um valor de 1 a 500.

Depois que o círculo é formado, conta-se, iniciando no aluno que está ao lado da primeira que entrou no círculo, o número correspondente à ficha que o primeiro detém. O aluno onde o número contado cair, deve ser retirado do grupo, e a contagem inicia novamente segundo a ficha do aluno que acabou de ser eliminado.

Para ficar mais interessante, quando o valor que consta na ficha é par, a contagem é feita no sentido horário e quando o valor que consta na ficha é ímpar, a contagem é feita no sentido anti-horário.

Desenvolva um programa para que no próximo evento o responsável pela brincadeira saiba previamente qual criança irá ser a vencedora de cada grupo, com base nas informações fornecidas.

//### Entrada

A entrada contém vários casos de teste.

A primeira linha de cada caso de teste contém um inteiro N (1 ≤ N ≤ 100), indicando a quantidade de alunos que farão parte de cada círculo.

Em seguida, as N linhas de cada caso de teste conterão duas informações, o Nome e o Valor (1 ≤ Valor ≤ 500) que consta na ficha de cada aluno, separados por um espaço, na ordem de entrada na formação do círculo inicial.

OBS: O Nome de cada aluno não deverá ultrapassar 30 caracteres e contém apenas letras maiúsculas e minúsculas, sem acentos, e o caractere “_”. O final da entrada é indicado pelo número zero.

//### Saída

Para cada caso de teste, deve-se apresentar a mensagem Vencedor(a): xxxxxx, com um espaço após o sinal ":" indicando qual é o aluno do grupo que venceu a brincadeira.

|--------------------------------------------|

| Exemplo de Entrada | Exemplo de Saída |

|--------------------|-----------------------|

| 3 | Vencedor(a): Fernanda |

| Fernanda 7 | |

| Fernando 9 | |

| Gustavo 11 | |

|--------------------|-----------------------|

| 5 | Vencedor(a): Pedro |

| Maria 7 | |

| Pedro 9 | |

| Joao_Vitor 5 | |

| Isabel 12 | |

| Laura 8 | |

|--------------------|-----------------------|

| 3 | Vencedor(a): Pedro |

| Maria 4 | |

| Pedro 3 | |

| Joao 2 | |

| 0 | |

|--------------------------------------------|

*/

//Código do desafio:

const inputs = [//para uso local

'3',

'Fernanda 7',

'Fernando 9',

'Gustavo 11',

'5',

'Maria 7',

'Pedro 9',

'Joao_Vitor 5',

'Isabel 12',

'Laura 8',

'3',

'Maria 4',

'Pedro 3',

'Joao 2',

'0',

]

let n = 0; //para uso local

while (true) {

// let nStudents = parseInt(gets());//para uso na DIO

let nStudents = parseInt(inputs[n++]); //para uso local

if (nStudents === 0) break;

if (nStudents < 1 || nStudents > 100) {

n += nStudents //para uso local

continue;

}

let students = [];

let i = 0;

while (i < nStudents) {

// let input = gets();//para uso na DIO

let input = inputs[n++];//para uso local

let [name, value] = input.split(' ');

i++;

if (!(name.match(/^[A-Za-z_]{1,30}$/)) || !(1 <= value && value <= 500)) {

// console.log(`Entrada do Aluno ${name} com valor ${value} é inválida.`)

continue;

}

students = [...students, { name, value }]

}

let winner = whoIsChampion(students);

console.log(`Vencedor(a): ${winner}`);

}

function whoIsChampion(group, index = 0, removed = {}) {

if (group.length === 1) return group[0].name;

let nextIndex = undefined;

let studentNumber = parseInt(removed.value) || parseInt(group[index].value);

(studentNumber % 2 === 0) ? studentNumber *= -1 : studentNumber *= 1;

const indexToRemove = crawlArray(group, index, studentNumber);

[removed] = group.splice(indexToRemove, 1);

if (removed.value % 2 === 0) {

nextIndex = (indexToRemove > group.length - 1)

? 0

: indexToRemove;

}

else {

nextIndex = (indexToRemove > group.length - 1)

? group.length - 1

: indexToRemove - 1;

}

return whoIsChampion(group, nextIndex, removed);

}

function crawlArray(array, index, n) {

return ((index + n) % array.length + array.length) % array.length;

}

//### Desafio - Gincana no Acampamento

Desafio - Fila do Banco - Ordenação e Filtros em JavaScript

 

O banco que você trabalha sempre tem problemas para organizar as filas de atendimento dos clientes.

Após uma reunião com a gerência ficou decidido que os clientes ao chegar na agência receberão uma senha numérica em seu aparelho de celular via sms e que a ordem da fila será dada não pela ordem de chegada, mas sim pelo número recebido via sms.

Sendo, aqueles com número maior deverão ser atendidos primeiro.

Então, dada a ordem de chegada dos clientes reordene a fila de acordo com o número recebido via sms, e diga quantos clientes não precisaram trocar de lugar nessa reordenação.

//### Entrada

A primeira linha contém um inteiro N, indicando o número de casos de teste a seguir.

Cada caso de teste inicia com um inteiro M (1 ≤ M ≤ 1000), indicando o número de clientes.

Em seguida haverá M inteiros distintos Pi (1 ≤ Pi ≤ 1000), onde o i-ésimo inteiro indica o número recebido via sms do i-ésimo cliente.

Os inteiros acima são dados em ordem de chegada, ou seja, o primeiro inteiro diz respeito ao primeiro cliente a chegar na fila, o segundo inteiro diz respeito ao segundo cliente, e assim sucessivamente.

//### Saída

Para cada caso de teste imprima uma linha, contendo um inteiro, indicando o número de clientes que não precisaram trocar de lugar mesmo após a fila ser reordenada.

|---------------------------------------|

| Exemplo de Entrada | Exemplo de Saída |

|--------------------|------------------|

| 3 | 1 |

| 3 | 0 |

| 100 80 90 | 4 |

| 4 | |

| 100 120 30 50 | |

| 4 | |

| 100 90 30 25 | |

|---------------------------------------|

*/

//Código do desafio:

const inputs = [ //para uso local

'3',

'3',

'100 80 90',

'4',

'100 120 30 50',

'4',

'100 90 30 ',

]//para uso local

let i = 0 //para uso local

// const nCasos = parseInt(gets()); //para uso na DIO

const nCasos = parseInt(inputs[i++]); //para uso local

let nClientes = [];

let senhas = [];

for (let n = 0; n < nCasos; n++) {

// nClientes[n] = parseInt(gets()); //para uso na DIO

nClientes[n] = parseInt(inputs[i++]);

// senhas[n] = gets().split(' '); //para uso na DIO

senhas[n] = inputs[i++].split(' '); //para uso local

let senhasOrdenadas = Array.from(senhas[n]).sort((a, b) => b - a);

let contadorSemTroca = 0;

for (let i = 0; i < senhas[n].length; i++) {

senhas[n][i] === senhasOrdenadas[i] && (contadorSemTroca++);

}

console.log(contadorSemTroca);

}

//### Desafio - Fila do Banco

Desafio - Uniformes de final de ano - Ordenação e Filtros em JavaScript

//### Desafio - Uniformes de final de ano

O professor Girafales organizou a confecção de um uniforme para as turmas da escola para comemorar o final do ano.

Após algumas conversas, ficou decidido com os alunos que eles poderiam escolher a cor do uniforme entre branco ou vermelho.

Assim sendo, Girafales precisa de sua ajuda para organizar as listas de quem quer o uniforme em cada uma das turmas, relacionando estas camisetas pela cor, tamanho (P, M ou G) e por último pelo nome.

//### Entrada

Cada caso de teste inicia com um valor N, (1 ≤ N ≤ 60) inteiro e positivo, que indica a quantidade de uniformes a serem feitas para aquela turma.

As próximas N*2 linhas contém informações de cada um dos uniformes (serão duas linhas de informação para cada uniforme).

A primeira linha irá conter o nome do estudante e a segunda linha irá conter a cor do uniforme ("branco" ou "vermelho") seguido por um espaço e pelo tamanho do uniforme "P" "M" ou "G".

A entrada termina quando o valor de N for igual a zero (0) e esta valor não deverá ser processado.

//### Saída

Para cada caso de entrada deverão ser impressas as informações ordenadas pela cor em ordem ascendente, seguido pelos tamanhos em ordem descendente e por último por ordem ascendente de nome, conforme o exemplo abaixo.

|----------------------------------------------------|

| Exemplo de Entrada | Exemplo de Saída |

|--------------------|-------------------------------|

| 9 | branco P Cezar Torres Mo |

| Maria Jose | branco P Maria Jose |

| branco P | branco M JuJu Mentina |

| Mangojata Mancuda | branco G Adabi Finho |

| vermelho P | branco G Severina Rigudinha |

| Cezar Torres Mo | vermelho P Amaro Dinha |

| branco P | vermelho P Baka Lhau |

| Baka Lhau | vermelho P Carlos Chade Losna |

| vermelho P | vermelho P Mangojata Mancuda |

| JuJu Mentina | |

| branco M | |

| Amaro Dinha | |

| vermelho P | |

| Adabi Finho | |

| branco G | |

| Severina Rigudinha | |

| branco G | |

| Carlos Chade Losna | |

| vermelho P | |

| 0 | |

|----------------------------------------------------|

*/

//Código do desafio:

const inputs = [ //para uso local

'9',

'Maria Jose',

'branco P',

'Mangojata Mancuda',

'vermelho P',

'Cezar Torres Mo',

'branco P',

'Baka Lhau',

'vermelho P',

'JuJu Mentina',

'branco M',

'Amaro Dinha',

'vermelho P',

'Adabi Finho',

'branco G',

'Severina ',

'branco G',

'Carlos Chade ',

'vermelho P',

'0'

] //para uso local

// const nUniformes = parseInt(gets()); //para uso na DIO

const nUniformes = parseInt(inputs[0]); //para uso local

let i = 1; //para uso local

let alunos = [];

while (true) {

// let nome = gets(); //para uso na DIO

let nome = inputs[i++]; //para uso local

if (parseInt(nome) === 0) break;

// let [cor, tamanho] = gets().split(' '); //para uso na DIO

let [cor, tamanho] = inputs[i++].split(' '); //para uso local

alunos = [...alunos, { nome, cor, tamanho }]

}

alunos

.sort((a, b) => {

for (let [testCase, sortCase] of [

[a.cor > b.cor, 1],

[a.cor < b.cor, -1],

[a.tamanho > b.tamanho, -1],

[a.tamanho < b.tamanho, 1],

[a.nome > b.nome, 1],

[a.nome < b.nome, -1],

]) {

if (testCase) return sortCase;

}

})

alunos.map(({ nome, cor, tamanho }) => {

console.log(`${cor} ${tamanho} ${nome}`);

})

/*