Meine frühere Herausforderung, unsichtbaren Text zu drucken, war ziemlich beliebt, wahrscheinlich weil es so trivial ist.

Diejenigen, die Sie genauer beobachten, haben jedoch möglicherweise bemerkt, dass Sie nicht wirklich unsichtbaren Text drucken, da es unmöglich ist, zu lesen, was nur bei der Ausgabe eingegeben wurde.

Also dachte ich mir, wie wäre es mit einer wirklich unsichtbaren Textherausforderung?

0x20-0x7EKonvertieren Sie bei einer Zeichenfolge, die nur aus druckbaren ASCII-Zeichen ( ) besteht, jedes Zeichen in ein bestimmtes Unicode-Zeichen (in UTF-8-Codierung), das nicht zu den 95 druckbaren ASCII-Zeichen (UTF-8-Zeichen außerhalb des 0x20-0x7EBereichs) gehört.

Eingang

Eine Zeichenfolge aus druckbaren ASCII-Zeichen, entweder als Zeichenfolge oder als Array / Liste von Zeichen

Ausgabe

Die Eingabezeichenfolge, wobei jedes Zeichen durch ein bestimmtes nicht druckbares Zeichen ersetzt wird. Jedes angegebene Zeichen muss ein entsprechendes nicht druckbares Zeichen enthalten, das nicht als Ersatz für ein anderes Zeichen verwendet wird.

Wenn Sie keine nicht druckbaren Zeichen drucken können, können Sie stattdessen die Zeichenwerte ausgeben.

Wenn Ihr Code beispielsweise alle Kleinbuchstaben adurch ersetzt 0x01, dürfen Sie 0x01keine anderen Zeichen ersetzen.

Ihr Code muss auch deterministisch sein . Dies bedeutet, dass, wenn in der angegebenen Zeichenfolge Helloalle Kleinbuchstaben ldurch ersetzt werden 0x03, Ihr Code auch alle Kleinbuchstaben ldurch 0x03eine beliebige andere Zeichenfolge ersetzen muss .

Testfälle

Es ist etwas schwierig, Testfälle für diese Herausforderung zu schreiben, daher zeige ich die Ausgabe einfach als Liste mit Hexcodes

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]

Gelee , 3 Bytes

O²Ọ

Probieren Sie es online!

Quadriert jeden Codepunkt.

Leerzeichen , 39 36 Bytes

Probieren Sie es online!

Erläuterung

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'

Ursprünglich wollte ich mit -0 oder -1 multiplizieren, da dies die kürzesten Stellen sind, die in Whitespace deklariert werden können. TIO unterscheidet nicht zwischen -0 und +0. Während das Tutorial / die Spezifikation nicht eindeutig ist, wie ein negativer Wert als Zeichen interpretiert werden soll, wirft TIO (zu Recht) einen Fehler über das ungültige Argument aus, sodass dies ebenfalls keine Option darstellt.

Die nächstkürzere Arbeitskonstante ist 4, sodass wir am Ende den gleichen grundlegenden Ansatz wie die Powershell / Pyth-Lösungen ausführen.

Whitespace , 56 53 Bytes - Ordnet Zeichen zu

Probieren Sie es online!

Erläuterung

Tatsächlich der gleiche Ansatz wie in der vorherigen Version, außer dass 0xE0000 als Konstante verwendet wird und anstelle von Multiplikationen addiert wird. Dadurch werden die sichtbaren ASCII-Zeichen dem entsprechenden Unicode-Tag-Zeichen (Bereich U + E0000-U + E007F) zugeordnet. Die beabsichtigte Verwendung für diesen Bereich bestand darin, die Sprache des Texts in einer Klartextdatei anzugeben, von deren Verwendung jedoch abgeraten wird. Dieser Code gibt gültige Bezeichnungen aus, wenn Sie Zeichenfolgen mit einem 0x01-Zeichen voranstellen.

Der Unicode-Standard besagt, dass Zeichen in diesem Bereich kein sichtbares Rendering aufweisen. Ich bin daher der Meinung, dass dies dem Geist der Herausforderung besser entspricht als der vorherige Ansatz.

Japt , 5 2 Bytes

cp

Probieren Sie es online aus

Erläuterung

     :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

Beinhaltet +1 für -c

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

Probieren Sie es 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&@

Quadrate für jeden Zeichenwert werden gedruckt.

-1 Byte dank der Quadraturlösung von Erik the Outgolfer

Braingolf v0.7, 6 bytes [nicht konkurrierend]

{.*}&@

Jeder Wert wird dann auch quadriert, aber in v0.7 gibt es die "foreach" {}-Schleife

Mathematica, 48 Bytes

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

Erläuterung:

                             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

Interessanterweise waren von den beiden Moduloptionen mit weniger als 1000, die die 96 Zeichen in 96 eindeutige Werte mit dem Modul 978 änderten, die beiden niedrigsten Werte 7 und 33. Glücklicherweise werden diese Werte durch 4-mal in 28 und 132 umgewandelt, die beide gerade außerhalb des sichtbaren Bereichs liegen. Wenn ich den anderen Modul von 784 verwendete, musste ich mit 18 multiplizieren, um die Zahlen außerhalb des Bereichs zu bewegen.

Testfall.

Hinweis: Zusätzliche Backslashes als Escape-Zeichen für "und \. Auch das Zeichen 0x7E scheint nicht richtig einfügen zu wollen.

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

Ausgabe:

Die Verwendung von Hashkam wie es ToCharacterCodeist wirklich lange her. Allerdings war es fast so teuer. Der einfache mathematische Weg, dies zu tun, wäre 49 Bytes:

FromCharacterCode[4ToCharacterCode@Characters@#]&

CJam , 8 5 Bytes

l95f+

Probieren Sie es online!

Fügt jedem Codepunkt 95 hinzu.

Pyth, 6 Bytes

smC*4C

Probieren Sie es hier aus.

Multipliziert jeden Codepunkt mit 4.

PowerShell, 32 - 31 Byte

-1 Danke an neil, 99+an4*

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

multipliziert 9 mit jedem Zeichencode und druckt ihn zurück.

05AB1E , 4 Bytes

ÇnçJ

Probieren Sie es online!

Quadriert jeden Codepunkt.

CJam , 4 Bytes

lWf^

XORs jeden Codepunkt mit -1 . CJams Zeichen sind 16 Bit breit, daher ordnet dies den Codepunkt n dem Codepunkt 65535-n zu .

Probieren Sie es online!

Dezimal 37 Bytes

91D31030030012255D412D590D543D301291D

Erläuterung:

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

Probieren Sie es online!

Google Sheets, 68 Bytes

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

Ich wollte dies posten, um zu zeigen, wie umständlich es ist, einige grundlegende Funktionen in Sheets auszuführen. Möchten Sie für jedes Zeichen in einer Zelle eine Operation ausführen und das verkettete Ergebnis ausgeben? Sie sind bei 42 Bytes, bevor Sie überhaupt auf diese Zeichen einwirken .

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

Ansonsten ist dies dasselbe wie bei anderen Lösungen: Quadrieren Sie den Codepunkt jedes Zeichens.

Python 3, 40 38 Bytes

print ([chr (ord (x) * 9) für x in input ()])

Probieren Sie es online!

C, 42 Bytes

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

Nimmt ein UTF-8-Gebietsschema an. Die Eingabe wird quadriert.

Probieren Sie es online!

Sauber , 25 Bytes

import StdEnv

map((+)'~')

Ein Teilfunktionsliteral.

Probieren Sie es online!

Realistisch:

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

Unboxed-Array-Verständnis über ein unboxed-Array desselben Typs ( {#Char} -> {#Char}). Clean kann feststellen, dass die Eindeutigkeit übertragbar ist ( !u:{#Char} -> u:{#Char}) und dass die Größe der Eingabegröße entspricht. Dies bedeutet, dass bei Übergabe von a *Stringjedes Zeichen destruktiv mit dem entsprechenden Zeichen in der Ausgabe aktualisiert wird, was bedeutet, dass keine Speicherzuweisung oder Bewegung erfolgt und der Graphknoten vollständig wiederverwendet wird.

Probieren Sie es online!