Meu desafio anterior, Imprimir texto invisível, era bastante popular, provavelmente devido ao quão trivial é.

No entanto, aqueles mais atentos de vocês devem ter notado que não estão realmente imprimindo texto invisível, porque é impossível ler o que foi inserido, apenas a saída.

Então eu percebi que tal um verdadeiro desafio texto invisível.

Dada uma sequência que consiste apenas em caracteres ASCII imprimíveis ( 0x20-0x7E), converta cada caractere em um caractere Unicode distinto (na codificação UTF-8) que não seja um dos 95 caracteres ASCII imprimíveis (qualquer caractere UTF-8 fora do 0x20-0x7Eintervalo)

Entrada

Uma sequência de caracteres ASCII imprimíveis, como uma sequência ou matriz / lista de caracteres

Resultado

A sequência de entrada com cada caractere é substituída por um caractere não imprimível distinto. Cada caractere especificado deve ter um caractere não imprimível correspondente que não seja usado como substituto para qualquer outro caractere.

Se você não conseguir imprimir caracteres não imprimíveis, poderá gerar os valores dos caracteres.

Por exemplo, se o seu código substituir todos os minúsculos apor 0x01, você não poderá usar 0x01como substituto para outros caracteres.

Seu código também deve ser determinístico . Isso significa que, se, dada a string Hello, todas as minúsculas lforem substituídas por 0x03, seu código também deverá substituir todas as minúsculas lpor 0x03qualquer outra string.

Casos de teste

É um pouco difícil escrever casos de teste para esse desafio, então mostrarei a saída como uma lista de códigos hexadecimais

input     -> output
"Hello"   -> [0x01, 0x02, 0x03, 0x03, 0x04]
"Hi!"     -> [0x01, 0x05, 0x06]
""        -> []
"   H   " -> [0x07, 0x07, 0x07, 0x01, 0x07, 0x07, 0x07]
"yo! "    -> [0x08, 0x04, 0x06, 0x07]

Geléia , 3 bytes

O²Ọ

Experimente online!

Esquadra cada ponto de código.

Espaço em branco , 39 36 bytes

Experimente online!

Explicação

nssn  ; label 'loop'
ssstssn ; push 4 to use as a multiplication operand
sns   ; dup 4 to use as a heap address
sns   ; dup 4 to use as a heap address
tnts  ; getchar and store at address 4
ttt   ; retrieve the value at address 4
tssn  ; multiply the character value by 4
tnss  ; putchar output the new character
nsnn  ; jmp 'loop'

Originalmente, eu queria multiplicar por -0 ou -1, pois seriam os dígitos mais curtos possíveis para declarar em espaço em branco. O TIO não diferencia entre -0 e +0, então está fora. Infelizmente, enquanto o tutorial / especificação é ambíguo sobre como interpretar um valor negativo como um caractere TIO (corretamente) lança um erro sobre o argumento inválido, de modo que também não é uma opção.

A próxima constante de trabalho mais curta é 4, portanto, acabamos executando a mesma abordagem básica das soluções Powershell / Pyth.

Espaço em branco , 56 53 bytes - mapeia para marcar caracteres

Experimente online!

Explicação

Efetivamente, a mesma abordagem da versão anterior, exceto que ela usa 0xE0000 como constante e adiciona em vez de multiplicar. Isso mapeia os caracteres ASCII visíveis para o caractere de tag Unicode correspondente (o intervalo U + E0000-U + E007F). O uso pretendido para esse intervalo era indicar o idioma do texto em um arquivo de texto sem formatação, no entanto esse uso é desencorajado. Esse código produzirá rótulos válidos se você prefixar as strings com um caractere 0x01.

O Padrão Unicode diz que os caracteres desse intervalo não têm renderização visível, então acho que isso atende melhor ao espírito do desafio do que a abordagem anterior.

Japonês , 5 2 bytes

cp

Experimente online

Explicação

     :Implicit input of string U
c    :Map over the character codes of the string.
p    :Square them.
     :Implicit output of result.

Brain-Flak , 33 bytes

Inclui +1 para -c

{((({}){}){}<>)<>}<>{({}<>)<>}<>

Experimente online!

# For each character
{
  # Multiply by 4 and move to the other stack
  ((({}){}){}<>)

# End loop
<>}

# For each character on the other stack
<>{

  # Copy it back (reverse the stack)
  ({}<>)<>

# End loop
}<>

Braingolf v0.6, 17 bytes

VRl1-M[R.*>v]R&@

Esquadra cada valor de char e depois imprime.

-1 byte graças à solução quadrada de Erik the Outgolfer

Braingolf v0.7, 6 bytes [não concorrente]

{.*}&@

Também esquadrinha cada valor e depois imprime, mas a v0.7 possui o {}loop "foreach"

Mathematica, 48 bytes

FromCharacterCode[4Mod[Hash/@Characters@#,978]]&

Explicação:

                             Characters@#      & - Convert string to array of characters
                       Hash/@                    - Hash them all using default hash
                   Mod[                  ,978]   - apply a modulus which uniquely transforms each potential character's hash into a number
                  4                              - times by 4 to move values out of 0x20-0x7E.
FromCharacterCode[                            ]  - Convert array of numbers back to string

Curiosamente das duas opções de módulo inferiores a 1000, que alteraram os 96 caracteres para 96 ​​valores únicos, com o módulo 978, os dois valores mais baixos foram 7 e 33. Felizmente, vezes por 4, converte isso em 28 e 132, os quais ficam fora do intervalo visível. Se eu usasse o outro módulo de 784, precisava multiplicar por 18 para mover os números para fora do intervalo.

Caso de teste.

Nota: barras invertidas extras como caracteres de escape para "e \. O caractere 0x7E também não parece querer colar corretamente.

Input: "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

Resultado:

O uso de Hashsurgiu como ToCharacterCodeé realmente longo. No entanto, o hash era quase tão caro. A maneira fácil do mathematica de fazer isso seria 49 bytes:

FromCharacterCode[4ToCharacterCode@Characters@#]&

CJam , 8 5 bytes

l95f+

Experimente online!

Adiciona 95 a cada ponto de código.

Pitão, 6 bytes

smC*4C

Experimente aqui.

Multiplica cada ponto de código por 4.

PowerShell, 32 31 bytes

-1 Obrigado a neil, 99+a4*

[char[]]"$args"|%{[char](4*$_)}

multiplica 9 por cada código de caractere e o imprime novamente.

05AB1E , 4 bytes

ÇnçJ

Experimente online!

Esquadra cada ponto de código.

CJam , 4 bytes

lWf^

XORs cada ponto de código com -1 . Os caracteres de CJam têm 16 bits de largura, portanto, este mapeia o ponto de código n para o ponto de código 65535 - n .

Experimente online!

Decimal , 37 bytes

91D31030030012255D412D590D543D301291D

Explicação:

91D             ; declare jump 1
    310         ; push user input to stack
    300         ; duplicate
    300         ; duplicate
    12255D      ; push EOF to stack
    412D        ; compare top two values, pop, push result
    5 90D 5     ; if result == true, quit
    43D         ; multiply top two values, pop, push result
    301         ; print
    2           ; pop
91D             ; goto jump 1

Experimente online!

Planilhas Google, 68 bytes

=ArrayFormula(Join("",IfError(Char(Code(Mid(A1,Row(A:A),1))^2),"")))

Eu queria postar isso para mostrar como é estranho fazer algumas funções básicas no Planilhas. Deseja executar uma operação para todos os caracteres em uma célula e obter o resultado concatenado? Você tem 42 bytes antes mesmo de agir sobre esses caracteres.

=ArrayFormula(Join("",Mid(A1,Row(A:A),1)))

Caso contrário, é igual a outras soluções: calcule o quadrado do ponto de código de cada caractere.

Python 3, 40 38 bytes

print ([chr (ord (x) * 9) para x na entrada ()]))

Experimente Online!

C, 42 bytes

c;f(){while(~(c=getchar()))putwchar(c*c);}

Assume um código de idioma UTF-8. A entrada é quadrada.

Experimente online!

Limpo , 25 bytes

import StdEnv

map((+)'~')

Uma função parcial literal.

Experimente online!

Realisticamente:

f s = {# c+'~' \\ c <-: s}

Compreensão de array não caixa sobre uma matriz não caixa do mesmo tipo ( {#Char} -> {#Char}). Clean poderá determinar que a exclusividade é transferível ( !u:{#Char} -> u:{#Char}) e que o tamanho é igual ao tamanho da entrada. Isso significa que, se você passar a *String, todos os caracteres serão destrutivamente atualizados com o correspondente na saída, o que significa que nenhuma alocação ou movimento de memória é feito e o nó do gráfico é totalmente reutilizado.

Experimente online!