// encrypted_input = 'NÃOENTREEMPANICO / 3'
function decode_message(encrypted_input) {
  // função pra gerar os array's de carácteres
  const generateLines = num => {
    let lines = []

    for (let i = 0; i < num; i++) {
      lines.push([])
    }

    return lines
  }

  // informações passadas no input
  const message = encrypted_input.split(" / ")[0].split("") // frase: NÃOENTREEMPANICO
  const lines = encrypted_input.split(" / ")[1] // número de linhas: 3

  // array de linhas
  const linesArray = generateLines(lines)

  // aqui tem algumas variáveis que ajudam na lógica da solução
  let lastWrite = null // variável usada preu saber qual foi a última linha que teve uma letra adicionada
  let lineToWrite = null // variável preu saber em qual linha eu vou escrever a letra agora
  let signal = "plus" // variável preu saber se preciso "subir" ou "descer" pelas linhas

  // enquanto o message tiver caracteres esse código vai ser executado
  while (message.length > 0) {
    // se a variável que informa qual foi a última linha que teve uma letra inserida estiver como NULL significa que estamos escrevebdo a primeira letra
    if (lastWrite === null) {
      // então a linha em que preciso escrever a primeira letra da frase com certeza é a linha 0
      lineToWrite = 0
    } else {
      // agora que a lastWrite está preenchida preciso criar uma lógica pra construir a mensagem criptografada

      // variável onde salvo qual é o número da linha que precisa ter a letra inserida nessa iteração do while
      let newLineToWrite = null

      // antes de definir a variável newLineToWrite preciso saber se estamos descendo na linha (+) ou se estamos subindo (-) pra então definir a linha correta
      if (signal === "plus") {
        // aqui estamos descendo
        newLineToWrite = lineToWrite + 1
      } else {
        // aqui estamos subindo
        newLineToWrite = lineToWrite - 1
      }

      // aqui verificamos se estamos na última ou na primeira linha, se estivermos em uma das duas precisamos mudar a variável signal e então inverter a nossa direção de escrita
      if (newLineToWrite + 1 === linesArray.length || newLineToWrite === 0) {
        signal =
          signal === "plus" // se a variável signal esta como plus então estamos descendo na linha
            ? "minus" // por isso mudamos ela pra minus, assim eu sei que precisamos começar a subir pelas linhas
            : "plus" // se a signal está como minus mudamos ela pra plus de novo e voltamos a descer pelas linhas
      }

      // e aqui definimos qual linha deve ter a letra escrita dessa vez
      lineToWrite = newLineToWrite
    }

    // nesse for passamos por todas as linhas que criamos lá no início da nossa função
    for (let i = 0; i < linesArray.length; i++) {
      // validamos se a linha atual dessa iteração é igual a linha que devemos escrever a letra atual
      if (i === lineToWrite) {
        // se for a linha certa pegamos a primeira letra da variável onde está nossa mensagem original e adicionamos ela a essa linha
        linesArray[i].push(message[0])
      } else {
        // se não for a linha que deve ter a letra escrita então simplesmente adicionamos um ponto nela
        linesArray[i].push(".")
      }
    }

    // aqui marcamos qual linha foi escrita agora
    lastWrite = lineToWrite

    // e removemos a primeira letra da variável message, afinal ela já foi adicionada na linha correta
    message.shift()
  }

  let encryptedMessageWithLines = ""

  // depois de finalizar todo o array de linhas e carácteres eu passo por cada linha transformando ela em uma string
  for (let i = 0; i < linesArray.length; i++) {
    // pego a linha atual e junto os carácteres que estavam separados num array transformando essa linha em uma string
    const stringLine = linesArray[i].join("")

    const firstLine = stringLine

    // aqui eu tô só adicionando uma quebra de linha entre a linha existente na mensagem criptograda e a nova linha a ser adicionada
    const otherLines = `${encryptedMessageWithLines}\n${stringLine}`

    // a mensagem final criptografada começa a ser construída aqui:
    encryptedMessageWithLines = encryptedMessageWithLines
      ? otherLines // se essa variável encryptedMessageWithLines não estiver vazia eu adiciono a variável que juntou o valor atual da encryptedMessageWithLines + a linha atual
      : firstLine // se a encryptedMessageWithLines está vazia então eu só preciso adicionar a primeira linha (que é simplesmente a linha atual da iteração)

    // a variável encryptedMessageWithLines fica assim:
    // N...N...E...N...
    // .Ã.E.T.E.M.A.I.O
    // ..O...R...P...C.
  }

  // aqui eu tô gerando a mensagem criptografada que é esperada, tô removendo daquela string todas as quebras de linha e os pontos entre as letras
  let encryptedFinalMessage = encryptedMessageWithLines
    .replace(/\n/g, "") // remove as quebras de linha (/n)
    .replace(/\./g, "") // remove os pontos (.)

  // e por fim eu retorno a mensagem criptografada: NNENÃETEMAIOORPC
  return encryptedFinalMessage
}