Exercicios de Analise e Desenvolvimento de Sistemas

Programando com JS 2 / 5 - Resto 2

Desafio

Leia um valor inteiro N. Apresente todos os números entre 1 e 10000 que divididos por N dão resto igual a 2.

Entrada

A entrada contém um valor inteiro N (N < 10000).

Saída

Imprima todos valores que quando divididos por N dão resto = 2, um por linha.

Exemplo de Entrada	Exemplo de Saída
13	2 15 28 41 ...

let lines = gets().split('\n'); let N = parseInt(lines.shift()); for (let i = 1; i<10000;i++) { if (i%N==2) print(i); }

faço trabalhos avulsos de programação em php , javascript , html , VBA-EXCEL e EXCEL formulas avançadas . pode entrar em contato no whatsapp 83988596239. nós combinaremos os valores de acordo com a demanda.

Programando com JS 1 / 5 - Quadrado de Pares

Leia um valor inteiro N. Apresente o quadrado de cada um dos valores pares, de 1 até N, inclusive N, se for o caso.

Entrada

A entrada contém um valor inteiro N (5 < N < 2000).

Saída

Imprima o quadrado de cada um dos valores pares, de 1 até N, conforme o exemplo abaixo.

Tome cuidado! Algumas linguagens tem por padrão apresentarem como saída 1e+006 ao invés de 1000000 o que ocasionará resposta errada. Neste caso, configure a precisão adequadamente para que isso não ocorra.

Exemplo de Entrada	Exemplo de Saída
6	2^2 = 4 4^2 = 16 6^2 = 36

Exemplo de Entrada

Exemplo de Saída

2^2 = 4
4^2 = 16
6^2 = 36

let lines = gets().split('\n');

var N = parseInt(lines.shift());
for (let i=2; i<=N; i=i+2) {

if (i % 2 == 0) print(i+"^2 = "+i*i);
}

Resolvendo Algoritmos com JavaScript 5 / 5 - O tabuleiro secreto

Desafio

O senhor Milli, morador da cidade Petland, é o famoso proprietário da maior fábrica de jogos de tabuleiros do mundo.

Recentemente, ele teve a ideia de lançar um novo jogo exclusivo de tabuleiro, que ele apelidou de Tabuleiro da Frequência.

O jogo ocorre da seguinte forma. Inicialmente, um tabuleiro com dimensões N × N é dado contendo apenas 0’s. Depois disso, Q operações são propostas, podendo ser de 4 tipos:

1 X R: Atribuir o valor R a todos os números da linha X;
2 X R: Atribuir o valor R a todos os números da coluna X;
3 X: Imprimir o valor mais frequente na linha X;
4 X: Imprimir o valor mais frequente da coluna X.

Milli não é muito bom com computadores, mas é bastante preguiçoso. Sabendo que você é um dos melhores programadores do mundo, ele precisa sua ajuda para resolver este problema.

Entrada

A primeira linha da entrada é composta por dois inteiros N e Q (1 ≤ N, Q ≤ 105), representando, respectivamente, o tamanho do tabuleiro e a quantidade de operações. As próximas Q linhas da entrada vão conter as Q operações. O primeiro inteiro de cada linha vai indicar o tipo da operação. Caso seja 1 ou 2, será seguido por mais dois inteiros X (1 ≤ X ≤ N) e R (0 ≤ R ≤ 50). Caso seja 3 ou 4, será seguido por apenas mais um inteiro X.

Saída

Para cada operação do tipo 3 ou 4, seu programa deve produzir uma linha, contendo o valor da resposta correspondente. Se uma linha ou coluna tiver dois ou mais valores que se repetem o mesmo número de vezes, você deve imprimir o maior deles. Por exemplo, se uma linha tem os valores [5,7,7,2,5,2,1,3], tanto o 2, 5 e 7 se repetem duas vezes, então a resposta será 7, pois é o maior deles.

-------------------------------------------------------------------------------------------------------

let input;
const limit = Math.pow(10, 5);
let T, X, R;
var output = '';

const operation = {
'1': function fillLine(matrix, line, num) {
    for (let index = 0; index < matrix.length; index++) {
      matrix[line - 1][index] = num;
    }
},
'2': function fillColumn(matrix, col, num) {
    for (let index = 0; index < matrix.length; index++) {
      matrix[index][col - 1] = num;
    }
},
'3': function showMostFrequentAtLine(matrix, line) {
    const lineValues = matrix[line - 1]

    output += getMostFrequentIn(lineValues) + '\n'
},
'4': function showMostFrequentAtColumn(matrix, col) {
    const columnValues = matrix.map(line => line[col - 1])

    output += getMostFrequentIn(columnValues) + '\n'
}
}

const getMostFrequentIn = (values) => {

let n = values.length;

if (n == 0) return null;

let map = {}, most = values[0], freqCount = 1;

for (let i = 0; i < n; i++) {
    let el = values[i];

    if (map[el] == null)
      map[el] = 1;
    else
      map[el]++;

    if (map[el] > freqCount) {
      most = el;
      freqCount = map[el];
    }
    else if (map[el] === freqCount) {
      most = Math.max(most, el)
    }
}
return most;
}

while (true) {
   input = gets()

if (!input || input === '') break;

let [N, Q] = input.match(/\d+/g);

N = parseInt(N);
Q = parseInt(Q);

if (N < 1 || N > limit || Q < 1 || N > limit) break;

let matrix = Array.from(Array(parseInt(N)), () => new Array(parseInt(N)).fill(0));

for (let index = 0; index < Q; index++) {
     let [T, X, R] = gets().split(/[ ]+/g) //para uso na DIO
    X = parseInt(X)
    R = parseInt(R)

    if (/[12]/.test(T)) {
      if (X < 1 || X > N || R < 0 || R > 50) {
        // console.log('Valores de X e/ou N inválidos para operação 1 ou 2. Verifique antes de iniciar o jogo');
        continue;
      }
    }

    if (/[34]/.test(T)) {
      if (X > N || X < 0) {
        // console.log('Valores de X e/ou N inválidos para operação 3 ou 4. Verifique antes de iniciar o jogo');
        continue;
      }
    }

    operation[T](matrix, X, R);
}
console.log(output);
}

Resolvendo Algoritmos com JavaScript 4 / 5 - Hash Mágico

Desafio

O conceito de hash é transformar uma grande quantidade de dados em uma pequena quantidade de informações. Nesse algoritmo você terá uma entrada com várias linhas, cada uma com uma string.

O valor de cada caracter é computado como segue:

Valor = (Posição no alfabeto) + (Elemento de entrada) + (Posição do elemento)

As posições iniciam em zero. 'A' tem posição 0 no alfabeto, ‘C' tem posição 2 no alfabeto, ... O cálculo de hash retornado é a soma de todos os caracteres da entrada. Por exemplo, se a entrada for:

CBA

DDD

então cada caractere deverá ser computado como segue:

2 = 2 + 0 + 0 : 'C' no elemento 0 posição 0

2 = 1 + 0 + 1 : 'B' no elemento 0 posição 1

2 = 0 + 0 + 2 : 'A' no elemento 0 posição 2

4 = 3 + 1 + 0 : 'D' no elemento 1 posição 0

5 = 3 + 1 + 1 : 'D' no elemento 1 posição 1

6 = 3 + 1 + 2 : 'D' no elemento 1 posição 2

O cálculo final de hash será 2+2+2+4+5+6 = 21.

Entrada

A entrada contém vários casos de teste. A primeira linha de entrada contém um inteiro N que indica a quantidade de casos de teste. Cada caso de teste inicia com um inteiro L (1 ≤ L ≤ 100) que indica a quantidade de linhas que vem a seguir. Cada uma destas L linhas contém uma string com até 50 letras maiúsculas ('A' - 'Z').

Saída

Para cada caso de teste imprima o valor de hash que é calculado conforme o exemplo apresentado acima.

------------------------------------------------------------------------------------------------------------

Resolvendo Algoritmos com JavaScript 3 / 5 - Combinação de strings

Desafio

Crie um algoritmo que receba dois inputs que sejam strings e combine-as alternando as letras de cada string.

Deve começar pela primeira letra da primeira string, seguido pela primeira letra da segunda string, em seguida pela segunda letra da primeira string e continuar dessa forma sucessivamente.

As letras restantes da cadeia mais longa devem ser adicionadas ao fim da string resultante e retornada.

Entrada

A entrada contém vários casos de teste. A primeira linha contém um inteiro N que indica a quantidade de casos de teste que vem a seguir. Cada caso de teste é composto por uma linha que contém duas cadeias de caracteres, cada cadeia de caracteres contém entre 1 e 50 caracteres inclusive.

Saída

Combine as duas cadeias de caracteres da entrada como mostrado no exemplo abaixo e exiba a cadeia resultante.

--------------------------------------------------------------------------------------------------

Resolvendo Algoritmos com JavaScript 2 / 5 - Abreviando posts do blog

Desafio

Leonardo é um nômade digital e viaja pelo mundo programando em diferentes cafés das cidades por onde passa. Recentemente, resolveu criar um blog, para compartilhar suas experiências e aprendizados com seus amigos.

Para criação do blog, ele optou por utilizar uma ferramenta pronta, que há um limite de caracteres que se pode escrever por dia, e Leonardo está preocupado que essa limitação, afinal, irá impedir de contar suas melhores experiências. Para contornar esse problema, decidiu usar um sistema de abreviação de palavras em seus posts.

O sistema de abreviações é simples e funciona da seguinte forma: para cada letra, é possível escolher uma palavra que inicia com tal letra e que aparece no post. Uma vez escolhida a palavra, sempre que ela aparecer no post, ela será substituída por sua letra inicial e um ponto, diminuindo assim o número de caracteres impressos na tela.

Por exemplo, na frase: “hoje eu programei em Python”, podemos escolher a palavra “programei” para representar a letra ‘p', e a frase ficará assim: “hoje eu p. em Python”, economizando assim sete caracteres. Uma mesma palavra pode aparecer mais de uma vez no texto, e será abreviada todas as vezes. Note que, se após uma abreviação o número de caracteres não diminuir, ela não deve ser usada, tal como no caso da palavra “eu” acima.

Leonardo precisa que seu post tenha o menor número de caracteres possíveis, e por isso pediu a sua ajuda. Para cada letra, escolha uma palavra, de modo que ao serem aplicadas todas as abreviações, o texto contenha o menor número de caracteres possíveis.

Entrada

Haverá diversos casos de teste. Cada caso de teste é composto de uma linha, contendo uma frase de até 10⁴ caracteres. A frase é composta de palavras e espaços em branco, e cada palavra é composta de letras minúsculas ('a'-'z'), e contém entre 1 e 30 caracteres cada.

O último caso de teste é indicado quando a linha dada conter apenas um “.”, o qual não deverá ser processado.

Saída

Para cada caso de teste, imprima uma linha contendo a frase já com as abreviações escolhidas e aplicadas.

Em seguida, imprima um inteiro N, indicando o número de palavras em que foram escolhidas uma letra para a abreviação no texto. Nas próximas N linhas, imprima o seguinte padrão “C. = P”, onde C é a letra inicial e P é a palavra escolhida para tal letra. As linhas devem ser impressas em ordem crescente da letra inicial.

------------------------------------------------------------------------------------------------------------

const regexPattern = /\b[a-z]{1,30}\b/g
const alphabet = 'abcdefghijklmnopqrstuvwxyz'

while (true) {
  let newSentence = ''
   const input = gets() //para uso na DIO
  
  if (!input || input === '.') break;

  if (input.length > Math.pow(10, 4)) continue;

  const sentence = input.trim().match(regexPattern)
  const uniqueWords = Array.from(new Set(sentence));

  const words = uniqueWords.map(word => {
    const repeatations = sentence.join(' ').match(new RegExp(`\\b${word}\\b`, 'g')).length;
    const trim = word.length - 2
    const save = trim * repeatations
    const abbreviation = `${word[0]}.`
    const legend = `${abbreviation} = ${word}`
    const regexp = new RegExp(`\\b${word}\\b`, 'g')
    return { word, repeatations, trim, save, abbreviation, legend, regexp }
  }).filter(word => word.save > 0)

  const abbreviations = alphabet.split('').map(letter => {
    candidates = words.filter(word => word.word.match(new RegExp(`\\b${letter}\\w{2,}\\b`, 'g')))

    if (!candidates || candidates === null) return { save: 0 }

    return candidates.reduce((acc, curr) => {
      return curr.save >= acc.save
        ? curr
        : acc

    }, { save: 0 });

  }).filter(el => el.save > 0)

  newSentence = input
  for (const abbr of abbreviations) {
    newSentence = newSentence.replace(abbr.regexp, abbr.abbreviation)
  }

  //Output
  console.log(newSentence);
  console.log(abbreviations.length);
  abbreviations.sort().map(({ legend }) => console.log(legend))
}

Resolvendo Algoritmos com JavaScript 1 / 5 - Coração das cartas

Desafio

Marcos decidiu abandonar o bar da faculdade onde jogava truco para dedicar-se ao mundo da programação. Para que isso fosse mais fácil, decidiu criar um novo jogo de cartas.

O coração das cartas, como Marcos apelidou o jogo, é individual e jogado com três pilhas, inicialmente com o mesmo número de cartas. Cada carta tem um valor numérico inteiro de 0 até 9. O jogador pode, a qualquer momento ver o valor de qualquer carta, mas só pode jogar com as cartas que estão no topo das pilhas. Em cada rodada, o jogador pode remover qualquer combinação de cartas que estejam no topo da pilha (pode escolher 1, 2 ou até 3 cartas) cuja soma dos valores seja múltiplo de 3. O jogo é ganho quando todas as cartas forem removidas das pilhas. Se alguma carta não puder ser removida, perde-se o jogo.

Entrada

A entrada é composta por várias instâncias Cada instância é iniciada por um inteiro N (0 ≤ N ≤ 100), que identifica o número de cartas em cada pilha. A entrada termina quando N = 0. Cada uma das N linhas seguintes contém três inteiros A, B e C, que descrevem os valores numéricos das cartas em um nível da pilha (0 ≤ A, B, C ≤ 9). As pilhas são descritas do topo até o fundo.

Saída

Para cada instância, imprima uma linha contendo o número 1 se o jogador pode ganhar a instância do jogo ou o número 0 se o jogo for impossível.

-------------------------------------------------------------------------------------------------------------------------

let m, cards;
let n = 1;

while (true) {
   n = parseInt(gets());

if (n <= 0) break;

m = new Map();
cards = Array.from(new Array(3)).map(v => new Array(n));

for (let i = 0; i < n; i++) {
     [cards[0][i], cards[1][i], cards[2][i]] = gets().match(new RegExp(/\d+/, 'g')).map(v => parseInt(v));

}

console.log(canWinWith(0, 0, 0) ? 1 : 0);

}

function canWinWith(a, b, c) {
let s = '';

s = s.concat(a + '0');
s = s.concat(b + '0');
s = s.concat(c + '0');

if (a === b && b === c && c === n) {
    m.set(s, 1);
    return true;
}

let x = m.get(s);

if (x > 0) {
    return x === 1 ? true : false;
}

if (a < n && cards[0][a] % 3 === 0 && canWinWith(a + 1, b, c)) {
    m.set(s, 1);
    return true;
}

if (b < n && cards[1][b] % 3 === 0 && canWinWith(a, b + 1, c)) {
    m.set(s, 1);
    return true;
}

if (c < n && cards[2][c] % 3 === 0 && canWinWith(a, b, c + 1)) {
    m.set(s, 1);
    return true;
}

if (a < n && b < n && (cards[0][a] + cards[1][b]) % 3 == 0 && canWinWith(a + 1, b + 1, c)) {
    m[s] = 1;
    return true;
}

if (a < n && c < n && (cards[0][a] + cards[2][c]) % 3 == 0 && canWinWith(a + 1, b, c + 1)) {
    m.set(s, 1);
    return true;
}
if (b < n && c < n && (cards[1][b] + cards[2][c]) % 3 == 0 && canWinWith(a, b + 1, c + 1)) {
    m.set(s, 1);
    return true;
}

if (a < n && b < n && c < n && (cards[0][a] + cards[1][b] + cards[2][c]) % 3 == 0 && canWinWith(a + 1, b + 1, c + 1)) {
    m.set(s, 1);
    return true;
}

m.set(s, 2);
return false;
}