Inverta a verdade

22

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

Mostrar snippet de código

code-golf  string  code-golf  string  ascii-art  code-golf  string  code-golf  quine  polyglot  code-golf  math  string  code-golf  internet 
— Hannes Karppila
fonte
Na etapa 3, apenas uma substituição é necessária ou todas as ocorrências devem ser substituídas? por exemplo, true true false falsetorna true true false false- se ou true eslaf false eurt?
— Gaborsch
Deveria eurtse tornar falseou true?
— Zereges
@Zereges Não é falso ou verdadeiro antes de ser revertido, então: eurt->true
— Hannes Karppila
@HannesKarppila Então, as regras são aplicadas em ordem:1 3 2 4 5
— Zereges
3
Isso também significa isso trufalse -> trueurt?
— Adnan

Respostas:

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

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");
— ProgramFOX
fonte
15
Solução CA # com menos de 100 bytes? Certamente o fim dos dias está chegando.
— Alex A.
@AlexA. Haha, tudo graças à versão 6; P
— ProgramFOX
1
Isso não funciona corretamente para a entrada falstrue.
— precisa saber é
2
@AlexA. Bem, com a saída incorreta para falstruefixa, não é mais <100 bytes ... :(
— ProgramFOX
14
Embora isso seja realmente triste, significa que não precisamos mais nos preocupar com o apocalipse. Os erros de software nos salvaram a todos.
— Alex A.
7

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.
— intrepidcoder
fonte
Se você usar le em ivez de te f, poderá omitir os .s. f também é predefinido para falseque você possa obter:xv¡g(l="eurt",i=f+¢)g(iv¡,lv¡)
— Downgoat 7/11/15
Na verdade ainda melhor:xv¡g("eurt",f)g(f.T¡v¡,t)
— Downgoat 7/11/15
@ Vɪʜᴀɴ Obrigado pela ajuda. não vi isso nos documentos. Seria possível inserir automaticamente (após métodos? Semelhante replace(/(\.[BcCdeE...])/g,"$1(")ou semelhante após inserir períodos.
— intrepidcoder
1
Isso não funciona corretamente para a entrada falstrue.
— precisa saber é
@feersum Fixed. Obrigado por apontar isso. Isso foi complicado.
— Intrepidcoder
7

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
— gaborsch
fonte
1
Combine as expressões sed em uma e remova o "-e" e aspas:rev|sed s/eurt/false/g\;s/eslaf/true/g
— Digital Trauma
2
Isso não funciona corretamente para a entrada falstrue.
— feersum
@feersum Bom ponto, fixo. Também verificado trufalse.
— Gaborsch #
6

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>
Expandir snippet

— edc65
fonte
Veio aqui para postar uma incrível solução de 62 bytes ... encontrada uma solução incrível de 59 bytes. +1
— ETHproductions
5

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%
— Adnan
fonte
1
Isso não funciona corretamente para a entrada falstrue.
— precisa saber é
@feersum, fixa-lo :)
— Adnan
5

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]
— Craig Roy
fonte
Adicionado agora, desculpe por isso
— Craig Roy
Deixa pra lá. Parece que cometi algum erro ao tentar testá-lo. Talvez eu simplesmente tenha imprimido a string sem conseguir aplicar a função a ela.
— precisa saber é
Acredito que você pode pegar a f[]=[]linha superior e colocar f x=xna parte inferior para salvar um byte.
— Michael Klein
4

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``
— Conor O'Brien
fonte
Você pode usar .replace(/eurt/g,false).replace(/eslaf/g,true), pois eles serão convertidos em string. Tente true + ''(deve retornar 'true')
— Ismael Miguel
3
ESPERAR!!! Mude falsecom !1e truecom !0. Lá, alguns bytes mais curtos
— Ismael Miguel
3
@IsmaelMiguel whoa thanks !!!!
— Conor O'Brien
1
Eu acho que você também deve ser capaz de usar em [...x]vez de x.split ''
— Downgoat 7/15/15
2
67: x=>[...x].reverse().join``[r='replace'](/eurt/g,!1)[r](/eslaf/g,!0). Também mudei o parâmetro de junção para uma sequência de modelo vazia para retirar as vírgulas da matriz.
— Mama Fun Roll
2

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!

— Alex A.
fonte
2
Não acredito que isso funcione corretamente para a entrada falstrue.
— precisa saber é
Ele está usando o mesmo raciocínio básico, então eu o ofereço a você: s->replace(reverse(s),r"eurt|eslaf",i->i<"et")- usa um regex em vez de fazê-lo duas vezes, e uma função para a substituição que avalia truese foi "elsaf" e falsese foi "eurt". 46 bytes.
— Glen O
Ah, e também corrige o falstrueproblema.
— Glen O
@GlenO Isso é ótimo, graças
— Alex A.
@feersum Corrigido agora
— 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)}

Teste:

=>"false é o oposto de true"

<="verdadeiro para etisoppo eht si falso"

Obrigado ProgramFOX e edc65 por apontar um erro!

— Fuzzyzilla
fonte
Bem-vindo à programação de quebra-cabeças e código de golfe! A pergunta solicita um programa ou uma função completa, portanto, não apenas um trecho de código que assume que sexiste uma variável . Além disso, seu código não funciona falstrue: ele deve gerar falseslaf, não trueslaf. Deseja corrigir esses problemas? Obrigado! :)
— ProgramFOX
@ProgramFOX Thank you! Eu vou direto nisso!
— Fuzzyzilla
1
Você pode economizar alguns bytes se você usar ES6, ele tem essa sintaxe da função de seta: f=s=>s.split(""). ....
— precisa
Isso é excessivamente complexo e errado. Teste com 'false1' ou 'true0' ou 'true1'
— edc65 08/11/2015
@ edc65 Por que obrigado, gentil senhor!
— Fuzzyzilla
2

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.

— Addison Crump
fonte
StringBuffer é um byte mais curto. Além disso, funções são permitidas.
— Daniel M.
Estou preparando outra resposta em um idioma diferente, para que você possa manter isso
— Daniel M.
O returnestá implícita quando se lida com lambdas de uma linha
— Daniel M.
4
Java venceu o Python? Agora certamente o fim está sobre nós
— Downgoat
1
@GaborSch Nifty. : P Obrigado!
— Addison Crump
1

Mathematica, 64 bytes

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

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"))
— Adnan
fonte
3
Isso não funciona corretamente para a entrada falstrue.
— precisa saber é
Isso pode ser facilmente remediado alternando as instruções de substituição ( print(input()[::-1].replace("eslaf","true").replace("eurt","false")))
— Decay Beta 8/15
@BetaDecay, que não vai funcionar, porque trufalsese torna trufalse, ao mesmo tempo ele precisa sertrueurt
— Adnan
@Adriandmen No entanto, isso não é um do exemplo I / Os por isso será suficiente para agora :)
— Beta Decay
@BetaDecay Haha, não vai notar :)
— Adnan
1

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")$
— ETHproductions
fonte
1

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

— FryAmTheEggman
fonte
Não, acho que cometi um erro. Você solução de 22 bytes está correta.
— Jakube 9/11
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

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.

— arjanen
fonte
1

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.

— Phyxie
fonte
5
Exigimos aqui que os programas funcionem para todas as entradas, não apenas para os casos de teste fornecidos.
— lirtosiast
Você pode salvar 6 bytes, invertendo a seqüência primeiro, e depois substituindo (uma economia de [::-1]) print(re.compile("eslaf|eurt").sub(lambda m:repr(m.group(0)!="eurt").lower(),input()[::-1]))
— TFeld
Você também pode começar afastado com não usar re.compile print(re.sub("eslaf|eurt",lambda m:repr(m.group(0)!="eurt").lower(),input()[::-1])) Mudar m.group(0)!="eurt"para len(m.group(0))>4(para 1 mais)
— TFeld
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).

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

p("falstrue").
— Emigna
fonte
0

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"
— daniero
fonte
0

Perl 5, 68 bytes

67 mais 1 para em -Evez de-e

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

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);
— Daniel M.
fonte
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
fonte
Este é o meu primeiro post (real) - eu vi alguém usando c # acima não incluir: using system; classe P {}, static void main (), Console.WriteLine (); ou Console.ReadLine () ;. Estes, obviamente, assumir um monte de bytes para mim - se há uma forma de golfe que ou se ele será excluído do código-golf - deixe-me saber :)
— Belfield
0

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'})
— Xanderhall
fonte
0

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.

— Paul Picard
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.