Escreva um programa ou função que:

1. recebe uma string de stdio ou argumentos
2. substitui todas as ocorrências de truecom falsee falsecomtrue
3. inverte-o, mas não inverte trueefalse
4. retorna ou imprime o resultado

Exemplos (o lado esquerdo é inserido):

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

Aplicam-se brechas padrão. Isso é código-golfe , então o código mais curto em bytes vence.

Entre os melhores

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

Ele usa uma expressão regular para corresponder true|falsee, se corresponder true, será substituído por eslaf, caso contrário, por eurt. m.Value[0]<'g'é uma maneira mais curta de dizer m.Value[0]=="false", porque os únicos valores possíveis para m.Valuesão "true"ou "false", portanto, se o código do primeiro caractere for menor que o código de 'g', é "false".

Versão antiga, 95 bytes

Este teve um bug, não retornou a saída correta para 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 é JavaScript para jogar golfe.

Edições: salvou 11 bytes graças a @ Vɪʜᴀɴ. Corrigido para entrada falstruee salvo um byte.

Versão antiga (inválida):

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

Explicação:

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

Editar: trabalha com ambos trufalseefalstrue

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

Versão antiga , 38 bytes (reduzida, graças ao Digital Trauma):

rev|sed s/eurt/false/g\;s/eslaf/true/g

JavaScript ES6, 59

Como uma função anônima.

Observe que substituir é usado apenas como uma abreviação de match (). Map (). A string substituída é descartada e a string de saída é feita peça por peça para trás (portanto, não é necessário reverter).

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

Teste a execução do snippet abaixo em um navegador compatível com EcmaScript 6.

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>

Lote do Windows, 184 213 bytes

Corrigido o erro falstrue -> falseslafetrufalse -> trueurt

Provavelmente um dos idiomas menos populares:

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

Executa a correspondência de padrões na string de entrada, procurando "false" ou "true" e acrescenta o oposto ao resultado da aplicação da função no restante da string. Se true ou false não for encontrado, ele usa a recursão para reverter a string da mesma maneira.

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

Função sem nome. Adicione f=ao começo para usá-lo. Obrigado Ismael! Também assume que a entrada não contém guias.

x=>[...x[r="replace"](/false/g,"\teslaf")[r](/(\t)*true/g,"eurt")[r](/\t/g,"")].reverse().join``

Pitão, 30 bytes

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

Isso inverte a entrada ( _z), substitui "eurt"por "false"e "eslaf"para "true". A substituição é feita usando :.

Experimente online

rs , 56 bytes

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

Demonstração ao vivo e casos de teste.

Julia, 59 55 46 bytes

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

Isso cria uma função sem nome que aceita uma string e retorna uma string. Para chamá-lo, dê um nome, por exemplo f=s->....

A entrada é revertida usando reverse. Combinamos com a expressão regular eurt|eslafque corresponde trueou falseretrocede. Para a correspondência, aplicamos uma função que retorna truese a correspondência for lexicograficamente menor que et(ie eslaf) e falsecaso contrário. Os literais booleanos são convertidos em string na saída.

Economizou 9 bytes e corrigiu um problema graças ao Glen O!

Javascript, 135 bytes

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

Teste:

=>"false é o oposto de true"

<="verdadeiro para etisoppo eht si falso"

Obrigado ProgramFOX e edc65 por apontar um erro!

Java, 162 98 92 bytes

Obrigado (e desculpe! ~) A @DanielM. por me falar sobre o StringBuffer e o fato de podermos usar funções!

Porque, você sabe, Java.

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

Retorna a sequência correta e invertida.

Versão Ungolfed:

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

Basicamente, substituo todas as instâncias de "false" por uma "true" reversa, depois inverto a string inteira e substituo as versões agora anteriores de "true" (não as que acabei de substituir) por "false". Mole-mole.

Mathematica, 64 bytes

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

Python 3, 68 100 bytes

Ainda estou jogando golfe, mas está corrigido para o bug, então falstrue -> falselsafetrufalse -> trueurt

Bem direto:

print(input()[::-1].replace("eurt","false").replace("eslaf","true").replace("falstrue","falseslaf"))

Japonês, 26 bytes

Nota: Isso pode ser inválido, pois exige correções de erros feitas após o lançamento deste desafio.

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

Experimente no intérprete online ! (A função Seta requer um navegador compatível com ES6, como o Firefox.)

Como funciona

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

Aqui está uma versão que funcionou antes da correção do bug: (38 bytes)

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

Gema, 43

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

( Gema é uma linguagem macro obscura.)

Pyth, 28 22

Amr`!dZ2jHjLGcR_Hc_z_G

6 bytes graças a Jakube

Funciona corretamente para falstrue, como mostrado no conjunto abaixo.

Suíte de teste

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

A substituição de "true" por "false" e vice-versa é bastante longa com a correspondência de padrões, mas pelo menos lida corretamente com "falstrue" e similares. Além disso, suspeito que uma versão correta baseada em regex seria um pouco mais longa.

Python 3-108 bytes

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

Usa um regex para corresponder em "true" ou "false" e usa um lambda para processar correspondências e escolher o que usar como uma sequência de substituição. O uso de repr obtém a representação de string de (len (match)> 4) que fornece "True" quando "false" é correspondido e vice-versa (e usa .lower () porque repr (bool) fornece uma string em maiúscula) para obter o inverso da partida e termine revertendo a substituição e depois a entrada processada usando [:: - 1]

Conseguiu reduzir 16 bytes de comprimento das sugestões do TFelds.

Edit: Python está de volta na frente do java, sem necessidade de alarme.

, 40 caracteres / 65 bytes

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

Try it here (Firefox only).

Obrigado a @feersum por apontar um bug!

21 caracteres / 43 bytes, não competitivo

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

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

Experimente on-line aqui.
Execute a consulta da seguinte maneira:

p("falstrue").

Ruby, 55 bytes

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

Teste:

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

Perl 5, 68 bytes

67 mais 1 para em -Evez de-e

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

OpenSCAD, 178 bytes

(Observe que isso usa a biblioteca String Theory , pois o OpenSCAD não possui exatamente uma biblioteca padrão. Além disso, essa é uma função porque a única entrada permitida é codificá-la.

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

Simples, inverte a sequência primeiro e, em seguida, substitui as versões invertidas por seus respectivos swaps.

"falstrue" se torna "eurtslaf" se torna "falseslaf".

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

Perl 5.10, 54 bytes

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

Inverta e substitua. Uma maneira diferente de fazer isso além da tabela de hash usada para a outra resposta Perl, que acaba sendo mais curta!

Experimente online.

Pitão - 18 bytes

Pode ser jogado muito mais.

Amr`!dZ2::_z_GH_HG

Conjunto de Teste .