सच को उलट दो


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"

मानक खामियां लागू होती हैं। यह , इसलिए बाइट्स जीत में सबसे छोटा कोड है।

लीडरबोर्ड


चरण 3 में, केवल एक प्रतिस्थापन की आवश्यकता है, या सभी घटनाओं को प्रतिस्थापित किया जाना चाहिए? उदाहरण true true false falseबनता है true true false falseया true eslaf false eurt?
गैबोरश

चाहिए eurtबन गया falseया true?
23

@ इससे पहले कि यह उलटा न हो, यह गलत या सच नहीं है: eurt->true
हेंप्स कारपिला

@ हन्नेसकार्पिला तो, नियम क्रम में लागू होते हैं:1 3 2 4 5
ज़ेर्गेस

3
क्या इसका मतलब यह भी है कि trufalse -> trueurt?
अदनान

जवाबों:


12

सी # 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, अन्यथा eurtm.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");

15
100 बाइट के तहत एसी # समाधान? निश्चित रूप से दिनों का अंत हम पर है।
एलेक्स ए।

@AlexA। हाहा, सभी 6 संस्करण के लिए धन्यवाद; पी
प्रोग्रामफॉक्स

1
यह इनपुट के लिए सही तरीके से काम नहीं करता है falstrue
feersum

2
@AlexA। ठीक है, falstrueतय के लिए गलत आउटपुट के साथ , यह अब नहीं है <100 बाइट्स ... :(
ProgramFOX

14
जबकि वास्तव में यह दुखद है, इसका मतलब है कि हमें अब सर्वनाश के बारे में चिंता करने की ज़रूरत नहीं है। सॉफ्टवेयर बग ने हम सभी को बचा लिया है।
एलेक्स ए।

7

टीस्क्रिप्ट , 36 25 24 बाइट्स

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

TeaScript गोल्फिंग के लिए जावास्क्रिप्ट है।

संपादन: @ V 11 के लिए 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.

आप का उपयोग करते हैं lऔर iके बजाय tऔर f, आप कर सकते हैं ommit .रों। f को भी पूर्वनिर्धारित किया जाता है falseताकि आप प्राप्त कर सकें:xv¡g(l="eurt",i=f+¢)g(iv¡,lv¡)
Downgoat

वास्तव में और भी बेहतर:xv¡g("eurt",f)g(f.T¡v¡,t)
23

@ V @ मदद के लिए धन्यवाद। डॉक्स में यह नहीं देखा। क्या (विधियों के बाद ऑटो सम्मिलित करना संभव होगा ? जैसा replace(/(\.[BcCdeE...])/g,"$1(")या पूर्ण विराम डालने के बाद इसी तरह की।
intrepidcoder

1
यह इनपुट के लिए सही तरीके से काम नहीं करता है falstrue
फेर्सुम

@ फ़र्सम फिक्स्ड। यह बात बताने के लिए धन्यवाद। यह मुश्किल था।
intrepidcoder

7

बैश + जीएनयू, 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

1
Sed भावों को एक में मिलाएं, और "-e" और उद्धरण हटा दें:rev|sed s/eurt/false/g\;s/eslaf/true/g
डिजिटल ट्रामा

2
यह इनपुट के लिए सही तरीके से काम नहीं करता है falstrue
2

@ Faersum अच्छा बिंदु, निश्चित। के लिए भी जाँच की trufalse
गाबर्सच

6

जावास्क्रिप्ट ईएस 6, 59

एक अनाम फ़ंक्शन के रूप में।

ध्यान दें, प्रतिस्थापित का उपयोग मैच () मानचित्र () के लिए शॉर्टहैंड के रूप में किया जाता है। प्रतिस्थापित स्ट्रिंग को छोड़ दिया गया है, और आउटपुट स्ट्रिंग को पीछे की ओर टुकड़ा करके बनाया गया है (इसलिए रिवर्स करने की कोई आवश्यकता नहीं है)।

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>


आश्चर्यजनक 62-बाइट समाधान पोस्ट करने के लिए यहां आया ... अविश्वसनीय 59-बाइट समाधान मिला। +1
ETHproductions

5

विंडोज बैच, 184 213 बाइट्स

बग फिक्स्ड, 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%

1
यह इनपुट के लिए सही तरीके से काम नहीं करता है falstrue
feersum

@ फ़ेर्सुम, इसे तय किया :)
अदनान

5

हास्केल, 94 बाइट्स

इनपुट स्ट्रिंग पर मिलान पैटर्न निष्पादित करता है, "झूठे" या "सच" की तलाश करता है और स्ट्रिंग के शेष पर फ़ंक्शन को लागू करने के परिणाम के विपरीत जोड़ता है। यदि सही या गलत नहीं पाया जाता है, तो यह उसी फैशन में स्ट्रिंग को उलटने के लिए पुनरावृत्ति का उपयोग करता है।

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

जावास्क्रिप्ट ES6, 95 93 बाइट्स

कार्य करते हैं। f=इसका उपयोग करने के लिए शुरुआत में जोड़ें । धन्यवाद इस्माईल! यह भी मानता है कि इनपुट में टैब नहीं हैं।

x=>[...x[r="replace"](/false/g,"\teslaf")[r](/(\t)*true/g,"eurt")[r](/\t/g,"")].reverse().join``

You can use .replace(/eurt/g,false).replace(/eslaf/g,true), since they will be converted to string. Try true + '' (should return 'true')
Ismael Miguel

3
WAIT!!! Change false with !1 and true with !0. There, a few bytes shorter
Ismael Miguel

3
@IsmaelMiguel whoa thanks!!!!
Conor O'Brien

1
I think you should also be able to use [...x] instead of x.split''
Downgoat

2
67: x=>[...x].reverse().join``[r='replace'](/eurt/g,!1)[r](/eslaf/g,!0). I also changed the join param to an empty template string to make strip out array commas.
Mama Fun Roll

2

Pyth, 30 bytes

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

This reverses the input (_z), substitutes "eurt" for "false" and "eslaf" for "true". Replacement is done using :.

Try it online


You can declare "true" and "false" as a variable: =d"true"=k"false"::_z_dk_kd, and use the reverse of it. It will save 3 bytes.
Adnan


5
This does not work correctly for the input falstrue.
feersum


2

Julia, 59 55 46 bytes

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

This creates an unnamed function that accepts a string and returns a string. To call it, give it a name, e.g. f=s->....

The input is reversed using reverse. We match on the regular expression eurt|eslaf which matches true or false backwards. To the match we apply a function that returns true if the match is lexicographically smaller than et (i.e. eslaf) and false otherwise. The boolean literals are converted to string in the output.

Saved 9 bytes and fixed an issue thanks to Glen O!


2
I don't believe this works correctly for the input falstrue.
feersum

It's using the same basic reasoning, so I'll offer it to you: s->replace(reverse(s),r"eurt|eslaf",i->i<"et") - uses a regex rather than doing it twice, and a function for the replace that evaluates to true if it was "elsaf" and to false if it was "eurt". 46 bytes.
Glen O

Oh, and it also fixes the falstrue issue.
Glen O

@GlenO That's great, thanks
Alex A.

@feersum Fixed now
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)}

Test:

=>"false is the opposite of true"

<="true fo etisoppo eht si false"

Thanks ProgramFOX and edc65 for pointing out a bug!


Welcome to Programming Puzzles & Code Golf! The question requests a full program or a function, so not just a code snippet that assumes that a variable s exists. Also, your code does not work for falstrue: it should output falseslaf, not trueslaf. Do you want to fix these issues? Thanks! :)
ProgramFOX

@ProgramFOX Thank you! I'll get right on that!
Fuzzyzilla

1
You can save a few bytes if you use ES6, it has this arrow-function syntax: f=s=>s.split(""). ....
ProgramFOX

This is both overly complex and wrong. Test with 'false1' or 'true0' or 'true1'
edc65

@edc65 Why thank you, kind sir!
Fuzzyzilla

2

Java, 162 98 92 bytes

Thanks (and sorry!~) to @DanielM. for telling me about StringBuffer and the fact that we can use functions!

Because, you know, Java.

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

Returns the correct, reversed string.

Ungolfed Version:

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

Basically, I replace all instances of "false" with a backwards "true", then reverse the entire string, and then replace the now backwards versions of "true" (not the ones I just replaced) with "false". Easy peasy.


StringBuffer is a byte shorter. Also, functions are allowed.
Daniel M.

I'm preparing another answer in a different language, so you can keep this
Daniel M.

The return is implicit when dealing with one-line lambdas
Daniel M.

4
Java beat Python? Now surely the end is upon us
Downgoat

1
@GaborSch Nifty. :P Thanks!
Addison Crump


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

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


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


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.


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.


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

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"

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

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

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

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'})

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.


हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.