Invertir la verdad

22

Escriba un programa o función que:

  1. toma una cadena de stdio o argumentos
  2. reemplaza todas las ocurrencias de truecon falsey falsecontrue
  3. lo invierte, pero no lo invierte trueyfalse
  4. devuelve o imprime el resultado

Ejemplos (se ingresa el lado izquierdo):

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

Se aplican lagunas estándar. Este es el , por lo que gana el código más corto en bytes.

Tabla de clasificación

Hannes Karppila
fuente
En el Paso 3, ¿solo se requiere un reemplazo, o se deben reemplazar todos los eventos? por ejemplo, se true true false falseconvierte en true true false falseo true eslaf false eurt?
gaborsch
Debería eurtser falseo true?
Zereges
@Zereges No es falso o verdadero antes de que se invierta, así que: eurt->true
Hannes Karppila, el
@HannesKarppila Entonces, las reglas se aplican en orden:1 3 2 4 5
Zereges
3
¿Esto también significa eso trufalse -> trueurt?
Adnan

Respuestas:

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

Utiliza una expresión regular para hacer coincidir true|false, y si coincide true, será reemplazado por eslaf, de lo contrario, por eurt. m.Value[0]<'g'es una forma más corta de decir m.Value[0]=="false", porque los únicos valores posibles para m.Valueson "true"o "false", por lo tanto, si el código de caracteres del primer carácter es más pequeño que el código de caracteres 'g', es "false".

Versión anterior, 95 bytes

Este tenía un error, no devolvió la salida correcta para falstrue.

string R(string t)=>string.Concat(t.Reverse()).Replace("eurt","false").Replace("eslaf","true");
ProgramFOX
fuente
15
¿Solución AC # de menos de 100 bytes? Seguramente el fin de los días está sobre nosotros.
Alex A.
@AlexA. Jaja, todo gracias a la versión 6; P
ProgramFOX
1
Esto no funciona correctamente para la entrada falstrue.
fiesta del
2
@AlexA. Bueno, con la salida incorrecta para falstruefijo, ya no es <100 bytes ... :(
ProgramFOX
14
Si bien eso es triste, significa que ya no tenemos que preocuparnos por el apocalipsis. Los errores de software nos han salvado a todos.
Alex A.
7

TeaScript , 36 25 24 bytes

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

TeaScript es JavaScript para jugar al golf.

Ediciones: Guardado 11 bytes gracias a @ Vɪʜᴀɴ. Se corrigió la entrada falstruey se guardó un byte.

Versión anterior (inválida):

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

Explicación:

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.
codificador intrépido
fuente
Si usa ly en ilugar de ty f, puede omitir el .s. f también está predefinido para falseque pueda obtener:xv¡g(l="eurt",i=f+¢)g(iv¡,lv¡)
Downgoat
En realidad aún mejor:xv¡g("eurt",f)g(f.T¡v¡,t)
Downgoat
@ Vɪʜᴀɴ Gracias por la ayuda. No vi eso en los documentos. ¿Sería posible insertar automáticamente (después de los métodos? Me gusta replace(/(\.[BcCdeE...])/g,"$1(")o similar después de insertar períodos.
intrepidcoder
1
Esto no funciona correctamente para la entrada falstrue.
fiesta del
@feersum fijo. Gracias por señalar eso. Eso fue complicado.
intrepidcoder
7

Bash + GNU, 45 38 73 bytes

Editar: funciona con ambos trufalseyfalstrue

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

Versión anterior , 38 bytes (acortada, gracias a Digital Trauma):

rev|sed s/eurt/false/g\;s/eslaf/true/g
gaborsch
fuente
1
Combina las expresiones sed en una, y elimina el "-e" y las comillas:rev|sed s/eurt/false/g\;s/eslaf/true/g
Digital Trauma
2
Esto no funciona correctamente para la entrada falstrue.
fiesta del
@feersum Buen punto, fijo. También verificado para trufalse.
gaborsch
6

JavaScript ES6, 59

Como una función anónima.

Tenga en cuenta que reemplazar se usa solo como una abreviatura de match (). Map (). La cadena reemplazada se descarta, y la cadena de salida se hace pieza por pieza hacia atrás (por lo que no es necesario invertir).

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

Pruebe a ejecutar el fragmento a continuación en un navegador compatible con 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>

edc65
fuente
Vine aquí para publicar una increíble solución de 62 bytes ... encontré una increíble solución de 59 bytes. +1
ETHproductions
5

Lote de Windows, 184 213 bytes

Se corrigió el error falstrue -> falseslafytrufalse -> trueurt

Probablemente uno de los 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
fuente
1
Esto no funciona correctamente para la entrada falstrue.
fiesta del
@feersum, lo arregló :)
Adnan
5

Haskell, 94 bytes

Realiza la coincidencia de patrones en la cadena de entrada, busca "falso" o "verdadero" y agrega lo contrario al resultado de aplicar la función en el resto de la cadena. Si no se encuentra verdadero o falso, utiliza la recursión para invertir la cadena de la misma manera.

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
fuente
Agregado ahora, perdón por eso
Craig Roy
No importa. Parece que cometí un error al intentar probarlo. Tal vez simplemente imprimí la cadena sin lograr aplicarle la función.
feersum
Creo que puede tomar la f[]=[]línea superior y en su lugar poner f x=xla parte inferior para guardar un byte.
Michael Klein
4

JavaScript ES6, 95 93 bytes

Función sin nombre Añadir f=al principio para usarlo. Gracias Ismael! También supone que la entrada no contiene pestañas.

x=>[...x[r="replace"](/false/g,"\teslaf")[r](/(\t)*true/g,"eurt")[r](/\t/g,"")].reverse().join``
Conor O'Brien
fuente
Puede usar .replace(/eurt/g,false).replace(/eslaf/g,true), ya que se convertirán en cadena. Prueba true + ''(debería regresar 'true')
Ismael Miguel
3
¡¡¡ESPERE!!! Cambiar falsecon !1y truecon !0. Allí, unos pocos bytes más cortos
Ismael Miguel
3
@IsmaelMiguel whoa gracias !!!!
Conor O'Brien el
1
Creo que también deberías poder usar en [...x]lugar de x.split ''
Downgoat
2
67: x=>[...x].reverse().join``[r='replace'](/eurt/g,!1)[r](/eslaf/g,!0). También cambié el parámetro de unión a una cadena de plantilla vacía para eliminar comas de matriz.
Mama Fun Roll
2

Pyth, 30 bytes

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

Esto invierte la entrada ( _z), sustituye "eurt"por "false"y "eslaf"para "true". El reemplazo se realiza usando :.

Pruébalo en línea

Alex A.
fuente
Puede declarar "true"y "false"como una variable:, =d"true"=k"false"::_z_dk_kdy usar el reverso de la misma. Ahorrará 3 bytes.
Adnan
::_zJ"eurt"K"false"_K_Jes de 23 bytes.
PurkkaKoodari
55
Esto no funciona correctamente para la entrada falstrue.
fiesta del
2

rs , 56 bytes

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

Demostración en vivo y casos de prueba.

kirbyfan64sos
fuente
1
Esto no funciona correctamente para la entrada falstrue.
Feersum
@feersum Ugh ... tampoco responde Pyth, para tu información ...
kirbyfan64sos
Al menos 7 respuestas tienen este problema que he probado
feersum
@feersum Ok; Lo arreglé ahora.
kirbyfan64sos
2

Julia, 59 55 46 bytes

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

Esto crea una función sin nombre que acepta una cadena y devuelve una cadena. Para llamarlo, dale un nombre, por ejemplo f=s->....

La entrada se invierte usando reverse. Hacemos coincidir en la expresión regular eurt|eslafque coincide trueo al falserevés. Para la coincidencia aplicamos una función que devuelve truesi la coincidencia es lexicográficamente menor que et(es decir eslaf) y de lo falsecontrario. Los literales booleanos se convierten en cadenas en la salida.

¡Ahorré 9 bytes y solucioné un problema gracias a Glen O!

Alex A.
fuente
2
No creo que esto funcione correctamente para la entrada falstrue.
fiesta del
Está utilizando el mismo razonamiento básico, por lo que se lo ofreceré: s->replace(reverse(s),r"eurt|eslaf",i->i<"et")utiliza una expresión regular en lugar de hacerlo dos veces, y una función para el reemplazo que evalúa truesi fue "elsaf" y falsesi fue "eurt". 46 bytes.
Glen O
Ah, y también soluciona el falstrueproblema.
Glen O
@GlenO Eso es genial, gracias
Alex A.
@feersum Corregido ahora
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)}

Prueba:

=>"falso es lo opuesto a verdadero"

<="verdadero para etisoppo eht si falso"

¡Gracias ProgramFOX y edc65 por señalar un error!

Fuzzyzilla
fuente
¡Bienvenido a Programming Puzzles & Code Golf! La pregunta solicita un programa completo o una función, por lo que no solo un fragmento de código que asume que sexiste una variable . Además, su código no funciona para falstrue: debería generar falseslaf, no trueslaf. ¿Quieres solucionar estos problemas? ¡Gracias! :)
ProgramFOX
@ProgramFOX ¡Gracias! ¡Me pondré en eso!
Fuzzyzilla
1
Usted puede ahorrar unos pocos bytes si utiliza ES6, tiene esta sintaxis flecha de función: f=s=>s.split(""). ....
ProgramFOX
Esto es demasiado complejo e incorrecto. Prueba con 'falso1' o 'verdadero0' o 'verdadero1'
edc65
@ edc65 ¿Por qué gracias, amable señor!
Fuzzyzilla
2

Java, 162 98 92 bytes

Gracias (y lo siento! ~) A @DanielM. ¡por contarme sobre StringBuffer y el hecho de que podemos usar funciones!

Porque, ya sabes, Java.

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

Devuelve la cadena inversa correcta.

Versión sin golf:

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

Básicamente, reemplazo todas las instancias de "falso" con un "verdadero" al revés, luego invierto toda la cadena y luego reemplazo las versiones ahora al revés de "verdadero" (no las que acabo de reemplazar) con "falso". Pan comido.

Addison Crump
fuente
StringBuffer es un byte más corto. Además, las funciones están permitidas.
Daniel M.
Estoy preparando otra respuesta en un idioma diferente, para que pueda mantener esto
Daniel M.
El returnes implícito cuando se trata de lambdas de una línea
Daniel M.
44
Java venció a Python? Ahora seguramente el final está sobre nosotros
Downgoat
1
@GaborSch Nifty. : P Gracias!
Addison Crump
1

Mathematica, 64 bytes

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

Python 3, 68100 bytes

Todavía lo estoy jugando al golf, pero está arreglado para el error, así que falstrue -> falselsafytrufalse -> trueurt

Muy claro:

print(input()[::-1].replace("eurt","false").replace("eslaf","true").replace("falstrue","falseslaf"))
Adnan
fuente
3
Esto no funciona correctamente para la entrada falstrue.
fiesta del
Esto puede remediarse fácilmente cambiando las declaraciones de reemplazo ( print(input()[::-1].replace("eslaf","true").replace("eurt","false")))
Decaimiento Beta
@BetaDecay, eso no funcionará, porque se trufalseconvierte trufalse, mientras tiene que serlotrueurt
Adnan
@Adriandmen Sin embargo, ese no es uno de los ejemplos de E / S, por lo que será suficiente por ahora :)
Beta Decay
@BetaDecay Jaja, no se darán cuenta :)
Adnan
1

Japt, 26 bytes

Nota: Esto puede no ser válido, ya que requiere correcciones de errores realizadas después de que se publicó este desafío.

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

¡Pruébelo en el intérprete en línea ! (La función de flecha requiere un navegador compatible con ES6, como Firefox).

Cómo 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

Aquí hay una versión que funcionó antes de la corrección de errores: (38 bytes)

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

Gema, 43

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

( Gema es un lenguaje macro oscuro).

Steven Taschuk
fuente
1

Pyth, 28 22

Amr`!dZ2jHjLGcR_Hc_z_G

6 bytes gracias a Jakube

Funciona correctamente para falstrue, como se muestra en la suite a continuación.

Banco de pruebas

FryAmTheEggman
fuente
No, creo que cometí un error. Su solución de 22 bytes es correcta.
Jakube el
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

El reemplazo de "verdadero" por "falso" y viceversa es bastante largo con la coincidencia de patrones, pero al menos trata correctamente con "falso" y similares. Y además, sospecho que una versión correcta basada en expresiones regulares sería un poco más larga.

arjanen
fuente
1

Python 3 - 108 92 bytes

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

Utiliza una expresión regular para hacer coincidir en "verdadero" o "falso" y utiliza una lambda para procesar coincidencias y elegir qué usar como una cadena de reemplazo. El uso de repr obtiene la representación de cadena de (len (match)> 4) que da "True" cuando se coincide "false" y viceversa (y usa .lower () porque repr (bool) da una cadena en mayúscula) para obtener el inverso del partido y terminar invirtiendo el reemplazo y luego la entrada procesada usando [:: - 1]

Logramos reducir la longitud de 16 bytes de las sugerencias de TFelds.

Editar: Python está de vuelta frente a Java, no hay necesidad de alarma.

Phyxie
fuente
55
Aquí requerimos que los programas funcionen para todas las entradas, no solo para los casos de prueba dados.
lirtosiast el
Puede guardar 6 bytes invirtiendo la cadena primero y luego reemplazando (guardando uno [::-1]) print(re.compile("eslaf|eurt").sub(lambda m:repr(m.group(0)!="eurt").lower(),input()[::-1]))
TFeld
También puede salirse con la suya sin usar re.compile print(re.sub("eslaf|eurt",lambda m:repr(m.group(0)!="eurt").lower(),input()[::-1])) Cambiar m.group(0)!="eurt"a len(m.group(0))>4(por 1 más)
TFeld
1

𝔼𝕊𝕄𝕚𝕟, 40 caracteres / 65 bytes

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

Try it here (Firefox only).

¡Gracias a @feersum por señalar un error!

21 caracteres / 43 bytes, no competitivos

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

Try it here (Firefox only).

Mama Fun Roll
fuente
2
Esto no funciona correctamente para la entrada falstrue.
fiesta del
1

Prólogo, 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).

Pruébelo en línea aquí
Ejecútelo consultando de la siguiente manera:

p("falstrue").
Emigna
fuente
0

Ruby, 55 bytes

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

Prueba:

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

Perl 5, 68 bytes

67 más 1 para en -Elugar de-e

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

OpenSCAD, 178 bytes

(Tenga en cuenta que esto usa la biblioteca de la teoría de cadenas , ya que OpenSCAD no tiene exactamente una biblioteca estándar. Además, esta es una función porque la única entrada permitida es codificarla.

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.
fuente
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
fuente
Esta es mi primera publicación (real). He visto que alguien que usaba C # no incluía: uso del sistema; clase P {}, vacío estático main (), Console.WriteLine (); o Console.ReadLine () ;. Obviamente, toman muchos bytes para mí, si hay una forma de jugar al golf o si está excluido del código de golf, hágamelo saber :)
Belfield
0

PHP, 60 bytes

Simple, primero invierte la cadena, luego reemplaza las versiones invertidas con sus respectivos intercambios.

"falstrue" se convierte en "eurtslaf" se convierte en "falseslaf".

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

Perl 5.10, 54 bytes

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

Invierta, luego reemplace. Una forma diferente de hacerlo además de la tabla hash utilizada para la otra respuesta de Perl, ¡que termina siendo más corta!

Pruébalo en línea.

Paul Picard
fuente
-1

Pyth - 18 bytes

Se puede jugar mucho más al golf.

Amr`!dZ2::_z_GH_HG

Test Suite .

Maltysen
fuente
66
Esto no funciona correctamente para la entrada falstrue.
fiesta del