Kehre die Wahrheit um

22

Schreiben Sie ein Programm oder eine Funktion, die:

  1. Nimmt einen String aus stdio oder Argumenten auf
  2. ersetzt alle Vorkommen von truemit falseund falsemittrue
  3. kehrt es um, aber nicht um trueundfalse
  4. Gibt das Ergebnis zurück oder druckt es aus

Beispiele (linke Seite ist Eingabe):

"true"                     "false"
"2false"                   "true2"
"true is false"            "true si false"
"false,true,undefined"     "denifednu,false,true"
"stressed-false"           "true-desserts"
"falstrue"                 "falseslaf"
"true false true x"        "x false true false"

Es gelten Standardlücken. Das ist , also gewinnt der kürzeste Code in Bytes.

Bestenliste

Hannes Karppila
quelle
In Schritt 3 ist nur ein Ersatz erforderlich, oder sollten alle Vorkommen ersetzt werden? zB true true false falsewird true true false falseoder true eslaf false eurt?
Gaborsch
Should eurtwurde falseoder true?
Zereges
@Zereges Es ist nicht falsch oder wahr, bevor es umgekehrt ist, also: eurt->true
Hannes Karppila
@HannesKarppila Also, die Regeln werden in der folgenden Reihenfolge angewendet:1 3 2 4 5
Zereges
3
Bedeutet das auch das trufalse -> trueurt?
Adnan

Antworten:

12

C # 6, 144 Bytes

string R(string t)=>string.Concat(new System.Text.RegularExpressions.Regex("true|false").Replace(t,m=>m.Value[0]<'g'?"eurt":"eslaf").Reverse());

Es wird ein regulärer Ausdruck verwendet, um eine Übereinstimmung zu erzielen true|false, und wenn er übereinstimmt true, wird er durch ersetzt eslaf, andernfalls durch eurt. m.Value[0]<'g'Art und Weise ist eine kürzere zu sagen m.Value[0]=="false", weil die einzig möglichen Werte für m.Valuesind "true"oder "false", also , wenn der Zeichencode des ersten Zeichens kleiner ist als der char - Code 'g', es ist "false".

Alte Version, 95 Bytes

Dieser hatte einen Fehler, für den keine korrekte Ausgabe zurückgegeben wurde falstrue.

string R(string t)=>string.Concat(t.Reverse()).Replace("eurt","false").Replace("eslaf","true");
ProgramFOX
quelle
15
AC # -Lösung unter 100 Bytes? Sicher ist das Ende der Tage vor uns.
Alex A.
@AlexA. Haha, alles dank Version 6; P
ProgramFOX
1
Dies funktioniert bei der Eingabe nicht richtig falstrue.
Feersum
2
@AlexA. Nun, mit der falschen Ausgabe für falstrueFixed ist es nicht mehr <100 Bytes ... :(
ProgramFOX
14
Das ist zwar traurig, bedeutet aber, dass wir uns keine Sorgen mehr um die Apokalypse machen müssen. Softwarefehler haben uns alle gerettet.
Alex A.
7

TeaScript , 36 25 24 Bytes

xv¡g("eurt|eslaf",#ln>4)   

TeaScript ist JavaScript zum Golfen.

Änderungen: 11 Bytes dank @ Vɪʜᴀɴ gespeichert. Bei der Eingabe behoben falstrueund ein Byte gespeichert.

Alte Version (ungültig):

xv¡g("eurt",f)g(f.T¡v¡,t)

Erläuterung:

x    // Input
 v¡    // Reverse
   g("eurt",    // Global replace "eurt" with "false".
            f)    // f is predefined to false.
              g(f.T¡v¡, // Convert false to string, then reverse.
                       t) // t is predefined to true.
unerschrockener Kodierer
quelle
Wenn Sie lund ianstelle von tund verwenden f, können Sie das .s weglassen . f ist auch vordefiniert, falsedamit Sie xv¡g(l="eurt",i=f+¢)g(iv¡,lv¡)
Folgendes
Eigentlich noch besser:xv¡g("eurt",f)g(f.T¡v¡,t)
Downgoat
@Vɪʜᴀɴ Danke für die Hilfe. Ich habe das in den Dokumenten nicht gesehen. Wäre es möglich, (nach Methoden automatisch einzufügen ? Ähnlich replace(/(\.[BcCdeE...])/g,"$1(")oder ähnlich nach dem Einfügen von Punkten.
intrepidcoder
1
Dies funktioniert bei der Eingabe nicht richtig falstrue.
Feersum
@feersum Behoben. Vielen Dank für den Hinweis. Das war knifflig.
intrepidcoder
7

Bash + GNU, 45 38 73 Bytes

Bearbeiten: funktioniert mit beiden trufalseundfalstrue

sed s/false/%eurt%/g\;s/true/%eslaf%/g|rev|sed "s/%\(true\|false\)%/\1/g"

Alte Version , 38 Bytes (verkürzt dank Digital Trauma):

rev|sed s/eurt/false/g\;s/eslaf/true/g
gaborsch
quelle
1
Kombinieren Sie die sed-Ausdrücke zu einem und entfernen Sie das "-e" und die Anführungszeichen:rev|sed s/eurt/false/g\;s/eslaf/true/g
Digitales Trauma
2
Dies funktioniert bei der Eingabe nicht richtig falstrue.
Feersum
@feersum Guter Punkt, behoben. Auch geprüft auf trufalse.
Gaborsch
6

JavaScript ES6, 59

Als anonyme Funktion.

Beachten Sie, dass replace nur als Kurzform für match (). Map () verwendet wird. Die ersetzte Zeichenfolge wird verworfen und die Ausgabezeichenfolge wird Stück für Stück rückwärts erstellt (es ist also nicht erforderlich, sie umzukehren).

s=>s.replace(/false|true|./g,x=>s=(x[1]?x<'t':x)+s,s='')&&s

Testen Sie das folgende Snippet in einem EcmaScript 6-kompatiblen Browser.

f=s=>s.replace(/false|true|./g,x=>s=(x[1]?x<'t':x)+s,s='')&&s

//test

console.log=x=>O.innerHTML+=x+'\n'

;[
 ["true","false"]
,["falstrue","falseslaf"]  
,["1false","true1"]
,["true is false","true si false"]
,["false,true,undefined","denifednu,false,true"]
,["stressed-false","true-desserts"]
,["true false true x","x false true false"]
].forEach(t=>console.log(t[0]+' -> '+f(t[0])))
<pre id=O></pre>

edc65
quelle
Kam hierher, um eine erstaunliche 62-Byte-Lösung zu posten ... fand eine unglaubliche 59-Byte-Lösung. +1
ETHproductions
5

Windows Batch, 184 213 Bytes

Fehler behoben falstrue -> falseslafundtrufalse -> trueurt

Wahrscheinlich eine der weniger populären Sprachen:

setlocal enabledelayedexpansion
set /p Q=
set N=0
:L
call set T=%%Q:~%N%,1%%%
set /a N+=1
if not "%T%" equ "" (
set R=%T%%R%
goto L
)
set R=%R:eurt=false%
set R=%R:eslaf=true%
set R=%R:falstrue=falseslaf%
echo %R%
Adnan
quelle
1
Dies funktioniert bei der Eingabe nicht richtig falstrue.
Feersum
@feersum, repariert es :)
Adnan
5

Haskell, 94 Bytes

Führt einen Mustervergleich für die Eingabezeichenfolge durch, sucht nach "false" oder "true" und fügt das Gegenteil zum Ergebnis der Anwendung der Funktion auf den Rest der Zeichenfolge hinzu. Wenn true oder false nicht gefunden wird, wird die Zeichenfolge mithilfe der Rekursion auf dieselbe Weise umgekehrt.

f[]=[]
f('t':'r':'u':'e':s)=f s++"false"
f('f':'a':'l':'s':'e':s)=f s++"true"
f(x:s)=f s++[x]
Craig Roy
quelle
Entschuldigung
Craig Roy
Keine Ursache. Es scheint, als hätte ich einen Fehler gemacht, als ich versucht habe, ihn zu testen. Vielleicht habe ich die Zeichenfolge einfach ausgedruckt, ohne die Funktion anwenden zu können.
Feersum
Ich glaube, Sie können die oberste f[]=[]Zeile nehmen und stattdessen f x=xdie unterste Zeile setzen , um ein Byte zu speichern.
Michael Klein
4

JavaScript ES6, 95 93 Bytes

Unbenannte Funktion. Fügen Sie f=am Anfang hinzu, um es zu verwenden. Danke Ismael! Nimmt auch an, dass die Eingabe keine Tabulatoren enthält.

x=>[...x[r="replace"](/false/g,"\teslaf")[r](/(\t)*true/g,"eurt")[r](/\t/g,"")].reverse().join``
Conor O'Brien
quelle
Sie können verwenden .replace(/eurt/g,false).replace(/eslaf/g,true), da sie in Zeichenfolge konvertiert werden. Versuchen Sie true + ''(sollte zurückkehren 'true')
Ismael Miguel
3
WARTEN!!! Ändern Sie falsemit !1und truemit !0. Dort ein paar Bytes kürzer
Ismael Miguel
3
@IsmaelMiguel whoa danke !!!!
Conor O'Brien
1
Ich denke, Sie sollten auch in der Lage sein, [...x]anstelle von x.split ''
Downgoat
2
67: x=>[...x].reverse().join``[r='replace'](/eurt/g,!1)[r](/eslaf/g,!0). Ich habe auch den Join-Parameter in einen leeren Template-String geändert, um Array-Kommas herauszulösen.
Mama Fun Roll
2

Pyth, 30 Bytes

::_z"eurt""false""eslaf""true"

Dies kehrt die Eingabe ( _z), die "eurt"für "false"und "eslaf"für ersetzt, um "true". Der Austausch erfolgt mit :.

Probieren Sie es online aus

Alex A.
quelle
Sie können "true"und "false"als Variable: deklarieren und =d"true"=k"false"::_z_dk_kdumgekehrt verwenden. Es werden 3 Bytes gespart.
Adnan
::_zJ"eurt"K"false"_K_Jist 23 Bytes.
PurkkaKoodari
5
Dies funktioniert bei der Eingabe nicht richtig falstrue.
Feersum
2

RS , 56 Bytes

\t
+(.*\t)(.)(.*)/\2\1\3
\t/
eurt/fals\t
eslaf/true
\t/e

Live-Demo und Testfälle.

kirbyfan64sos
quelle
1
Dies funktioniert bei der Eingabe nicht richtig falstrue.
Feersum
@feersum Ugh ... auch nicht die Pyth-Antwort, FYI ...
kirbyfan64sos
Mindestens 7 Antworten haben dieses Problem, das ich getestet habe
feersum
@feersum Ok; Ich habe es jetzt behoben.
kirbyfan64sos
2

Julia, 59 55 46 Bytes

s->replace(reverse(s),r"eurt|eslaf",i->i<"et")

Dadurch wird eine unbenannte Funktion erstellt, die eine Zeichenfolge akzeptiert und eine Zeichenfolge zurückgibt. Um es zu nennen, geben Sie ihm einen Namen, z f=s->....

Die Eingabe wird mit umgekehrt reverse. Wir stimmen mit dem regulären Ausdruck eurt|eslafüberein, der übereinstimmt trueoder falserückwärts. Auf das Match wird eine Funktion angewendet, die zurückgibt, truewenn das Match lexikografisch kleiner als et(dh eslaf) ist, und falseansonsten. Die booleschen Literale werden in der Ausgabe in einen String konvertiert.

9 Bytes gespart und ein Problem dank Glen O behoben!

Alex A.
quelle
2
Ich glaube nicht, dass dies für die Eingabe richtig funktioniert falstrue.
Feersum
Es verwendet die gleichen grundlegenden Überlegungen, also werde ich es Ihnen anbieten: s->replace(reverse(s),r"eurt|eslaf",i->i<"et")- Verwendet einen regulären Ausdruck anstatt es zweimal zu tun, und eine Funktion für das Ersetzen, die bewertet, trueob es "elsaf" war und falseob es "eurt" war. 46 Bytes.
Glen O
Oh, und es behebt auch das falstrueProblem.
Glen O
@ GlenO Das ist großartig, danke
Alex A.
@feersum Jetzt behoben
Alex A.
2

Javascript, 135 Bytes

function(s){return s.split("").reverse().join("").replace(/eslaf/i,'☺').replace(/eurt/i,'☻').replace(/☻/g,!1).replace(/☺/g,!1)}

Prüfung:

=>"falsch ist das Gegenteil von wahr"

<="wahr für etisoppo eht si falsch"

Vielen Dank an ProgramFOX und edc65 für den Hinweis auf einen Fehler!

Fuzzyzilla
quelle
Willkommen bei Programming Puzzles & Code Golf! Die Frage fordert ein vollständiges Programm oder eine Funktion an, also nicht nur einen Codeausschnitt, der davon ausgeht, dass eine Variable sexistiert. Außerdem funktioniert Ihr Code nicht für falstrue: er sollte ausgegeben werden falseslaf, nicht trueslaf. Möchten Sie diese Probleme beheben? Vielen Dank! :)
ProgramFOX
@ProgramFOX Vielen Dank! Darauf komme ich gleich an!
Fuzzyzilla,
1
Sie können ein paar Bytes speichern , wenn Sie ES6 verwenden, hat sie diese Pfeil-Funktion Syntax: f=s=>s.split(""). ....
ProgramFOX
Dies ist sowohl zu komplex als auch falsch. Testen Sie mit 'false1' oder 'true0' oder 'true1'
edc65
@ edc65 Warum danke, mein Herr!
Fuzzyzilla
2

Java, 162 98 92 Bytes

Vielen Dank (und sorry! ~) An @DanielM. für das Erzählen von StringBuffer und der Tatsache, dass wir Funktionen verwenden können!

Weil Sie wissen, Java.

s -> ("" + neuer StringBuffer (s.replaceAll ("false", "eurt")). reverse ()). replaceAll ("eurt", "false");

Gibt die korrekte, umgekehrte Zeichenfolge zurück.

Ungolfed Version:

s-> neuer StringBuilder (
    s.replaceAll ("false", "eurt")
    .reverse (). toString (). replaceAll ("eurt", "false");

Grundsätzlich ersetze ich alle Instanzen von "false" durch ein rückwärts gerichtetes "true", kehre dann die gesamte Zeichenfolge um und ersetze dann die jetzt rückwärts gerichteten Versionen von "true" (nicht die, die ich gerade ersetzt habe) durch "false". Kinderleicht.

Addison Crump
quelle
StringBuffer ist ein Byte kürzer. Auch Funktionen sind erlaubt.
Daniel M.
Ich bereite eine weitere Antwort in einer anderen Sprache vor, damit Sie diese behalten können
Daniel M.
Das returnist implizit, wenn es sich um einzeilige Lambdas handelt
Daniel M.
4
Java schlägt Python? Jetzt haben wir bestimmt das Ende
Downgoat
1
@GaborSch Nifty. : P Danke!
Addison Crump
1

Mathematica, 64 Bytes

StringReverse@#~StringReplace~{"eurt"->"false","eslaf"->"true"}&
LegionMammal978
quelle
1

Python 3, 68 100 Bytes

Ich bin golfing es immer noch, aber es ist auf den Bug behoben, so falstrue -> falselsafundtrufalse -> trueurt

Ziemlich einfach:

print(input()[::-1].replace("eurt","false").replace("eslaf","true").replace("falstrue","falseslaf"))
Adnan
quelle
3
Dies funktioniert bei der Eingabe nicht richtig falstrue.
Feersum
Dies kann leicht behoben werden, indem die Anweisungen zum Ersetzen ( print(input()[::-1].replace("eslaf","true").replace("eurt","false")))
Beta-Zerfall
@BetaDecay, das wird nicht funktionieren, denn es trufalsewird trufalse, während es sein musstrueurt
Adnan
@Adriandmen Da dies jedoch nicht zu den Beispiel-E / As gehört, reicht es für den Moment :)
Beta Decay
@BetaDecay Haha, sie werden es nicht bemerken :)
Adnan
1

Japt, 26 Bytes

Hinweis: Dies kann ungültig sein, da Fehlerbehebungen erforderlich sind, die nach dem Posten dieser Herausforderung vorgenommen wurden.

Uw r"eurt|eslaf",X=>X<"et"

Probieren Sie es im Online-Dolmetscher aus ! (Für die Pfeilfunktion ist ein ES6-kompatibler Browser wie Firefox erforderlich.)

Wie es funktioniert

             // Implicit: U = input string
Uw r         // reverse U, then replace:
"eurt|eslaf" // occurrences of either "eurt" or "eslaf"
X=>X<"et"    // with "false" or "true", respectively
             // Implicit: output last expression

Hier ist eine Version, die vor den Bugfixes funktioniert hat: (38 Bytes)

Uw $.replace(/eurt|eslaf/g,X=>X<"et")$
ETHproductions
quelle
1

Gema, 43

*=@a{@reverse{*}};a:eurt=false;a:eslaf=true

( Gema ist eine obskure Makrosprache.)

Steven Taschuk
quelle
1

Pyth, 28 22

Amr`!dZ2jHjLGcR_Hc_z_G

6 Bytes dank Jakube

Funktioniert korrekt für falstrue, wie in der Suite unten gezeigt.

Testsuite

FryAmTheEggman
quelle
Nein, ich glaube, ich habe einen Fehler gemacht. Ihre 22-Byte-Lösung ist korrekt.
Jakube
1

Haskell, 102 Bytes

h('t':'r':'u':'e':s)="eslaf"++h s
h('f':'a':'l':'s':'e':s)="eurt"++h s
h(x:s)=x:h s
h[]=""
r=reverse.h

Das Ersetzen von "wahr" durch "falsch" und umgekehrt ist bei der Mustererkennung ziemlich langwierig, aber es handelt sich zumindest korrekt um "falstrue" und dergleichen. Außerdem vermute ich, dass eine korrekte, auf Regex basierende Version etwas länger dauern würde.

arjanen
quelle
1

Python 3 - 108 92 Bytes

import re
print(re.sub("eslaf|eurt",lambda m:repr(len(m.group(0))>4).lower(),input()[::-1]))

Verwendet einen regulären Ausdruck, um eine Übereinstimmung mit "true" oder "false" zu erzielen, und verwendet ein Lambda, um Übereinstimmungen zu verarbeiten und auszuwählen, was als Ersatzzeichenfolge verwendet werden soll. Bei Verwendung von repr wird die Zeichenfolgendarstellung von (len (match)> 4) abgerufen, die "True" ergibt, wenn "false" abgeglichen wird, und umgekehrt des Spiels und beenden durch Umkehren der Ersetzung und dann die verarbeitete Eingabe mit [:: - 1]

Es ist gelungen, die Länge durch TFelds-Vorschläge um 16 Byte zu verringern.

Bearbeiten: Python ist wieder vor Java, kein Grund zur Beunruhigung.

Phyxie
quelle
5
Wir fordern hier, dass Programme für alle Eingaben funktionieren, nicht nur für die gegebenen Testfälle.
Lirtosiast
Sie können 6 Bytes speichern , indem Sie die Zeichenfolge ersten Umkehr, und dann ersetzt (Speichern eines [::-1]) print(re.compile("eslaf|eurt").sub(lambda m:repr(m.group(0)!="eurt").lower(),input()[::-1]))
TFeld
Sie können auch davonkommen, wenn Sie re.compile nicht verwenden. print(re.sub("eslaf|eurt",lambda m:repr(m.group(0)!="eurt").lower(),input()[::-1])) Change m.group(0)!="eurt"to len(m.group(0))>4(für 1 weitere)
TFeld
1

𝔼𝕊𝕄𝕚𝕟 40 Zeichen / 65 Bytes

ô[…ïċ/false|true/g,⇏[…⬯+!שúa]ù⬮ø⬯)]ù⬮ø⬯)

Try it here (Firefox only).

Vielen Dank an @feersum für den Hinweis auf einen Fehler!

21 Zeichen / 43 Byte, nicht wettbewerbsfähig

ôᴙ(ïċ/⊭|⊨⌿,↪ᴙ(⬯+!ë$⸩⸩

Try it here (Firefox only).

Mama Fun Roll
quelle
2
Dies funktioniert bei der Eingabe nicht richtig falstrue.
Feersum
1

Prolog, 225 Bytes

p(X):-string_to_list(X,L),reverse(L,B),q(B,C),string_to_list(Z,C),write(Z),!.
q([],[]).
q([101,117,114,116|T],[102,97,108,115,101|L]):-q(T,L).
q([101,115,108,97,102|T],[116,114,117,101|L]):-q(T,L).
q([H|T],[H|L]):-q(T,L).

Probieren Sie es hier online aus.
Führen Sie die Abfrage folgendermaßen aus:

p("falstrue").
Emigna
quelle
0

Ruby, 55 Bytes

->s{s.gsub(/true|false/){$&[?t]?:eslaf: :eurt}.reverse}

Prüfung:

->s{s.gsub(/true|false/){$&[?t]?:eslaf: :eurt}.reverse}["false,true,undefined"]
=> "denifednu,false,true"
daniero
quelle
0

Perl 5, 68 Bytes

67 plus 1 für -Estatt-e

%a=(false,eurt,true,eslaf);say~~reverse<>=~s/false|true/$a{$&}/gr
msh210
quelle
0

OpenSCAD, 178 Byte

(Beachten Sie, dass hierbei die String Theory-Bibliothek verwendet wird , da OpenSCAD nicht genau über eine Standardbibliothek verfügt. Außerdem handelt es sich um eine Funktion, da die einzige zulässige Eingabe darin besteht, diese fest zu codieren.

use <Strings.scad>;function f(a)=contains(g(a),"eurt")?replace(g(a),"eurt","false"):g(a);function g(a)=contains(reverse(a),"eslaf")?replace(reverse(a),"eslaf","true"):reverse(a);
Daniel M.
quelle
0

C # 260 Bytes

using System;class P{static void Main(){var y=Console.ReadLine();char[] n=y.ToCharArray();Array.Reverse(n);var s=new string(n);if(s.Contains("eslaf")){s=s.Replace("eslaf","true");}if(s.Contains("eurt")){s=s.Replace("eurt","false");}Console.WriteLine(s);}}
Belfield
quelle
Dies ist mein erster (echter) Beitrag - ich habe gesehen, dass jemand, der C # oben verwendet, Folgendes nicht eingeschlossen hat: using system; Klasse P {}, static void main (), Console.WriteLine (); oder Console.ReadLine () ;. Diese nehmen offensichtlich eine Menge Bytes für mich in Anspruch - wenn es eine Möglichkeit gibt, das zu spielen, oder wenn es vom Code-Golf ausgeschlossen ist - lass es mich wissen :)
Belfield
0

PHP, 60 Bytes

Einfach, kehrt die Zeichenfolge zuerst um und ersetzt dann die umgekehrten Versionen durch ihre jeweiligen Auslagerungspositionen.

Aus "falstrue" wird "eurtslaf" wird "falseslaf".

<?=strtr(strrev($argv[1]),{'eurt'=>'false','eslaf'=>'true'})
Xanderhall
quelle
0

Perl 5.10, 54 Bytes

$_=reverse<>;s/(eurt)|(eslaf)/$1?"false":"true"/eg;say

Rückwärts fahren, dann austauschen. Eine andere Methode, als die Hash-Tabelle, die für die andere Perl-Antwort verwendet wird und die am Ende kürzer ist!

Probieren Sie es online aus.

Paul Picard
quelle
-1

Pyth - 18 Bytes

Kann viel mehr golfen werden.

Amr`!dZ2::_z_GH_HG

Test Suite .

Maltysen
quelle
6
Dies funktioniert bei der Eingabe nicht richtig falstrue.
Feersum