真実を逆にする

22

次のプログラムまたは関数を作成します。

  1. stdioまたは引数から文字列を受け取ります
  2. truewith falseおよびfalsewithのすべての出現を置き換えます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なので、バイト単位の最短コードが優先されます。

リーダーボード

コードスニペットを表示

code-golf  string  code-golf  string  ascii-art  code-golf  string  code-golf  quine  polyglot  code-golf  math  string  code-golf  internet 
— ハンネス・カルピーラ
ソース
ステップ3で必要な置換は1つだけですか、それともすべての置換を置換する必要がありますか？例えば、またはにtrue true false falseなる？true true false falsetrue eslaf false eurt
— ガボルシュ
べきでeurtになりましたfalseかtrue？
— ゼレゲス
@Zeregesそれは逆になる前に偽でも真でもないので：eurt->true
— ハンネスカルピーラ
@HannesKarppilaしたがって、ルールは次の順序で適用されます1 3 2 4 5
— 。– Zereges
3
これも意味しtrufalse -> trueurtますか？
— アドナン

回答:

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");
— ProgramFOX
ソース
15
100バイト未満のAC＃ソリューション？確かに日が終わります。
— アレックスA.
@AlexA。ハハ、バージョン6に感謝します; P
— ProgramFOX
1
これは入力に対して正しく機能しませんfalstrue。
— -feersum
2
@AlexA。さて、falstrue修正された出力が正しくないため、100バイト未満ではなくなりました... :(
— ProgramFOX
14
それは確かに悲しいことですが、それはもはや黙示録について心配する必要がないことを意味します。ソフトウェアのバグが私たち全員を救ってくれました。
— アレックス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.
— イントレピッドコーダー
ソース
landのi代わりにtand を使用するとf、.s を省略できます。fはまたに事前定義されてfalse：あなたが得ることができるようにxv¡g(l="eurt",i=f+¢)g(iv¡,lv¡)
— Downgoat
実際にはさらに良い：xv¡g("eurt",f)g(f.T¡v¡,t)
— Downgoat
@Vɪʜᴀɴ助けてくれてありがとう。ドキュメントでそれを見ませんでした。(メソッドの後に自動挿入することは可能でしょうか？同様replace(/(\.[BcCdeE...])/g,"$1(")またはピリオドを挿入した後に類似。
— intrepidcoder
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バイト（短縮、Digital Traumaのおかげ）：

rev|sed s/eurt/false/g\;s/eslaf/true/g
— ガボルシュ
ソース
1
sed式を1つに結合し、「rev|sed s/eurt/false/g\;s/eslaf/true/g
— デジタルトラウマ
2
これは入力に対して正しく機能しませんfalstrue。
— feersum
@feersum良い点、修正。についても確認しましたtrufalse。
— ガボルシュ
6

JavaScript ES6、59

匿名関数として。

replaceは、match（）。map（）の省略形として使用されることに注意してください。置換された文字列は破棄され、出力文字列は1つずつ逆方向に作成されます（したがって、逆にする必要はありません）。

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
ソース
素晴らしい62バイトのソリューションを投稿するためにここに来ました...信じられないほどの59バイトのソリューションが見つかりました。+1
— ETHproductions
5

Windowsバッチ、 184 213バイト

バグを修正し、 falstrue -> falseslafおよびtrufalse -> trueurt

おそらくあまり人気のない言語の1つ：

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%
— アドナン
ソース
1
これは入力に対して正しく機能しませんfalstrue。
— feersum
@feersum、修正:)
— アドナン
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]
— クレイグ・ロイ
ソース
そのことについて申し訳ありませんが、今追加しました
— クレイグ・ロイ
気にしないで。それをテストしようとして、私はいくつかの間違いを犯したようです。関数を適用することなく文字列を印刷しただけかもしれません。
— 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``
— コナー・オブライエン
ソース
.replace(/eurt/g,false).replace(/eslaf/g,true)文字列に変換されるため、使用できます。しようtrue + ''（戻る必要があります'true'）
— イスマエルミゲル
3
待つ！！！変更falseを!1してtrueて!0。そこで、数バイト短くなりました
— イスマエルミゲル
3
ありがとうございます！
— コナーオブライエン
1
[...x]x.splitの代わりに使用することもできると思います」
— -Downgoat
2
67： x=>[...x].reverse().join``[r='replace'](/eurt/g,!1)[r](/eslaf/g,!0)。また、結合パラメーターを空のテンプレート文字列に変更して、配列コンマを削除しました。
— ママファンロール
2

Pyth、30バイト

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

これは、入力を反転（_z）、代替"eurt"用"false"と"eslaf"するため"true"。置換はを使用して行われ:ます。

オンラインで試す

— アレックス・A
ソース
"true"and "false"を変数として宣言できます：=d"true"=k"false"::_z_dk_kd、およびその逆を使用します。3バイト節約されます。
— アドナン
::_zJ"eurt"K"false"_K_J23バイトです。
— -PurkkaKoodari
5
これは入力に対して正しく機能しませんfalstrue。
— feersum
2

ジュリア、59 55 46バイト

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

これにより、文字列を受け入れて文字列を返す名前のない関数が作成されます。呼び出すには、名前を付けf=s->...ます。

入力はを使用して反転されreverseます。eurt|eslaf一致trueまたはfalse逆方向の正規表現で一致します。一致に対してtrue、一致が辞書式に小さい場合et（つまりeslaf）などを返す関数を適用しますfalse。ブールリテラルは、出力で文字列に変換されます。

グレンO！のおかげで9バイトを節約し、問題を修正しました。

— アレックス・A
ソース
2
これが入力に対して正しく機能するとは思わないfalstrue。
— feersum
：私はあなたにそれを提供しますので、それは、同じ基本的な推論を使用していますs->replace(reverse(s),r"eurt|eslaf",i->i<"et")、むしろそれを2回行うよりも正規表現を使用して、と評価されたことを置き換えるための機能- trueそれは「elsaf」としたならばfalse、それは「eurt」だった場合。46バイト。
— グレンO
ああ、それもfalstrue問題を修正します。
— グレンO
@GlenOそれは素晴らしい、ありがとう
— アレックス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)}

テスト：

=>「falseはtrueの反対です」

<=「true fo etisoppo eht si false」

バグを指摘してくれたProgramFOXとedc65に感謝します！

— ファジジラ
ソース
プログラミングパズルとコードゴルフへようこそ！質問は完全なプログラムまたは関数を要求するため、変数sが存在することを前提とするコードスニペットだけではありません。また、あなたのコードは動作しませんfalstrue：それは、出力すべきfalseslafではありませんtrueslaf。これらの問題を修正しますか？ありがとう！:)
— ProgramFOX
@ProgramFOXありがとうございます！私はそれで正しくなります！
— ファジージラ
1
ES6を使用している場合、数バイトを保存できますf=s=>s.split(""). ...。矢印関数の構文は次のとおりです。
— -ProgramFOX
これは非常に複雑であり、間違っています。'false1'または 'true0'または 'true1'でテスト
— edc65
@ edc65どうもありがとう、親切な先生！
— ファジジラ
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"）;

基本的に、「false」のすべてのインスタンスを後方の「true」に置き換えてから、文字列全体を逆にし、次に後方にあるバージョンの「true」（置き換えたばかりのものではない）を「false」に置き換えます。簡単です。

— アディソン・クランプ
ソース
StringBufferは1バイト短くなっています。また、機能が許可されています。
— ダニエルM.
私は別の言語で別の答えを準備していますので、これを維持できます
— ダニエルM.
return1行のラムダを扱うときに暗黙的である
— ダニエル・M.
4
JavaはPythonを打ち負かしましたか？今、確かに最後は私たちにある
— Downgoat
1
@GaborSchニフティ。：Pありがとう！
— アディソンクランプ
1

Pythonの3、68の 100バイト

私はまだそれをゴルフんだけど、それはバグに固定されていますので、falstrue -> falselsafとtrufalse -> trueurt

とても簡単です：

print(input()[::-1].replace("eurt","false").replace("eslaf","true").replace("falstrue","falseslaf"))
— Adnan
ソース
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
ソース
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
ソース
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
ソース
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
ソース
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
ソース
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
ソース
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
ソース
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.
ソース
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
ソース
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
ソース
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
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.