颠倒真相

22

编写程序或函数以：

  1. 从stdio或参数中获取一个字符串
  2. 替换所有出现true与false和false与true
  3. 扭转它，但不扭转true和false
  4. 返回或打印结果

示例（输入为左侧）：

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

有标准漏洞。这是代码高尔夫球，因此以字节为单位的最短代码获胜。

排行榜

显示代码段

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
在第3步中，只需要替换一次，还是应该替换所有出现的内容？例如true true false false成为true true false false或true eslaf false eurt？
— gaborsch 2015年
应该eurt成为false还是true？
— Zereges
@Zereges在反转之前，它不是虚假或真实，所以：eurt->true
— Hannes Karppila 2015年
@HannesKarppila因此，将按以下顺序应用规则：1 3 2 4 5
— Zereges
3
这还意味着trufalse -> trueurt吗？
— 阿德南2015年

Answers:

12

C＃6，144字节

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

它使用正则表达式进行匹配true|false，如果匹配true则将替换为eslaf，否则替换为eurt。m.Value[0]<'g'是一个较短的方式说m.Value[0]=="false"，因为唯一可能的值m.Value是"true"或"false"，所以如果第一个字符的字符代码比的字符代码小'g'，它的"false"。

旧版本，95字节

这个有一个错误，它没有为传回正确的输出falstrue。

string R(string t)=>string.Concat(t.Reverse()).Replace("eurt","false").Replace("eslaf","true");
— 程序FOX
source
15
100字节以下的AC＃解决方案？日子肯定会过去了。
— Alex A.
@AlexA。哈哈，这一切都要归功于版本6; P
— ProgramFOX 2015年
1
对于输入，这不能正常工作falstrue。
— feersum
2
@AlexA。好吧，对于falstrue固定的错误输出，它不再是<100字节... :(
— ProgramFOX
14
虽然确实令人难过，但这意味着我们不再需要担心世界末日。软件错误挽救了我们所有人。
— Alex A.
7

TeaScript，36 25 24字节

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

TeaScript是用于高尔夫的JavaScript。

编辑：感谢@Vɪʜᴀɴ，节省了11个字节。固定用于输入falstrue并保存一个字节。

旧版本（无效）：

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

说明：

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.
— 无畏编码器
source
如果使用l和i而不是t和f，则可以省略.。f也已预定义为，false因此您可以获得：xv¡g(l="eurt",i=f+¢)g(iv¡,lv¡)
— Downgoat 2015年
实际上更好：xv¡g("eurt",f)g(f.T¡v¡,t)
— Downgoat
@Vɪʜᴀɴ谢谢你的帮助。在文档中没有看到。(方法之后是否可以自动插入？replace(/(\.[BcCdeE...])/g,"$1(")插入句点后类似或类似。
— intrepidcoder 2015年
1
对于输入，这不能正常工作falstrue。
— feersum
@feersum固定。感谢您指出了这一点。那很棘手。
— intrepidcoder
7

Bash + GNU，45 38 73字节

编辑：有两部作品trufalse和falstrue

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

旧版本，38字节（由于数字创伤而缩短了）：

rev|sed s/eurt/false/g\;s/eslaf/true/g
— 加博尔施
source
1
将sed表达式合并为一个，并删除“ -e”和引号：rev|sed s/eurt/false/g\;s/eslaf/true/g
— Digital Trauma 2015年
2
对于输入，这不能正常工作falstrue。
— feersum
@feersum好点，固定。还检查了trufalse。
— gaborsch 2015年
6

JavaScript ES6、59

作为匿名函数。

注意，replace只是match（）。map（）的简写形式。替换的字符串将被丢弃，并且输出字符串将逐段倒退（因此无需反向）。

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

测试在符合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
source
来到这里发布令人惊叹的62字节解决方案...找到了令人难以置信的59字节解决方案。+1
— ETHproductions 2015年
5

Windows Batch，184213字节

修复了该错误，falstrue -> falseslaf并且trufalse -> trueurt

可能是不太流行的语言之一：

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%
— 阿德南
source
1
对于输入，这不能正常工作falstrue。
— feersum
@feersum，将其修复:)
— Adnan
5

Haskell，94个字节

在输入字符串上执行模式匹配，查找“ false”或“ true”，并将相反的结果附加到在字符串的其余部分上应用函数的结果。如果找不到true或false，它将使用递归以相同的方式反转字符串。

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]
— 克雷格·罗伊
source
现在添加，对此感到抱歉
— Craig Roy
没关系。似乎在尝试测试时犯了一些错误。也许我只是简单地打印出了字符串，而没有设法将功能应用到它。
— feersum
我相信您可以将第一f[]=[]行放在f x=x最下面，以节省一个字节。
— 迈克尔·克莱因
4

的JavaScript ES6，95 93个字节

未命名的函数。添加f=到开始使用它。谢谢伊斯梅尔！还假定输入不包含选项卡。

x=>[...x[r="replace"](/false/g,"\teslaf")[r](/(\t)*true/g,"eurt")[r](/\t/g,"")].reverse().join``
— 科纳·奥布莱恩
source
您可以使用.replace(/eurt/g,false).replace(/eslaf/g,true)，因为它们将被转换为字符串。试试true + ''（应该返回'true'）
— Ismael Miguel
3
等待！！！false与!1和true一起更改!0。在那里，短了几个字节
— Ismael Miguel
3
@IsmaelMiguel哇，谢谢！！！
— Conor O'Brien
1
我认为您也应该能够[...x]代替x.split 使用”
— Downgoat 2015年
2
67 ：x=>[...x].reverse().join``[r='replace'](/eurt/g,!1)[r](/eslaf/g,!0)。我也将连接参数更改为空模板字符串，以使数组逗号分隔。
— Mama Fun Roll 2015年
2

朱莉娅59 55 46字节

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

这将创建一个未命名的函数，该函数接受一个字符串并返回一个字符串。要给它起个名字，例如f=s->...。

使用反转输入reverse。我们在匹配的正则表达式上eurt|eslaf进行匹配true或false向后匹配。对于匹配项，我们应用一个函数，true如果匹配项在字典上小于et（ie eslaf），false则返回该函数，否则返回。布尔文字将在输出中转换为字符串。

节省了9个字节，并通过Glen O解决了一个问题！

— 亚历克斯·A
source
2
我认为这对于输入不起作用falstrue。
— feersum
它使用的是相同的基本推理，因此我将向您提供：s->replace(reverse(s),r"eurt|eslaf",i->i<"et")-使用正则表达式而不是true重复两次，以及用于替换的函数，其计算结果是否为“ elsaf”以及false是否为“ eurt”。46个字节
— Glen O
哦，它还解决了这个falstrue问题。
— Glen O
@GlenO太好了，谢谢
— Alex A.
现在@feersum固定
— 亚历A.
2

Javascript，135字节

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

测试：

=>“假与真相反”

<=“对于其他人而言是真实的”

感谢ProgramFOX和edc65指出错误！

— 模糊浏览器
source
欢迎来到编程难题和代码高尔夫球！这个问题要求一个完整的程序或一个函数，而不只是一个假定s存在变量的代码段。另外，您的代码不适用于falstrue：它应该输出falseslaf，而不是trueslaf。您要解决这些问题吗？谢谢！:)
— ProgramFOX
@ProgramFOX谢谢！我会马上解决的！
— Fuzzyzilla
1
您可以保存几个字节，如果您使用ES6，它有这个箭头函数语法：f=s=>s.split(""). ...。
— ProgramFOX
这既太复杂又错。使用“ false1”或“ true0”或“ true1”进行测试
— edc65
@ edc65先生，为什么谢谢你！
— Fuzzyzilla 2015年
2

Java，162 98 92字节

感谢（对不起！〜）@DanielM。告诉我有关StringBuffer以及我们可以使用函数的事实！

因为，您知道Java。

s->（“” + new StringBuffer（s.replaceAll（“ false”，“ eurt”））。reverse（））。replaceAll（“ eurt”，“ false”）;

返回正确的，反向的字符串。

非高尔夫版本：

s-> new StringBuilder（
    s.replaceAll（“ false”，“ eurt”））
    .reverse（）。toString（）。replaceAll（“ eurt”，“ false”）;

基本上，我用向后的“ true”替换所有“ false”的实例，然后反转整个字符串，然后用“ false”替换现在向后的“ true”版本（不是我刚刚替换的版本）。十分简单。

— 艾迪生·克伦普
source
StringBuffer短一个字节。而且，允许功能。
— Daniel M.
我正在用另一种语言准备另一个答案，所以您可以保留这个
— Daniel M.
return在处理单行lambda时，该值是隐式的
— Daniel M.
4
Java击败了Python？现在肯定即将结束
— Downgoat
1
@GaborSch漂亮的。：P谢谢！
— Addison Crump
1

Python 3，68100字节

我仍然在打高尔夫球，但它是固定的bug，所以falstrue -> falselsaf和trufalse -> trueurt

很简单：

print(input()[::-1].replace("eurt","false").replace("eslaf","true").replace("falstrue","falseslaf"))
— 阿德南
source
3
对于输入，这不能正常工作falstrue。
— feersum
可以通过切换替换语句（print(input()[::-1].replace("eslaf","true").replace("eurt","false"))）
— Beta Decay
@BetaDecay，这将不起作用，因为它trufalse变成了trufalse，而它必须是trueurt
— Adnan
@Adriandmen但是，这不是示例I / O之一，因此现在就足够了：)
— Beta Decay
@BetaDecay哈哈，他们不会注意到:)
— Adnan
1

Japt，26个字节

注意：这可能是无效的，因为它要求在发布此挑战后进行错误修复。

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

在在线解释器中尝试一下！（箭头功能需要符合ES6的浏览器，例如Firefox。）

怎么运行的

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

这是在错误修复之前有效的版本：（38字节）

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

佩斯，28 22

Amr`!dZ2jHjLGcR_Hc_z_G

6个字节，感谢Jakube

可以正常使用falstrue，如下面的套件所示。

测试套件

— 弗莱姆·埃格曼
source
不，我想我做错了。您22字节的解决方案是正确的。
— 2015年
1

Haskell，102字节

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

模式匹配将“ true”替换为“ false”，反之亦然，但至少可以正确处理“ falstrue”等。此外，我怀疑基于正则表达式的正确版本会更长一些。

— Arjanen
source
1

Python 3-108 92字节

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

使用正则表达式匹配“ true”或“ false”，并使用lambda处理匹配项并选择用作替换字符串的内容。使用repr获取（len（match）> 4）的字符串表示形式，当匹配“ false”时给出“ True”，反之亦然（并使用.lower（）因为repr（bool）给出大写的字符串）来获得反匹配，然后先反转替换，然后使用[::-1]处理已处理的输入

设法使长度减少了TFelds建议的16个字节。

编辑：Python回到了Java的前面，不需要报警。

— y
source
5
我们在这里要求程序对所有输入有效，而不仅仅是给定的测试用例。
— lirtosiast 2015年
您可以保存6个字节，方法是先反转字符串，然后替换（保存一个[::-1]） print(re.compile("eslaf|eurt").sub(lambda m:repr(m.group(0)!="eurt").lower(),input()[::-1]))
— TF
您也可以不使用re.compile print(re.sub("eslaf|eurt",lambda m:repr(m.group(0)!="eurt").lower(),input()[::-1])) 更改m.group(0)!="eurt"为len(m.group(0))>4（还有1个）
— TFeld 2015年
1

Prolog，225个字节

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

在此处 在线尝试
通过以下查询方式运行：

p("falstrue").
— 艾米尼亚
source
0

Ruby，55个字节

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

测试：

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

Perl 5,68位元组

67加1 -E代替-e

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

OpenSCAD，178个字节

（请注意，这使用String Theory库，因为OpenSCAD并不完全具有标准库。此外，这是一个函数，因为唯一允许的输入是对其进行硬编码。

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);
— 丹尼尔·M。
source
0

C＃，260个字节

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);}}
— 贝尔菲尔德
source
这是我的第一篇（真实）文章-我见过有人在上面使用c＃进行过开发，但其中不包括：using system; P {}类，static void main（），Console.WriteLine（）; 或Console.ReadLine（）;。这些显然对我来说占用了很多字节-如果有打高尔夫球的方法，或者如果它不在代码高尔夫球中-请告诉我：)
— Belfield，2015年
0

PHP，60个字节

简单，首先反转字符串，然后将反转版本替换为其各自的交换。

“ falstrue”变成“ eurtslaf”，变成“ falseslaf”。

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

Perl 5.10，54个字节

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

反转，然后更换。除了用于其他Perl答案的哈希表以外，另一种处理方法也更短！

在线尝试。

— 保罗·皮卡德
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.