Ziel dieser Herausforderung ist es, ein Programm zu schreiben, das die folgenden Bedingungen erfüllt:

• Das Programm ist nicht palindromisch oder im Wesentlichen palindromisch (was bedeutet, dass es möglich ist, Zeichen zu entfernen, um es zu einem Palindrom zu machen, ohne die Effekte des Programms zu ändern).

• Das Programm ist keine Involution (was bedeutet, dass es nicht seine ursprüngliche Eingabe erzeugt, wenn es auf seiner Ausgabe ausgeführt wird)

• Das Programm mit umgekehrter Polarität ist das Gegenteil des normalen Programms. Wenn also das umgekehrte Programm auf der Ausgabe des normalen Programms ausgeführt wird, wird die ursprüngliche Eingabe zurückgegeben.

Was bedeutet Verpolung ? Nun, es unterscheidet sich zwischen den Sprachen.

• Für die meisten Nicht-Esolangs bedeutet dies, die Reihenfolge der Unteroperationen in einer einzelnen Operation umzukehren, die Reihenfolge der Argumente umzukehren und den Inhalt von hartcodierten Listen / Arrays / Tupeln / Wörterbüchern / Stapeln / Warteschlangen / usw. umzukehren als Umkehrung der Reihenfolge von Code-Blöcken und eigenständigen Zeilen (aber nicht Zeilen innerhalb von Blöcken)

Beispiele:

Haskell : x`mod`y-> y`mod`x; zipWith ((*3).(+)) [1,2,3] [4,5,6]->zipWith ((+).(*3)) [6,5,4] [3,2,1]

Python : 2**3-> 3**2; for x,y in [(1,2),(3,4),(5,6)]->for y,x in [(6,5),(4,3),(2,1)]

• Für Sprachen mit 1-Zeichen-Funktionen (wie Pyth, APL) kehren Sie einfach die Anweisungsfolge um

• Für eindimensionale Esolangs wie BF kehren Sie die Anweisungen um oder tauschen Sie die Polarität aus. Polaritätswechsel sind []-> {}, +-> -, --> +, >-> <, <-> >, .-> ,und ,-> .(aber nicht beide)

• Für zweidimensionale Esolangs wie Befunge können Sie entweder eine Reflexion über die x- oder y-Achse oder eine Diagonale ausführen, um 180 Grad drehen oder eine Kombination aus einer Reflexion und einer Drehung ausführen

Kommutative Operationen sind erlaubt, palindrome jedoch nicht: 2*xist in Ordnung, aber x+xschlecht. Die Definition einer Polaritätsumkehr ist ziemlich locker, aber urteilen Sie, was Sinn macht. es geht nicht darum, die klügste lücke zu finden, sondern die klügste lösung.

Dies ist ein Beliebtheitswettbewerb, daher mag eine sehr clevere Lücke beliebt sein, aber versuchen Sie, im Geiste dieser Herausforderung zu bleiben. Der Gewinner wird bekannt gegeben, wenn mindestens 10 Lösungen mit mindestens 1 positiven Bewertung vorliegen und mindestens eine Lösung mit mehr positiven Bewertungen vorliegt als Einsendungen mit mindestens 1 positiven Bewertung; oder in 1 Monat, je nachdem, was zuerst eintritt. Dies ist meine erste Herausforderung. Versuchen Sie also, fair zu sein und mir konstruktives Feedback zu geben. Lassen Sie mich jedoch auch wissen, ob dies eine unangemessene Herausforderung ist oder in irgendeiner Weise falsch kategorisiert oder nicht eindeutig ist. Wenn Sie Fragen zu einer Sprache haben, die nicht in eine der von mir hier aufgeführten Schubladen passt, kommentieren Sie, und ich werde mich dem Willen der Community anschließen, wenn ein starker Aufschrei nach einer bestimmten Klarstellung oder Änderung der Regeln besteht.

AKTUALISIEREN

Es ist genau 1 Monat her, seit dieser Wettbewerb gestartet wurde (ich habe es nur zufällig überprüft, ohne zu wissen, dass ich tatsächlich pünktlich war). Da dies ein Beliebtheitswettbewerb ist, ist der Gewinner (durch einen Erdrutsch) Pietu1998-Befunge . Auch wenn die unteren Komponenten (der Textumkehrer und das Rückwärtsalphabet) beide Involutionen sind, ist dies beim Encoder / Decoder nicht der Fall, sodass es dort kein Problem gibt. Bonuspunkte (meiner Meinung nach) für das Schreiben von "BEFUNGE" in die Mitte. Ich persönlich mochte die Neuheit von Zgarbs Theseus-Lösung , weil die Sprache cool aussieht (wenn sie eingeschränkt ist). Vielen Dank für die Teilnahme und während der Gewinner ausgewählt wurde, lasse ich diesen Wettbewerb völlig offen und begrüße zukünftige Einsendungen.

Befunge

Wow, das war ein Job, auch mit dem Editor, den ich für diese Herausforderung gemacht habe. Hier ist was ich habe, ein netter 11x12 Block:

v$,g6<6g,$v
v,$ _^_ $,v
1W>v\B\v>L1
~T+:1E1:-O~
+F00-F-02L+
>:|6gUg6|:>
{a@>^N^>@z`
>1+|@G$| +>
:^9< E<  ^1
~>7^@_,#:>:
 xD>65 ^=P~
v,-\+**<  v

Es macht ein paar Dinge, leider nur für Kleinbuchstaben.

Was es macht

Wenn es normal ausgeführt wird, führt es eine Caesar-Verschlüsselung für die Eingabe durch.

abcxyz      -> bcdyza
exampletext -> fybnqmfufyu

Wenn es horizontal gewendet wird, kehrt es die Chiffre um. Dies ist die Voraussetzung für die Herausforderung, endet aber nicht hier.

bcdyza      -> abcxyz
fybnqmfufyu -> exampletext

Bei vertikaler Umkehrung wird die Eingabe mit einem umgekehrten Alphabet verschlüsselt. Dies kann als der entgegengesetzte Ansatz zur Caesar-Chiffre angesehen werden.

abcxyz      -> zyxcba
exampletext -> vcznkovgvcg

Wenn es um 180 Grad gedreht wird, kehrt es schließlich die Eingabe um. Ich habe das Gefühl, es muss eine Umkehrung von etwas sein (Hinweis: die Eingabe).

abcxyz      -> zyxcba
exampletext -> txetelpmaxe

Wie es funktioniert

Der Block besteht im Wesentlichen aus vier sich halb überlappenden Algorithmen.

Caesar-Verschlüsselungscode

v$,g6<
v,$ _^
1 >v\
~ +:1
+ 00-
>:|6g
{a@>^

Caesar-Chiffre-Decoder (horizontal gespiegelt)

v$,g6<
v,$ _^
1 >v\
~ -:1
+ 20-
>:|6g
`z@>^

Umgekehrte Alphabet-Chiffre (vertikal gespiegelt)

v,-\+**<
   >65 ^
~>7^
:^9<
>1+|@
   >^

Textumkehrer (um 180 Grad gedreht)

v  <
~      
:>:#,_@
1^  <
>+ |$
   >^

Gehirnfick, 5

,+.-,

Möglicherweise liefert Brainfuck zum ersten Mal eine Antwort, die hinsichtlich der Codelänge wettbewerbsfähig ist. Schade, dass es keine Code-Golf-Frage ist.

Gibt ein Byte (Zeichen) ein, erhöht es und gibt das Ergebnis aus. Das Komma am Ende wartet auf eine weitere Eingabe, die ignoriert wird. Es gibt nichts in der Spezifikation über die ordnungsgemäße Kündigung: -) *

* (oder etwas Nützliches mit dem gesamten Code in beide Richtungen zu tun)

Typische Ergebnisse (zweites Zeichen, falls angegeben, wird ignoriert).

Weiterleiten: B->C

Rückwärts: B-> Aoder C->B

Marbelous

Hier ist eine einfache Einführung. Es liest ein Zeichen aus STDIN, erhöht und druckt es.

--
]]
00
]]
++

Wenn wir dies um 180 ° drehen (ohne Klammern zu tauschen) oder es in der x-Achse spiegeln, erhalten wir

++
]]
00
]]
--

Dieser liest ein Byte aus STDIN und dekrementiert es.

Sie können es hier testen .

Ich könnte in einige kompliziertere Marbelous-Programme schauen, aber ich bin sicher, es1024 wird mich schlagen. ;)

Erläuterung

Das 00ist ein Marmor mit dem Wert 0 (der beliebig ist). Die ]]Geräte lesen ein Byte aus STDIN - das heißt, wenn ein Marmor durch sie fällt, wird der Marmorwert in das gelesene Byte geändert. Die Geräte ++und --erhöhen oder verringern einfach den Wert einer Murmel (Mod 256) und lassen ihn fallen. Wenn eine Kugel von der Platine fällt, wird das Byte in STDOUT geschrieben.

Daher werden die beiden Geräte oben einfach ignoriert, da der Steuerungsfluss sie nie erreicht.

Marbelous

Dieses Board nimmt ein Argument ( x) und kehrt zurück (101 * x) mod 256.

.. @5 .. }0 }0 @1 .. @0 .. @2 .. 
.. /\ Dp << \\ .. &0 >0 &1 .. .. 
!! @3 .. << }0 .. \/ -- \/ .. }0 
@4 .. .. &0 @1 /\ &0 65 &1 /\ @2 
/\ Dp .. @4 .. .. @3 @0 @5 !! \\

Das Spiegeln der Zellen entlang der y-Achse führt zu einer Tafel, die ein Argument ( y) annimmt und zurückgibt. Dies (101 * y + 8 * y) mod 256ist die Umkehrung der ersten Tafel.

.. @2 .. @0 .. @1 }0 }0 .. @5 ..
.. .. &1 >0 &0 .. \\ << Dp /\ ..
}0 .. \/ -- \/ .. }0 << .. @3 !!
@2 /\ &1 65 &0 /\ @1 &0 .. .. @4
\\ !! @5 @0 @3 .. .. @4 .. Dp /\

Testen Sie dies hier . Zylindrische Boards und Include-Bibliotheken sollten beide überprüft werden.

Beispiel Ein- / Ausgabe :

Original Board:      Mirrored Board:
Input   Output       Input    Output
025     221          221      025
042     146          146      042
226     042          042      226

Bitte beachten Sie, dass Marbelous nur die Übergabe positiver Ganzzahlen als Argumente zulässt. Diese Ganzzahlen werden vom Interpreter an das Programm modulo 256 übergeben.

101wurde aus zwei Gründen gewählt: Es handelt sich um eine Primzahl (und jede mögliche Eingabe in dieses Programm führt zu einer eindeutigen Ausgabe) und die damit verbundene inverse Operation 109, von der ein praktischer Abstand von 8 liegt 101.

Kurze Erklärung

Die Spalte mit den Zellen (von oben nach unten) wird @0 >0 -- 65 @0auf beiden Brettern gleich ausgeführt und durchläuft die Schleifen 101, bevor nach rechts gewechselt wird. Auf beiden Seiten des >0Zweigs befindet sich ein anderer Synchronisierer. welche ausgewählt wird, hängt davon ab, ob die Platine gespiegelt ist oder nicht.

Auf jeder Seite wird synchron mit der mittleren Schleife die Eingabe wiederholt summiert, wodurch erhalten wird 101*x mod 256. Auf der umgekehrten Karte werden zwei Kopien der Eingabe ebenfalls zweimal bitweise nach links verschoben ( input * 4), dann summiert und in einem Synchronisierer belassen.

Sobald die mittlere Schleife beendet ist, werden die aufsummierten Murmeln zum Drucken gesendet, und zwar auf der Seite der Tafel (links für die ursprüngliche Tafel, rechts für die gespiegelte Tafel). Nach dem Drucken ist eine !!Zelle erreicht, wodurch die Platine beendet wird. Beachten Sie, dass die 101 * xgegebene Schleife von selbst weiterläuft, bis die Karte beendet ist.

Dp druckt das Ergebnis einfach als Dezimalzahl aus.

Theseus

Dies kann als eine Lücke angesehen werden, aber ich mag die Sprache, also hier geht. Dieses Programm definiert eine Funktion ffür natürliche Zahlen, die 3n bis 3n + 1 , 3n + 1 bis 3n + 2 und 3n + 2 bis 3n für jedes n abbildet .

data Num = Zero | Succ Num

iso f :: Num <-> Num
  | n                          <-> iter $ Zero, n
  | iter $ m, Succ Succ Succ n <-> iter $ Succ m, n
  | iter $ m, Succ Succ Zero   <-> back $ m, Zero
  | iter $ m, Succ Zero        <-> back $ m, Succ Succ Zero
  | iter $ m, Zero             <-> back $ m, Succ Zero
  | back $ Succ m, n           <-> back $ m, Succ Succ Succ n
  | back $ Zero, n             <-> n
  where iter :: Num * Num
        back :: Num * Num

Theseus ist eine umkehrbare Sprache mit einer Haskell-ähnlichen Syntax, bei der jede Funktion umkehrbar ist (Abzinsung von Problemen bei Nichtbeendigung). Es ist sehr experimentell und für Forschungszwecke konzipiert. Der obige Code definiert einen Datentyp für natürliche Zahlen und die Funktion f. Wenn Sie eine eingegebene Nummer haben, stimmen Sie das Muster mit dieser Nummer auf der linken Seite überein (es stimmt immer überein n). Dann schauen Sie sich das Muster rechts an. Wenn dieses Muster eine Bezeichnung hat (hieriter), fahren Sie mit der Mustererkennung auf der linken Seite fort und nehmen den entsprechenden Wert erneut auf der rechten Seite. Dies wiederholt sich, bis Sie rechts einen unbeschrifteten Wert haben, und das ist Ihre Ausgabe. Die Muster links und rechts müssen vollständig und nicht überlappend sein (für jedes Etikett separat). Um die Polarität von umzukehren f, gehe ich wie folgt vor.

• Tauschen Sie die beiden Werte jedes Etiketts aus. Dies ändert nichts an der Semantik von f.
• Vertauschen Sie die rechte und linke Seite im Funktionskörper. Dies definiert die Umkehrfunktion des f Entwurfs .

Das Ergebnis:

iso f :: Num <-> Num
  | iter $ n, Zero             <-> n
  | iter $ n, Succ m           <-> iter $ Succ Succ Succ n, m
  | back $ Zero, m             <-> iter $ Succ Succ Zero, m
  | back $ Succ Succ Zero, m   <-> iter $ Succ Zero, m
  | back $ Succ Zero, m        <-> iter $ Zero, m
  | back $ Succ Succ Succ n, m <-> back $ n, Succ m
  | n                          <-> back $ n, Zero
  where iter :: Num * Num
        back :: Num * Num

tr

a b

Beispiel:

$ echo "apple" | tr a b
bpple
$ echo "bpple" | tr b a
apple

Nur eine echte Umkehrung in der Domäne von Zeichenfolgen, die nicht sowohl "a" als auch "b" enthalten.

Eine weitere Antwort von Marbelous

Das ursprüngliche Recht verschiebt die Befehlszeileneingabe (einen 8-Bit-Wert) und fügt eine führende hinzu, wenn eine 1 durch Verschieben verloren geht. ( 0000 0001 -> 1000 0000)

{0 ..
~~ ..
>> {0
-2 =0
.. ^0
\/ }0
}0 Sb
<< ..
\\ ..
:Sb
// ..
Sb >>
}0 ..
^7 }0
{0 \/

Drehen dieses Boards um 180 ° (wobei der Inhalt jeder Zelle gleich bleibt) Ändert das Programm so, dass es nach links verschoben wird ( 1000 0000 -> 0000 0001)

\/ {0
}0 ^7
.. }0
>> Sb
.. //
:Sb
.. \\
.. <<
Sb }0
}0 \/
^0 ..
=0 -2
{0 >>
.. ~~
.. {0

Sie können es hier testen . (Sie müssen "Ausgabe als Dezimalzahl anzeigen" aktivieren.)

Erläuterung

Beide Programme bestehen aus zwei Karten, der Hauptkarte (die die Befehlszeileneingabe erhält) und Sb. Werfen wir einen Blick auf beide Versionen der Hauptplatine und betrachten nur die Zellen, die in ihrer jeweiligen Ausrichtung erreicht werden können (da Murmeln normalerweise nicht nach oben gehen können und die Eingabegeräte sich nicht oben befinden):

original:      flipped:
   }0          }0
}0 Sb          .. }0
<< ..          >> Sb
\\ ..          .. //

Das sind ziemlich einfach Bretter, nehmen beide zwei Kopien des Eingangs (die an die Stelle der nehmen }0Zellen. Die Original - Feeds eine Version in eine linke Schaltvorrichtung <<die blätterte Version bringt es auf den richtigen Schaltvorrichtung >>führen diese eine bitshift aber leider Verwerfungs jede Verlorene Bits: Hier kommen die SbKarten ins Spiel. Sie prüfen, ob Bits, die den eingegebenen Wert verschieben, zu einem Bitverlust führen und geben einen Wert zurück, der zum Ergebnis addiert wird, um dem verlorenen Bit entgegenzuwirken.

Hier ist der relevante Teil der Originalkarte Sbfür das Originalprogramm:

}0
^7
{0

Dieser ist unglaublich einfach, `^ 7 'prüft den Wert des höchstwertigen Bits. Wenn dies 1 ist, würde das Durchführen einer Linksverschiebung dazu führen, dass dieses Bit verloren geht. Diese Karte gibt also den Wert dieses Bits als 8-Bit-Wert aus, der zum Ergebnis der Bitverschiebung addiert wird.

Für die gekippte Version Sbmuss man sich das niederwertigste Bit ansehen und zurückgeben 128oder 0, das ist etwas komplizierter:

}0
^0 ..
=0 -2
{0 >>
.. ~~
.. {0

Wenn das niedrigstwertige Bit (wie von getestet ^0) 0 ist, wird nur 0 zurückgegeben. Wenn es eins ist, ^0wird ausgegeben 1. Dies wird den Gleichheitstest mit nicht bestehen 0 =0und somit nach rechts drängen. Wir subtrahieren dann 2 -2, um 255 zu erhalten, verschieben >>uns nach links , um 127 zu erhalten, und führen eine Binärdatei aus ~~, um nicht 128 zu erhalten (wir hätten auch einfach eine hinzufügen können ++, um 128 zu erhalten, aber wo ist der Spaß dabei?)