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 Code-Golf , also gewinnt der kürzeste Code in Bytes.

Bestenliste

var QUESTION_ID=63256,OVERRIDE_USER=20569;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

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");

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.

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

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>

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%

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]

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``

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

RS , 56 Bytes

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

Live-Demo und Testfälle.

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!

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!

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.

Mathematica, 64 Bytes

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

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"))

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")$

Gema, 43

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

( Gema ist eine obskure Makrosprache.)

Pyth, 28 22

Amr`!dZ2jHjLGcR_Hc_z_G

6 Bytes dank Jakube

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

Testsuite

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.

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.

𝔼𝕊𝕄𝕚𝕟 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).

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").

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"

Perl 5, 68 Bytes

67 plus 1 für -Estatt-e

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

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);

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);}}

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'})

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.

Pyth - 18 Bytes

Kann viel mehr golfen werden.

Amr`!dZ2::_z_GH_HG

Test Suite .