Desafio - Produto e divisão - 6-7 - Solução de Problemas com JavaScript

 

//### Desafio - Produto e divisão

Você tem a obrigação de testar as calculadores, para que façam apenas operações de multiplicação e divisão.

Além disso, o termo a ser digitado em cada operação, (o número exibido no visor que será dividido ou multiplicado), só pode conter um

único dígito.

Quando ligada, a calculadora exibe o número 1. Após isso, o usuário pode digitar um número com um único dígito e escolher se esse número

deve multiplicar ou dividir o número exibido anteriormente; o resultado da operação escolhida é então exibido na calculadora.

Pode-se repetir esse processo quantas vezes quiser.

Apesar de ser permitido apenas números inteiros de um dígito, a calculadora permite exibir números com múltiplos dígitos e até mesmo números

fracionários.

Apresentada a sequência de operações realizadas logo depois de ligada, seu objetivo é conferir o resultado exibido.

No primeiro caso de teste abaixo, o usuário deseja calcular o resultado da seguinte expressão: 1 × 2 × 1 × 3. Note que a primeira ocorrência do número 1 vem do fato da calculadora mostrar inicialmente 1 ao invés de 0.

No segundo caso de teste abaixo, o usuário deseja calcular o resultado da seguinte expressão: ((1/2)/3) × 6.

//### Entrada

A primeira e única linha da entrada contém um inteiro N (1 ≤ N ≤ 100 000). Cada uma das próximas N linhas contém um dígito e um caractere '*'

ou '/', que representam uma operação realizada na calculadora.

//### Saída

O programa deve imprimir uma única linha contendo o resultado que deve ser exibido pela calculadora ao final de todas as operações.

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

| Exemplo de Entrada | Exemplo de Saída |

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

| 3 | 6 |

| 2 * | |

| 1 * | |

| 3 * | |

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

| 3 | 1 |

| 2 / | |

| 3 / | |

| 6 * | |

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

| 11 | 387420489 |

| 9 * | |

| 9 * | |

| 9 * | |

| 9 * | |

| 9 * | |

| 9 * | |

| 9 * | |

| 9 * | |

| 9 * | |

| 9 * | |

| 9 / | |

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

*/

//Código do desafio:

const inputs = [ //para uso local

'3',

'2 *',

'1 *',

'3 *',

'3',

'2 /',

'3 /',

'6 *',

'11',

'9 *',

'9 *',

'9 *',

'9 *',

'9 *',

'9 *',

'9 *',

'9 *',

'9 *',

'9 *',

'9 /',

] //para uso local

let i = 0 //para uso local

let input, number1, number2, operator, result;

const regexInput = /^([0-9]) *([*/])/

const doMath = {

'/': (a, b) => {

a = Number(a)

b = Number(b)

return parseFloat(a / b)

},

'*': (a, b) => {

if (Number(a) * Number(b) >= Number.MAX_SAFE_INTEGER) {

a = BigInt(a)

b = BigInt(b)

return a * b

}

return a * b

}

}

while (true) {

number1 = 1

number2 = undefined

result = undefined

input = undefined

operator = undefined

// nOperators = parseInt(gets()) //para uso na DIO

nOperators = parseInt(inputs[i++]) //para uso local

if (!nOperators || nOperators === '' || nOperators < 1 || nOperators > 100000) break;

for (let index = 0; index < nOperators; index++) {

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

input = inputs[i++]; //para uso local

if (!input.match(regexInput)) continue;

[str, number2, operator] = input.match(regexInput);

if (number2 === undefined || (number2 == 0 && operator === '/')) continue;

result = doMath[operator](number1, number2)

number1 = result

}

if (result === undefined) { console.log(number1); continue; }

console.log(typeof result == 'bigint' ? result.toString() : parseInt(result))

}

/*

Desafio - Conjuntos bons ou ruins? - 5-7 - Solução de Problemas com JavaScript

 

//### Desafio - Conjuntos bons ou ruins?

Nesse algoritmo você deverá descobrir se um conjunto de palavras é bom ou ruim. Por definição, um conjunto é bom quando nenhuma palavra

desse conjunto é um prefixo de outra palavra. Caso contrário, é considerado um conjunto ruim.

Por exemplo, {dbc, dae, dbcde} é um conjunto ruim, pois dbc é um prefixo de dbcde. Quando duas palavras são idênticas, definimos como uma

sendo prefixo da outra.

//### Entrada

A entrada contém vários casos de teste. A primeira linha de cada caso de teste terá um inteiro N (1 ≤ N ≤ 10⁵), que representa a quantidade

de palavras no conjunto. Segue então N linhas, cada uma tendo uma palavra de no máximo 100 letras minúsculas. A entrada termina quando

N = 0 e não deve ser processada.

//### Saída

Para cada caso de teste, você deverá imprimir "Conjunto Bom", ou "Conjunto Ruim", conforme explicado acima.

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

| Exemplo de Entrada | Exemplo de Saída |

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

| 3 | Conjunto Ruim |

| abc | |

| dae | |

| abcde | |

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

| 2 | Conjunto Bom |

| abc | |

| def | |

| 0 | |

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

*/

//Código do desafio:

const inputs = [

'3',

'abc',

'dae',

'abcde',

'2',

'abc',

'def',

'3',

'dbc',

'dae',

'dbcde',

'3',

'abcd',

'def',

'abcd',

'0'

]

let i = 0; //para uso local

let N;

const limit = Math.pow(10, 5);

let words, isBad;

while (true) {

words = []

// N = parseInt(gets()) //para uso na DIO

N = parseInt(inputs[i]) //para uso local

if (N === 0 || (N < 1 || N > limit)) break;

for (let index = 0; index < N; index++) {

// word = gets() //para uso na DIO

word = inputs[++i] //para uso local

if (!(/^[a-z]{1,100}$/g.test(word))) continue; //skip invalid word

words = [...words, word]

}

isBad = words.some((currentWord, i, words) => {

const pattern = new RegExp(`^(${currentWord}).+`)

for (const word of words) {

if (pattern.test(word)) return true

}

const same = words.reduce((total, w) => {

total += w === currentWord ? 1 : 0

return total

}, 0)

return same > 1;

})

console.log(isBad ? 'Conjunto Ruim' : 'Conjunto Bom');

i++ //para uso local

}

/*