Inversez la vérité

22

Écrivez un programme ou une fonction qui:

  1. prend une chaîne de stdio ou d'arguments
  2. remplace toutes les occurrences de trueavec falseet falseavectrue
  3. l'inverse, mais n'inverse pas trueetfalse
  4. retourne ou imprime le résultat

Exemples (le côté gauche est saisi):

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

Des échappatoires standard s'appliquent. C'est le code-golf , donc le code le plus court en octets gagne.

Classement

Afficher l'extrait de code

code-golf  string  code-golf  string  ascii-art  code-golf  string  code-golf  quine  polyglot  code-golf  math  string  code-golf  internet 
— Hannes Karppila
source
À l'étape 3, un seul remplacement est requis, ou toutes les occurrences doivent être remplacées? par exemple true true false falsedevient true true false falseou true eslaf false eurt?
— gaborsch
Devrait eurtdevenir falseou true?
— Zereges
@Zereges Ce n'est pas faux ou vrai avant qu'il ne soit inversé, alors: eurt->true
— Hannes Karppila
@HannesKarppila Donc, les règles sont appliquées dans l'ordre:1 3 2 4 5
— Zereges
3
Est-ce que cela signifie aussi cela trufalse -> trueurt?
— Adnan

Réponses:

12

C # 6, 144 octets

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

Il utilise une expression régulière pour correspondre true|false, et s'il correspond, trueil sera remplacé par eslaf, sinon par eurt. m.Value[0]<'g'est une façon plus courte de dire m.Value[0]=="false", parce que les seules valeurs possibles pour m.Valuesont "true"ou "false", donc si le code de caractère du premier caractère est plus petit que le code de caractère de 'g', c'est "false".

Ancienne version, 95 octets

Celui-ci avait un bug, il n'a pas renvoyé de sortie correcte pour falstrue.

string R(string t)=>string.Concat(t.Reverse()).Replace("eurt","false").Replace("eslaf","true");
— ProgramFOX
source
15
Solution AC # sous 100 octets? La fin des jours est sûrement à nos portes.
— Alex A.
@AlexA. Haha, tout cela grâce à la version 6; P
— ProgramFOX
1
Cela ne fonctionne pas correctement pour l'entrée falstrue.
— feersum
2
@AlexA. Eh bien, avec la sortie incorrecte pour falstruefixe, ce n'est plus <100 octets ... :(
— ProgramFOX
14
Bien que ce soit vraiment triste, cela signifie que nous n'avons plus à nous soucier de l'apocalypse. Les bogues logiciels nous ont tous sauvés.
— Alex A.
7

TeaScript , 36 25 24 octets

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

TeaScript est JavaScript pour le golf.

Modifications: enregistré 11 octets grâce à @ Vɪʜᴀɴ. Corrigé pour l'entrée falstrueet enregistré un octet.

Ancienne version (invalide):

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

Explication:

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.
— intrépide
source
Si vous utilisez let iau lieu de tet f, vous pouvez annuler le .s. f est également prédéfini pour falseque vous puissiez obtenir:xv¡g(l="eurt",i=f+¢)g(iv¡,lv¡)
— Downgoat
En fait encore mieux:xv¡g("eurt",f)g(f.T¡v¡,t)
— Downgoat
@ Vɪʜᴀɴ Merci pour l'aide. n'a pas vu cela dans les documents. Serait-il possible d'insérer automatiquement des (méthodes après? Comme replace(/(\.[BcCdeE...])/g,"$1(")ou similaire après l'insertion de points.
— intrepidcoder
1
Cela ne fonctionne pas correctement pour l'entrée falstrue.
— feersum
@feersum Fixed. Merci d'avoir fait remarquer cela. C'était délicat.
— intrepidcoder
7

Bash + GNU, 45 38 73 octets

Modifier: fonctionne avec les deux trufalseetfalstrue

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

Ancienne version , 38 octets (raccourci, grâce à Digital Trauma):

rev|sed s/eurt/false/g\;s/eslaf/true/g
— gaborsch
source
1
Combinez les expressions sed en une seule, et supprimez le "-e" et les citations:rev|sed s/eurt/false/g\;s/eslaf/true/g
— Digital Trauma
2
Cela ne fonctionne pas correctement pour l'entrée falstrue.
— feersum
@feersum Bon point, corrigé. Également vérifié trufalse.
— gaborsch
6

JavaScript ES6, 59

En tant que fonction anonyme.

Remarque: replace est utilisé comme raccourci pour match (). Map (). La chaîne remplacée est supprimée et la chaîne de sortie est faite pièce par pièce en arrière (donc pas besoin de l'inverser).

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

Testez l'exécution de l'extrait ci-dessous dans un navigateur compatible 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>
Développer l'extrait

— edc65
source
Entré ici pour publier une solution incroyable de 62 octets ... trouvé une solution incroyable de 59 octets. +1
— ETHproductions
5

Windows Batch, 184 213 octets

Correction du bug falstrue -> falseslafettrufalse -> trueurt

Probablement l'une des langues les moins populaires:

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
source
1
Cela ne fonctionne pas correctement pour l'entrée falstrue.
— feersum
@feersum, corrigé :)
— Adnan
5

Haskell, 94 octets

Effectue une correspondance de modèle sur la chaîne d'entrée, en recherchant "faux" ou "vrai" et ajoute le contraire au résultat de l'application de la fonction sur le reste de la chaîne. Si true ou false n'est pas trouvé, il utilise la récursivité pour inverser la chaîne de la même manière.

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
source
Ajouté maintenant, désolé
— Craig Roy
Ça ne fait rien. Il semble que j'ai fait une erreur en essayant de le tester. J'ai peut-être simplement imprimé la chaîne sans réussir à lui appliquer la fonction.
— feersum
Je pense que vous pouvez prendre la f[]=[]ligne du haut et la mettre f x=xen bas pour enregistrer un octet.
— Michael Klein
4

JavaScript ES6, 95 93 octets

Fonction sans nom. Ajoutez f=au début pour l'utiliser. Merci Ismael! Suppose également que l'entrée ne contient pas d'onglets.

x=>[...x[r="replace"](/false/g,"\teslaf")[r](/(\t)*true/g,"eurt")[r](/\t/g,"")].reverse().join``
— Conor O'Brien
source
Vous pouvez utiliser .replace(/eurt/g,false).replace(/eslaf/g,true), car ils seront convertis en chaîne. Essayez true + ''(devrait revenir 'true')
— Ismael Miguel
3
ATTENDEZ!!! Changez falseavec !1et trueavec !0. Là, quelques octets plus court
— Ismael Miguel
3
@IsmaelMiguel whoa merci !!!!
— Conor O'Brien
1
Je pense que vous devriez également pouvoir utiliser à la [...x]place de x.split ''
— Downgoat
2
67: x=>[...x].reverse().join``[r='replace'](/eurt/g,!1)[r](/eslaf/g,!0). J'ai également changé le paramètre de jointure en une chaîne de modèle vide pour supprimer les virgules du tableau.
— Mama Fun Roll
2

Pyth, 30 octets

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

Ceci inverse l'entrée ( _z), des substituts "eurt"pour , "false"et "eslaf"pour "true". Le remplacement se fait à l'aide de :.

Essayez-le en ligne

— Alex A.
source
Vous pouvez déclarer "true"et "false"comme variable:, =d"true"=k"false"::_z_dk_kdet en utiliser l'inverse. Il économisera 3 octets.
— Adnan
::_zJ"eurt"K"false"_K_Jest de 23 octets.
— PurkkaKoodari
5
Cela ne fonctionne pas correctement pour l'entrée falstrue.
— feersum
2

Julia, 59 55 46 octets

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

Cela crée une fonction sans nom qui accepte une chaîne et renvoie une chaîne. Pour l'appeler, donnez-lui un nom, par exemple f=s->....

L'entrée est inversée à l'aide de reverse. Nous faisons correspondre sur l'expression régulière eurt|eslafqui correspond trueou en falsearrière. À la correspondance, nous appliquons une fonction qui renvoie truesi la correspondance est lexicographiquement plus petite que et(c.-à-d.eslaf ) et falseautrement. Les littéraux booléens sont convertis en chaîne dans la sortie.

Enregistré 9 octets et résolu un problème grâce à Glen O!

— Alex A.
source
2
Je ne crois pas que cela fonctionne correctement pour l'entrée falstrue.
— feersum
Il utilise le même raisonnement de base, donc je vais vous l'offrir: s->replace(reverse(s),r"eurt|eslaf",i->i<"et")- utilise une expression régulière plutôt que de le faire deux fois, et une fonction pour le remplacement qui évalue truesi c'était "elsaf" et falsesi c'était "eurt". 46 octets.
— Glen O
Oh, et cela résout également le falstrueproblème.
— Glen O
@GlenO C'est super, merci
— Alex A.
@feersum Fixé maintenant
— Alex A.
2

Javascript, 135 octets

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

Tester:

=>"faux est l'opposé de vrai"

<="true fo etisoppo eht si false"

Merci ProgramFOX et edc65 pour avoir signalé un bug!

— Fuzzyzilla
source
Bienvenue sur Programmation Puzzles & Code Golf! La question demande un programme complet ou une fonction, donc pas seulement un extrait de code qui suppose qu'une variable sexiste. De plus, votre code ne fonctionne pas falstrue: il devrait sortir falseslaf, non trueslaf. Voulez-vous résoudre ces problèmes? Merci! :)
— ProgramFOX
@ProgramFOX Merci! Je vais y arriver!
— Fuzzyzilla du
1
Vous pouvez enregistrer quelques octets si vous utilisez ES6, il a cette syntaxe flèche fonction: f=s=>s.split(""). ....
— ProgramFOX
C'est à la fois trop complexe et faux. Test avec 'false1' ou 'true0' ou 'true1'
— edc65
@ edc65 Pourquoi merci, gentil monsieur!
— Fuzzyzilla
2

Java, 162 98 92 octets

Merci (et désolé! ~) À @DanielM. pour me parler de StringBuffer et du fait que nous pouvons utiliser des fonctions!

Parce que, vous savez, Java.

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

Renvoie la chaîne correcte et inversée.

Version non golfée:

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

Fondamentalement, je remplace toutes les instances de "false" par un "true" en arrière, puis inverse la chaîne entière, puis remplace les versions maintenant en arrière de "true" (pas celles que je viens de remplacer) par "false". Peasy facile.

— Addison Crump
source
StringBuffer est un octet plus court. De plus, les fonctions sont autorisées.
— Daniel M.
Je prépare une autre réponse dans une langue différente, vous pouvez donc garder cela
— Daniel M.
Le returnest implicite lorsqu'il s'agit de lambdas à une ligne
— Daniel M.
4
Java a battu Python? Maintenant, la fin est sûrement à nos
— portes
1
@GaborSch Nifty. : P Merci!
— Addison Crump
1

Mathematica, 64 octets

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

Python 3, 68 100 bytes

I'm still golfing it, but it's fixed to the bug, so falstrue -> falselsaf and trufalse -> trueurt

Pretty straightforward:

print(input()[::-1].replace("eurt","false").replace("eslaf","true").replace("falstrue","falseslaf"))
— Adnan
source
3
This does not work correctly for the input falstrue.
— feersum
This can be easily remedied by switching the replace statements (print(input()[::-1].replace("eslaf","true").replace("eurt","false")))
— Beta Decay
@BetaDecay, that will not work, because trufalse becomes trufalse, while it needs to be trueurt
— Adnan
@Adriandmen However, that's not one of the example I/Os so it will suffice for now :)
— Beta Decay
@BetaDecay Haha, they won't notice :)
— Adnan
1

Japt, 26 bytes

Note: This may be invalid, as it requires bug fixes made after this challenge was posted.

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

Try it in the online interpreter! (Arrow function requires ES6-compliant browser, such as Firefox.)

How it works

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

Here's a version that worked before the bug fixes: (38 bytes)

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

Pyth, 28 22

Amr`!dZ2jHjLGcR_Hc_z_G

6 bytes thanks to Jakube

Works correctly for falstrue, as shown in the suite below.

Test suite

— FryAmTheEggman
source
No, I think I made a mistake. You 22 byte solution is correct.
— 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

The replacement of "true" by "false" and vice-versa is quite lengthy with the pattern-matching, but at least it deals correctly with "falstrue" and the like. And besides, I suspect that a correct regex-based version would be a bit longer.

— arjanen
source
1

Python 3 - 108 92 bytes

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

Uses a regex to match on "true" or "false" and uses a lambda to process matches and choose what to use as a replacement string. Using repr gets the string representation of (len(match)>4) which gives "True" when "false" is matched and vice versa (and use .lower() because repr(bool) gives a capitalized string) to get the inverse of the match and finish up by reversing the replacement and then the processed input using [::-1]

Managed to get the length down 16 bytes from TFelds suggestions.

Edit: Python is back in front of java, no need for alarm.

— Phyxie
source
5
We require here that programs work for all inputs, not just for the given test cases.
— lirtosiast
You can save 6 bytes by reversing the string first, and then replacing (saving one [::-1]) print(re.compile("eslaf|eurt").sub(lambda m:repr(m.group(0)!="eurt").lower(),input()[::-1]))
— TFeld
You can also get away with not using re.compile 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 (for 1 more)
— 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).

Try it out online here
Run by querying in the following way:

p("falstrue").
— Emigna
source
0

Ruby, 55 bytes

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

Test:

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

Perl 5, 68 bytes

67 plus 1 for -E instead of -e

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

OpenSCAD, 178 bytes

(Note that this uses the String Theory library, as OpenSCAD doesn't exactly have a standard library. Additionally, this is a function because the only allowed input is to hard-code it.

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.
source
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
source
This is my first (real) post - I've seen someone using c# above didn't include: using system; class P{ }, static void main(), Console.WriteLine(); or Console.ReadLine();. These obviously take on a lot of bytes for me - if there is a way of golfing that or if it is excluded from code-golf - let me know :)
— Belfield
0

PHP, 60 bytes

Simple, reverses the string first, then replaces the reversed versions with their respective swaps.

"falstrue" becomes "eurtslaf" becomes "falseslaf".

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

Perl 5.10, 54 bytes

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

Reverse, then replace. A different way of doing it besides the hash table used for the other Perl answer, which ends up being shorter!

Try it online.

— Paul Picard
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.