Stampa testo invisibile reale


15

La mia precedente sfida, Print text invisible era piuttosto popolare, probabilmente a causa di quanto sia banale.

Tuttavia, quelli più attenti a te potrebbero aver notato che non stai davvero stampando un testo invisibile, perché è impossibile leggere ciò che è stato immesso dato solo l'output.

Quindi ho pensato a una vera sfida di testo invisibile.

Data una stringa composta da soli caratteri ASCII stampabili ( 0x20-0x7E), converti ciascun carattere in un carattere Unicode distinto (con codifica UTF-8) che non è uno dei 95 caratteri ASCII stampabili (qualsiasi carattere UTF-8 al di fuori 0x20-0x7Edell'intervallo)

Ingresso

Una stringa di caratteri ASCII stampabili, come stringa o matrice / elenco di caratteri

Produzione

La stringa di input con ciascun carattere sostituita con un carattere non stampabile distinto. Ogni dato personaggio deve avere un corrispondente carattere non stampabile che non viene utilizzato come sostituto di nessun altro personaggio.

Se non è possibile stampare caratteri non stampabili, è possibile invece generare i valori dei caratteri.

Ad esempio, se il codice sostituisce tutte le lettere minuscole acon 0x01, non è possibile utilizzare 0x01come sostituzione per altri caratteri.

Anche il tuo codice deve essere deterministico . Ciò significa che se, data la stringa Hello, lvengono sostituite tutte le lettere minuscole 0x03, il codice deve anche sostituire tutte le lettere minuscole lcon 0x03qualsiasi altra stringa.

Casi test

È un po 'difficile scrivere testcase per questa sfida, quindi mostrerò semplicemente l'output come un elenco di codici esadecimali

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]

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.


9
Non esiste un carattere UTF-8: UTF-8 è una serializzazione di Unicode, non un set di caratteri. E se "non stampabile" ha senso in un contesto Unicode, è certamente molto più ristretto di "tutti tranne 95 delle centinaia di migliaia di punti codificati assegnati".
Peter Taylor,

11
@PeterTaylor Dato che stiamo parlando in termini di codici esadecimali qui, ho pensato che fosse chiaro che quando dico carattere UTF-8 intendo un carattere Unicode nella codifica UTF-8. ASCII è anche uno standard di codifica, non un set di caratteri, ma le persone non hanno alcun problema con il termine "carattere ASCII". Ad ogni modo, modificherò il testo per chiarire.
Skidsdev,

3
Qualche motivo particolare è richiesto UTF-8?
CalculatorFeline

L'ingresso può essere vuoto?
Dennis,

1
+1 per "Se non riesci a stampare caratteri non stampabili"
Robert Fraser,

Risposte:


13

Gelatina , 3 byte

O²Ọ

Provalo online!

Quadrati ogni punto di codice.


Molto simile alla soluzione di Japt che mi è venuta in mente, mi aspetto di tagliare a cubetti il ​​punto di codice invece di squadrarlo - sei d'accordo con me pubblicandolo?
Shaggy,

2
@Shaggy Japt ≠ Jelly, così puoi pubblicarlo.
Erik the Outgolfer,

Soluzione intelligente, non pensavo di quadrare.
Skidsdev,

1
Grande, volevo solo esserne sicuro, per non pensare che stavo solo strappando la tua soluzione :)
Shaggy,

4
@Shaggy non esiste alcuna linea guida contro il porting di una soluzione in un'altra lingua; se ci fosse, sarebbe terribile dato che di solito esiste un algoritmo ottimale che fornisce implementazioni ottimali nella maggior parte dei linguaggi, e nessuno, tranne il primo poster, non sarebbe in grado di provare che è arrivato con l'algoritmo da solo. Ovviamente se porti davvero la soluzione di qualcun altro, è solo un gioco da ragazzi menzionare la sua risposta.
Aaron,

13

Spazio bianco , 39 36 byte


  
   	  
 
  
 	
	 				  
	
  
 


Provalo online!

Spiegazione

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'

Inizialmente volevo moltiplicare per -0 o -1 poiché sarebbero le cifre più brevi possibili da dichiarare in Whitespace. TIO non distingue tra -0 e +0, quindi è fuori. Sfortunatamente mentre il tutorial / le specifiche sono ambigui su come interpretare un valore negativo come un carattere TIO (giustamente) genera un errore sull'argomento non valido in modo che anche questa non sia un'opzione.

La costante di lavoro più breve successiva è 4, quindi finiamo per eseguire lo stesso approccio di base delle soluzioni Powershell / Pyth.


Spazio bianco , 56 53 byte - mappa per contrassegnare i caratteri


  
   			                 
 
  
 	
	 				   	
  
 


Provalo online!

Spiegazione

In effetti, lo stesso approccio della versione precedente eccetto questo usa 0xE0000 come costante e aggiunge invece di moltiplicare. Questo associa i caratteri ASCII visibili al corrispondente carattere tag Unicode (l'intervallo U + E0000-U + E007F). L'uso previsto per questo intervallo era di indicare la lingua del testo in un file di testo in chiaro, tuttavia l'uso è sconsigliato. Questo codice genererà etichette valide se si antepongono le stringhe con un carattere 0x01.

Lo standard Unicode afferma che i personaggi in questa gamma non hanno un rendering visibile, quindi ritengo che questo soddisfi lo spirito della sfida meglio dell'approccio precedente.


5
Utilizzo di un programma invisibile per stampare testo invisibile. Mi piace.
Segna

7

Japt , 5 2 byte

cp

Provalo online


Spiegazione

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

Hmm, dopo un esame più attento, sembra che 126 ** 3 == 2000376non rientri nell'intervallo [0..1114111]. Puoi comunque quadrare :) Questo perché UTF-8 finisce lì, mentre UTF-16 continua.
Erik the Outgolfer,

1
@EriktheOutgolfer Ehm. UTF-8 ha esattamente lo stesso intervallo di UTF-16 per definizione. (In teoria, UTF-8 potrebbe memorizzare punti di codice più alti, usando 5 o 6 byte per punto di codice, ma questo è illegale.)
Mr Lister

5

Brain-Flak , 33 byte

Include +1 per -c

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

Provalo 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
}<>

4

Braingolf v0.6, 17 byte

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

Quadrati di ogni valore di carattere, quindi stampa.

-1 byte grazie alla soluzione di squadratura di Erik the Outgolfer

Braingolf v0.7, 6 byte [non competitivo]

{.*}&@

Inoltre piazza ogni valore e poi stampa, ma v0.7 ha il {}ciclo "foreach"


4

Mathematica, 48 byte

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

Spiegazione:

                             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

È interessante notare che le due opzioni del modulo meno di 1000 che hanno cambiato i 96 caratteri in 96 valori univoci con il modulo 978, i due valori più bassi erano 7 e 33. Fortunatamente i tempi di 4 lo converte in 28 e 132 che entrambi non rientrano nell'intervallo visibile. Se avessi usato l'altro modulo di 784, avrei dovuto moltiplicare per 18 per spostare i numeri al di fuori dell'intervallo.

Caso di prova.

Nota: barre rovesciate extra come caratteri di escape per "e \. Inoltre, il carattere 0x7E non sembra voler incollare correttamente.

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

Produzione: inserisci qui la descrizione dell'immagine

L'uso di è Hashnato come ToCharacterCodeè davvero lungo. Tuttavia l'hashing era quasi altrettanto costoso. Il modo matematico semplice per farlo sarebbe di 49 byte:

FromCharacterCode[4ToCharacterCode@Characters@#]&

2

CJam , 8 5 byte

l95f+

Provalo online!

Aggiunge 95 a ciascun punto di codice.


Non c'è un modo per moltiplicare o quadrare invece?
NieDzejkob,

@NieDzejkob No, questo si basa sul fatto che Character + Long = chr (ord (Character) + Long). Carattere * Lungo = [Carattere] * Lungo. Carattere # Lungo = errore (# è esponenziazione in CJam).
Erik the Outgolfer,


2

PowerShell, 32 31 byte

-1 Grazie a Neil, 99+a4*

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

moltiplica 9 per ciascun codice carattere e lo stampa indietro.


Per interesse, moltiplicando per un piccolo numero (4-9) lavoro?
Neil,

il più basso dei tempi stampabili 4 è maggiore del più grande stampabile, cioè -1 - grazie!
Colsw,


1

CJam , 4 byte

lWf^

XORs ogni punto di codice con -1 . I caratteri di CJam sono larghi 16 bit, quindi questo mappa il punto codice n al punto codice 65535 - n .

Provalo online!


1

Decimale , 37 byte

91D31030030012255D412D590D543D301291D

Spiegazione:

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

Provalo online!


quindi saltare a zero ( 90D) termina?
Skidsdev,

@Mayube Exactly.
MD XF,

1

Fogli Google, 68 byte

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

Volevo postare questo per mostrare quanto sia imbarazzante svolgere alcune funzioni di base in Fogli. Vuoi fare un'operazione per ogni personaggio di una cella e ottenere il risultato concatenato? Sei a 42 byte prima ancora di agire su quei personaggi.

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

Altrimenti, questo è lo stesso di altre soluzioni: quadrare il punto di codice di ogni carattere.



0

C, 42 byte

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

Presuppone un'impostazione internazionale UTF-8. L'ingresso è al quadrato.

Provalo online!


0

Pulito , 25 byte

import StdEnv

map((+)'~')

Una funzione parziale letterale.

Provalo online!

realisticamente:

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

Comprensione di unboxed array su un array unboxed dello stesso tipo ( {#Char} -> {#Char}). Clean sarà in grado di determinare che l'unicità è trasferibile ( !u:{#Char} -> u:{#Char}) e che la dimensione è uguale alla dimensione di input. Ciò significa che se si passa a *String, ogni carattere verrà aggiornato in modo distruttivo con quello corrispondente nell'output, il che significa che non viene eseguita alcuna allocazione di memoria o movimento e il nodo grafico viene completamente riutilizzato.

Provalo online!

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.