47
\$\begingroup\$

Do While False

At work today one of my colleagues was describing the use-case for do while(false). The person he was talking to thought that this was silly and that simple if statements would be much better. We then proceeded to waste half of our day discussing the best manner to write something equivalent to:

do
{
   //some code that should always execute...

   if ( condition )
   {
      //do some stuff
      break;
   }

   //some code that should execute if condition is not true

   if ( condition2 )
   {
       //do some more stuff
       break;
   }

   //further code that should not execute if condition or condition2 are true

}
while(false);

This is an idiom which is found in c quite often. Your program should produce the same output as the below pseudo-code depending on the conditions.

do
{
   result += "A";

   if ( C1)
   {
      result += "B";
      break;
   }

   result += "C"

   if ( C2 )
   {
       result += "D";
       break;
   }

   result += "E";

}
while(false);

print(result);

Therefore the input could be:

1. C1 = true, C2 = true
2. C1 = true, C2 = false
3. C1 = false, C2 = true
4. C1 = false, C2 = false

and the output should be:

1. "AB"
2. "AB"
3. "ACD"
4. "ACE"

This is code-golf so answers will be judged on bytes. Standard loopholes are banned.

Yes this is a simple one, but hopefully we will see some creative answers, I'm hoping the simplicity will encourage people to use languages they are less confident with.

\$\endgroup\$
  • \$\begingroup\$ Does the output have to be uppercase, or is lowercase also permitted? \$\endgroup\$ – Adnan Feb 18 '16 at 19:56
  • 7
    \$\begingroup\$ As an aside for the debate with your coworker, it seems to me you could accomplish the same thing using a method with return result in place of break. Then you get the bonuses of re-usability and simplifying the calling code, too. But perhaps I'm missing something. \$\endgroup\$ – jpmc26 Feb 21 '16 at 7:18
  • 3
    \$\begingroup\$ I didn't know this was an idiom in C... \$\endgroup\$ – Mehrdad Feb 21 '16 at 10:45
  • 5
    \$\begingroup\$ @Mehrdad some folks do this instead of goto because using goto is bad form :) \$\endgroup\$ – Seth Feb 21 '16 at 22:53
  • 2
    \$\begingroup\$ The only time I have ever used do{}while(false) is inside macros. A simple if does not suffice, because it interacts badly with elses around that may be present. Without a macro you may as well remove the do and while. \$\endgroup\$ – nwp Feb 22 '16 at 11:56

57 Answers 57

19
\$\begingroup\$

Python 3, 31

Saved 1 byte thanks to xnor.

Only one byte away from ES6. :/ Stupid Python and its long anonymous function syntax.

Hooray for one liners!

lambda x,y:x*"AB"or"AC"+"ED"[y]

Test cases:

assert f(1, 1) == "AB"
assert f(1, 0) == "AB"
assert f(0, 1) == "ACD"
assert f(0, 0) == "ACE"
\$\endgroup\$
  • 7
    \$\begingroup\$ If you re-order x*"AB", you can save the space after. \$\endgroup\$ – xnor Feb 18 '16 at 22:26
  • 2
    \$\begingroup\$ Sorry, your long, anonymous function syntax will be the death of python :P \$\endgroup\$ – Conor O'Brien Feb 19 '16 at 17:36
  • 5
    \$\begingroup\$ @CᴏɴᴏʀO'Bʀɪᴇɴ I knew something had to be holding Python back. I'll submit a PEP ASAP. \$\endgroup\$ – Morgan Thrapp Feb 19 '16 at 17:36
  • 2
    \$\begingroup\$ You do that, and I'll order snake traps \$\endgroup\$ – Conor O'Brien Feb 19 '16 at 17:38
  • 9
    \$\begingroup\$ A PEP to make λ a synonym of lambda would be great :) \$\endgroup\$ – Robert Grant Feb 19 '16 at 19:26
13
\$\begingroup\$

JavaScript ES6, 30 26 25 bytes

A simple anonymous function taking two inputs. Assign to a variable to call. Update: Let's jump on the index bandwagon. It saves 4 bytes. I have secured my lead over Python. Saved a byte by currying the function; call like (...)(a)(b). Thanks Patrick Roberts!

a=>b=>a?"AB":"AC"+"ED"[b]

Old, original version, 30 bytes (included to not melt into the python answer (;):

(a,b)=>"A"+(a?"B":b?"CD":"CE")
\$\endgroup\$
  • \$\begingroup\$ This isn't that clever... \$\endgroup\$ – theonlygusti Feb 18 '16 at 21:39
  • 15
    \$\begingroup\$ @theonlygusti This a code-golf, not a popularity contest. Also, why waste bytes being clever if there is a more concise solution? \$\endgroup\$ – Conor O'Brien Feb 18 '16 at 21:41
  • \$\begingroup\$ I like your choice of nose :b? \$\endgroup\$ – J Atkin Feb 19 '16 at 15:48
  • \$\begingroup\$ @JAtkin Indeed! \$\endgroup\$ – Conor O'Brien Feb 19 '16 at 17:05
  • 4
    \$\begingroup\$ You can save a byte with currying \$\endgroup\$ – Patrick Roberts Feb 19 '16 at 21:56
13
\$\begingroup\$

C preprocessor macro, 34

  • 1 byte saved thanks to @TobySpeight
#define f(a,b)a?"AB":b?"ACD":"ACE"

Try it online.

\$\endgroup\$
9
\$\begingroup\$

Haskell, 28 bytes

x#y|x="AB"|y="ACD"|1<2="ACE"

Usage example: False # True -> "ACD".

Using the input values directly as guards.

\$\endgroup\$
9
\$\begingroup\$

MATL, 15 17 bytes

?'AB'}'AC'69i-h

Inputs are 0 or 1 on separate lines. Alternatively, 0 can be replaced by F (MATL's false) and 1 by T (MATL's true).

Try it online!

?           % if C1 (implicit input)
  'AB'      %   push 'AB'
}           % else
  'AC'      %   push 'AC'
  69        %   push 69 ('E')
  i-        %   subtract input. If 1 gives 'D', if 0 leaves 'E'
  h         %   concatenate horizontally
            % end if (implicit)
\$\endgroup\$
8
\$\begingroup\$

Brainfuck, 65 bytes

This assumes that C1 and C2 are input as raw 0 or 1 bytes. e.g.

echo -en '\x00\x01' | bf foo.bf

Golfed:

++++++++[>++++++++<-]>+.+>+>,[<-<.>>-]<[<+.+>>,[<-<.>>-]<[<+.>-]]

Ungolfed:

                                      Tape
                                      _0
++++++++[>++++++++<-]>+.+  print A    0 _B
>+>,                       read C1    0 B 1 _0  or  0 B 1 _1
[<-<.>>-]<                 print B    0 B _0 0  or  0 B _1 0
[<+.+>>                    print C    0 D 1 _0
    ,                      read C2    0 D 1 _0  or  0 D 1 _1
    [<-<.>>-]<             print D    0 D _0 0  or  0 D _1 0
    [<+.>-]                print E    0 D _0    or  0 E _0
]

I believe it worth noting that this solution is in fact based on breaking out of while loops.

\$\endgroup\$
7
\$\begingroup\$

GNU Sed, 21

/^1/cAB
/1$/cACD
cACE

Ideone.

\$\endgroup\$
7
\$\begingroup\$

NTFJ, 110 bytes

##~~~~~#@|########@|~#~~~~~#@*(~#~~~~#~@*########@^)~#~~~~##@*##~~~~~#@|########@|(~#~~~#~~@*):~||(~#~~~#~#@*)

More readable:

##~~~~~#@|########@|~#~~~~~#@*(~#~~~~#~@*########@^)~#~~~~##@*##~~~~~#@|########@|(~#~~~#~~@*
):~||(~#~~~#~#@*)

That was certainly entertaining. Try it out here, using two characters (0 or 1) as input.

Using ETHProduction's method for converting to 0, 1 (characters) to bits, this becomes simpler.

##~~~~~#@|########@|

This is the said method. Pushing 193 (##~~~~~#@), NANDing it (|) with the top input value (in this case, the first char code, a 48 or 49). This yields 254 for 1 and 255 for 0. NANDing it with 255 (########@) yields a 0 or 1 bit according to the input.

~#~~~~~#@*

This prints an A, since all input begins with A. * pops the A when printing, so the stack is unchanged from its previous state.

(~#~~~~#~@*########@^)

Case 1: the first bit is 1, and ( activates the code inside. ~#~~~~#~@* prints B, and ########@^ pushes 255 and jumps to that position in the code. This being the end of the program, it terminates.

Case 2: the first bit is 0. ( skips to ) and the code continues.

~#~~~~##@*

This prints a C, because that's the next character.

##~~~~~#@|########@|

This converts our second input to a bit.

(~#~~~#~~@*)

If our second bit is a 1, we proceed to print an E.

:~||

This is the NAND representation of the Boolean negation of our bit: A NAND (0 NAND A) = NOT A.

(~#~~~#~#@*)

This now activates if the bit was a 0, and prints E.

\$\endgroup\$
5
\$\begingroup\$

Pyth, 16 bytes

+\A?Q\B+\C?E\D\E

Test suite

Ternaries!

Explanation:

+\A              Start with an A
?Q\B             If the first variable is true, add a B and break.
+\C              Otherwise, add a C and
?E\D             If the second variable is true, add a D and break.
\E               Otherwise, add a E and finish.

Input on two consecutive lines.

\$\endgroup\$
  • 3
    \$\begingroup\$ Oh pythmaster, make known to us the ways of this program. ;) \$\endgroup\$ – Conor O'Brien Feb 18 '16 at 18:41
5
\$\begingroup\$

CJam, 15 16 17 bytes

'Ali'B'C'Eli-+?

Try it online!

One byte off thanks to @randomra, and one byte off thanks to @Dennis

Explanation:

'A                  e# push "A"
  li                e# read first input as an integer
    'B              e# push "B" 
      'C            e# push "C"
        'E          e# push "E"
          li-       e# leave "E" or change to "D" according to second input
             +      e# concatenate "C" with "E" or "D"
              ?     e# select "B" or "C..." according to first input

Old version (16 bytes):

'Ali'B{'C'Eli-}?

Explanation:

'A                  e# push character "A"
               ?    e# if-then-else
  li                e# read first input as an integer. Condition for if
    'B              e# push character "B" if first input is true
      {       }     e# execute this if first input is false
       'C           e# push character "C"
         'E         e# push character "E"
           li       e# read second input as an integer
             -      e# subtract: transform "E" to "D" if second input is true
                    e# implicitly display stack contents
\$\endgroup\$
  • 5
    \$\begingroup\$ Our good friends Ali and Eli! \$\endgroup\$ – Conor O'Brien Feb 19 '16 at 17:39
5
\$\begingroup\$

Pyth, 13 chars, 19 bytes

.HC@"૎્««"iQ2

Takes input in form [a,b]

Explanation

               - autoassign Q = eval(input())
           iQ2 -    from_base(Q, 2) - convert to an int
   @"૎્««"    -   "૎્««"[^]
  C            -  ord(^)
.H             - hex(^)

Try it here

Or use a test suite

\$\endgroup\$
  • 2
    \$\begingroup\$ At least in UTF-8, this weighs 19 bytes. \$\endgroup\$ – Dennis Feb 19 '16 at 4:50
  • 1
    \$\begingroup\$ bytesizematters uses a completely made up way of counting bytes, which does not (and cannot) correspond to an actual encoding. It counts the square thingies as 2 bytes each (3 bytes in UTF-8) and « as 1 byte each (2 bytes in UTF-8). Both wc and this agree that it's 19 bytes. \$\endgroup\$ – Dennis Feb 19 '16 at 15:47
4
\$\begingroup\$

C, 76 bytes

I renamed c1 to c, c2 to C and result to r. C programmers go to extremes to avoid goto. If you ever have a problum with absurd syntax in C, it is most likely to be because you did not use goto.

char r[4]="A";if(c){r[1]=66;goto e;}r[1]=67;if(C){r[2]=68;goto e;}r[2]=69;e:

Ungolfed

char r[4] = "A";
if(c1){
    r[1] = 'B';
    goto end;
}
r[1] = 'C';
if(c2){
    r[2] = 'D';
    goto end;
}
r[2] = 'E';
end:
\$\endgroup\$
  • \$\begingroup\$ Can you start with char r[4]="A";? My C is rusty. \$\endgroup\$ – LarsH Feb 19 '16 at 11:17
  • \$\begingroup\$ Isn't that a really ridiculous way of declaring a String literal? \$\endgroup\$ – Tamoghna Chowdhury Feb 20 '16 at 11:51
  • \$\begingroup\$ @TamoghnaChowdhury Sort of. String literals aren't writable. It's an array which is then initialized by the string literal "A". Since "A" only sets the first two bytes, the remainder is initialized per the rules for objects of static duration (so 0 in this case). [C99 6.7.8/22] \$\endgroup\$ – Ray Feb 22 '16 at 0:27
  • 1
    \$\begingroup\$ You can save 22 bytes by changing the initialization list to "AC" and replacing everything from r[1]=67 to r[2]=69; with r[2]=c2?68:69; \$\endgroup\$ – Ray Feb 22 '16 at 0:43
4
\$\begingroup\$

C, 41 bytes

I'm not sure if the question requires a program, a function or a code snippet.
Here's a function:

f(a,b){a=a?16961:4473665|b<<16;puts(&a);}

It gets the input in two parameters, which must be 0 or 1 (well, b must), and prints to stdout.

Sets a to one of 0x4241, 0x454341 or 0x444341. When printed as a string, on a little-endian ASCII system, gives the required output.

\$\endgroup\$
4
\$\begingroup\$

R, 41 39 37 bytes

pryr::f(c("ACD","ACE","AB")[1+a+a^b])

Try it online!

In R, TRUE and FALSE are coerced to 1 and 0 respectively when you attempt to use them as numbers. We can convert these numbers to indices 1, 2, and 3 through the formula 1+a+a^b.

  a  |   b  | 1+a+a^b
TRUE | TRUE | 1+1+1^1 = 3
TRUE | FALSE| 1+1+1^0 = 3
FALSE| TRUE | 1+0+0^1 = 1
FALSE| FALSE| 1+0+0^0 = 2

These values are then used to index the list ACD, ACE, AB to yield the correct output.

Saved two bytes thanks to JayCe.

If instead you prefer a version with an if statement, there's the following for 41 bytes:

pryr::f(`if`(a,"AB",`if`(b,"ACD","ACE")))

Try it online!

\$\endgroup\$
3
\$\begingroup\$

Mathematica, 35 30 bytes

If[#,"AB",If[#2,"ACD","ACE"]]&

Very simple. Anonymous function.

\$\endgroup\$
3
\$\begingroup\$

Retina, 22 bytes

1.+
AB
.+1
ACD
.+0
ACE

Try it Online

\$\endgroup\$
  • 1
    \$\begingroup\$ retina.tryitonline.net/…. Prefix the ^ with m`, to make it work for multi-line input, which is not necessary for the question, but makes testing easier. \$\endgroup\$ – Digital Trauma Feb 18 '16 at 20:14
  • \$\begingroup\$ I think you can save 3 bytes by removing the space between the two inputs. \$\endgroup\$ – CalculatorFeline Mar 22 '16 at 15:12
3
\$\begingroup\$

JavaScript, 38 bytes

Use no-delimiter 0 or 1 instead of false/true

_=>"ACE ACD AB AB".split` `[+('0b'+_)]
\$\endgroup\$
  • 1
    \$\begingroup\$ You can use split` ` instead of split(" ") \$\endgroup\$ – andlrc Feb 18 '16 at 20:06
  • \$\begingroup\$ You can also use +('0b'+prompt()) instead of parseInt(prompt(),2) \$\endgroup\$ – andlrc Feb 18 '16 at 20:08
3
\$\begingroup\$

Caché ObjectScript, 27 bytes

"A"_$s(x:"B",y:"CD",1:"CE")
\$\endgroup\$
3
\$\begingroup\$

ArnoldC, 423 bytes

IT'S SHOWTIME
HEY CHRISTMAS TREE a
YOU SET US UP 0
HEY CHRISTMAS TREE b
YOU SET US UP 0
BECAUSE I'M GOING TO SAY PLEASE a
BECAUSE I'M GOING TO SAY PLEASE b
TALK TO THE HAND "ABD"
BULLSHIT
TALK TO THE HAND "ABE"
YOU HAVE NO RESPECT FOR LOGIC
BULLSHIT
BECAUSE I'M GOING TO SAY PLEASE b
TALK TO THE HAND "ACD"
BULLSHIT
TALK TO THE HAND "ACE"
YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE BEEN TERMINATED

Since ArnoldC doesn't seem to have formal input, just change the first 2 YOU SET US UP values to either 0 or 1 instead.

Explanation

This is just a whole bunch of conditional statements which account for all the possible outputs. Why, you may ask? Well, ArnoldC doesn't really have string comprehension. It can't even concatenate strings! As a result, we have to resort to the more... inefficient... method.

\$\endgroup\$
  • \$\begingroup\$ Er, the output should be "AB" if a is true, not "ABD"/"ABE". That should make your code shorter! \$\endgroup\$ – Toby Speight Aug 9 '18 at 10:58
3
\$\begingroup\$

Java, 28 bytes

Same boilerplate as a lot of the answers. type is BiFunction<Boolean,Boolean, String>.

(c,d)->c?"AB":d?"ACD":"ACE"
\$\endgroup\$
  • \$\begingroup\$ I know it's been almost two years, but (c,d)-> can be golfed by 1 byte to c->d-> when you use a java.util.function.Function<Boolean, java.util.function.Function<Boolean, String>>. \$\endgroup\$ – Kevin Cruijssen Jan 25 '18 at 10:38
2
\$\begingroup\$

Pyth, 21 bytes

@c"ACE ACD AB AB"diz2

Try it here!

Input is taken as 0 or 1 instead of true/false while C1 comes first.

Explanation

Just using the fact that there are only 4 possible results. Works by interpreting the input as binary, converting it to base 10 and using this to choose the right result from the lookup string.

@c"ACE ACD AB AB"diz2   # z= input

                  iz2   # Convert binary input to base 10
 c"ACE ACD AB AB"d      # Split string at spaces
@                       # Get the element at the index
\$\endgroup\$
2
\$\begingroup\$

Y, 20 bytes

In the event that the first input is one, only one input is taken. I assume that this behaviour is allowed. Try it here!

'B'AjhMr$'C'E@j-#rCp

Ungolfed:

'B'A jh M
   r$ 'C 'E@ j - # r
 C p

Explained:

'B'A

This pushes the characters B then A to the stack.

jh M

This takes one input, increments it, pops it and moves over that number of sections.

Case 1: j1 = 0. This is the more interesting one. r$ reverses the stack and pops a value, 'C'E pushes characters C and E. @ converts E to its numeric counterpart, subtracts the second input from it, and reconverts it to a character. r un-reverses the stack. Then, the program sees the C-link and moves to the next link p, and prints the stack.

Case 2: the program moves to the last link p, which merely prints the entire stack.

\$\endgroup\$
2
\$\begingroup\$

PowerShell, 40 bytes

param($x,$y)(("ACE","ACD")[$y],"AB")[$x]

Nested arrays indexed by input. In PowerShell, $true / 1 and $false / 0 are practically equivalent (thanks to very loose typecasting), so that indexes nicely into a two-element array. This is really as close to a ternary as PowerShell gets, and I've used it plenty of times in golfing.

Examples

PS C:\Tools\Scripts\golfing> .\do-while-false.ps1 1 1
AB

PS C:\Tools\Scripts\golfing> .\do-while-false.ps1 1 0
AB

PS C:\Tools\Scripts\golfing> .\do-while-false.ps1 0 1
ACD

PS C:\Tools\Scripts\golfing> .\do-while-false.ps1 0 0
ACE
\$\endgroup\$
2
\$\begingroup\$

K, 37 bytes

{?"ABCDE"@0,x,(1*x),(2*~x),(~x)*3+~y}
\$\endgroup\$
2
\$\begingroup\$

Vitsy, 26 bytes

Expects inputs as 1s or 0s through STDIN with a newline separating.

W([1m;]'DCA'W(Zr1+rZ
'BA'Z

I actually discovered a serious problem with if statements during this challenge. D: This is posted with the broken version, but it works just fine. (I'll update this after I fix the problem) Please note that I have updated Vitsy with a fix of if/ifnot. This change does not grant me any advantage, only clarification.

Explanation:

W([1m;]'DCA'W(Zr1+rZ
W                      Get one line from STDIN (evaluate it, if possible)
 ([1m;]                If not zero, go to the first index of lines of code (next line)
                       and then end execution.
       'DCA'           Push character literals "ACD" to the stack.
            W          Get another (the second) line from STDIN.
             (         If not zero, 
do the next instruction.
              Z        Output all of the stack.
               r1+r    Reverse the stack, add one (will error out on input 0, 1), reverse.
                   Z   Output everything in the stack.

'BA'Z
'BA'                   Push character literals "AB" to the stack.
    Z                  Output everything in the stack.

Try it Online!

\$\endgroup\$
2
\$\begingroup\$

beeswax, 26 bytes

Interpreting 0 as false, 1 as true.

E`<
D`d"`C`~<
_T~T~`A`"b`B

Output:

julia> beeswax("codegolfdowhile.bswx",0,0.0,Int(20000))
i1
i1
AB
Program finished!

julia> beeswax("codegolfdowhile.bswx",0,0.0,Int(20000))
i1
i0
AB
Program finished!

julia> beeswax("codegolfdowhile.bswx",0,0.0,Int(20000))
i0
i1
ACD
Program finished!

julia> beeswax("codegolfdowhile.bswx",0,0.0,Int(20000))
i0
i0
ACE
Program finished!

Clone my beeswax interpreter from my Github repository.

\$\endgroup\$
  • \$\begingroup\$ I'm pretty sure you don't need the quotes. \$\endgroup\$ – undergroundmonorail Feb 20 '16 at 4:38
  • \$\begingroup\$ @undergroundmonorail: Okay, I’ll update my solution. Thanks. \$\endgroup\$ – M L Feb 20 '16 at 5:49
2
\$\begingroup\$

C, 47 45 bytes

Since there are only 3 different outcomes, we can pick one of three strings like this:

char*f(c,d){return"AB\0 ACE\0ACD"+(!c<<d+2);}

Thanks to Herman L for 2 bytes

Demo

#include<stdio.h>
int main()
{
    printf("%s\n%s\n%s\n%s\n",
           f(1,1),
           f(1,0),
           f(0,1),
           f(0,0));
}
\$\endgroup\$
  • 1
    \$\begingroup\$ -2 bytes: char*f(c,d){return"AB\0 ACE\0ACD"+(!c<<d+2);} \$\endgroup\$ – Herman L Aug 9 '18 at 10:24
  • \$\begingroup\$ link to TIO pls \$\endgroup\$ – ASCII-only Aug 9 '18 at 11:17
1
\$\begingroup\$

Perl, 23 bytes

say<>>0?AB:<>>0?ACD:ACE

Requires the -E|-M5.010 flag and takes input as 1 and 0:

$ perl -E'say<>>0?AB:<>>0?ACD:ACE' <<< $'0\n0'
ACE
$ perl -E'say<>>0?AB:<>>0?ACD:ACE' <<< $'0\n1'
ACD
$ perl -E'say<>>0?AB:<>>0?ACD:ACE' <<< $'1\n0'
AB

Alternative solution that requires -p and is 22 + 1 = 23 bytes:

$_=/^1/?AB:/1/?ACD:ACE
perl -pe'$_=/^1/?AB:/1/?ACD:ACE' <<< '0 1'
\$\endgroup\$
  • \$\begingroup\$ say-<>?AB:-<>?ACD:ACE is two bytes shorter. \$\endgroup\$ – nwellnhof Feb 19 '16 at 14:45
1
\$\begingroup\$

05AB1E, 23 20 bytes

Code:

Ii"AB"?q}"AC"?69I-ç?

Try it online!

\$\endgroup\$
  • 1
    \$\begingroup\$ This is probably an ancient version of 05AB1E, but it can be 14 bytes now: i„ABë„AC69I-çJ Try it online or verify all test cases. \$\endgroup\$ – Kevin Cruijssen Aug 9 '18 at 9:03
  • 1
    \$\begingroup\$ @KevinCruijssen Nice! This is indeed an ancient version of 05AB1E. The language was about three months old here (it did not even have implicit input). \$\endgroup\$ – Adnan Aug 9 '18 at 9:13
  • 1
    \$\begingroup\$ Yeah, I was indeed already confused about the leading I. ;p \$\endgroup\$ – Kevin Cruijssen Aug 9 '18 at 9:17
1
\$\begingroup\$

Japt, 19 bytes

"A{U?'B:'C+(V?'D:'E

Test it online!

Fun fact: This would be 16 bytes if it weren't for a bug:

"A{U?"B:C{V?"D:E
\$\endgroup\$
  • \$\begingroup\$ Bugs are the worst :| \$\endgroup\$ – Conor O'Brien Feb 18 '16 at 20:01
  • 2
    \$\begingroup\$ @CᴏɴᴏʀO'Bʀɪᴇɴ Lemme see if I can dig out an older version that didn't have this bug. Then the 16 bytes would be legit. \$\endgroup\$ – ETHproductions Feb 18 '16 at 20:02
  • 1
    \$\begingroup\$ What's the bug? \$\endgroup\$ – CalculatorFeline Mar 22 '16 at 15:13
  • \$\begingroup\$ @CalculatorFeline I believe nested strings like that don't transpile for some reason. \$\endgroup\$ – ETHproductions Sep 7 '16 at 2:24

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.