Faça Enquanto Falso

Hoje, no trabalho, um dos meus colegas estava descrevendo o caso de uso do do while (false). A pessoa com quem ele estava conversando achou que isso era bobagem e simples, se as declarações fossem muito melhores. Em seguida, passamos a perder metade do dia discutindo a melhor maneira de escrever algo equivalente a:

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

Este é um idioma que é encontrado em c com bastante frequência. Seu programa deve produzir a mesma saída que o pseudocódigo abaixo, dependendo das condições.

do
{
   result += "A";

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

   result += "C"

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

   result += "E";

}
while(false);

print(result);

Portanto, a entrada pode ser:

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

e a saída deve ser:

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

Isso é código-golfe, então as respostas serão julgadas em bytes. As brechas padrão são proibidas.

Sim, essa é uma pergunta simples, mas espero que possamos ver algumas respostas criativas. Espero que a simplicidade incentive as pessoas a usar idiomas com os quais estão menos confiantes.

Python 3, 31

Economizou 1 byte graças ao xnor.

Apenas um byte de distância do ES6. : / Python estúpido e sua longa sintaxe de função anônima.

Viva um forro!

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

Casos de teste:

assert f(1, 1) == "AB"
assert f(1, 0) == "AB"
assert f(0, 1) == "ACD"
assert f(0, 0) == "ACE"

JavaScript ES6, 30 26 25 bytes

Uma função anônima simples que recebe duas entradas. Atribua a uma variável a ser chamada. Atualização : Vamos pular na onda do índice. Ele salva 4 bytes. Eu garanti minha liderança sobre o Python . Salva um byte, currying a função; ligar como (...)(a)(b). Obrigado Patrick Roberts!

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

Versão antiga e original, 30 bytes (incluída para não derreter na resposta python (;):

(a,b)=>"A"+(a?"B":b?"CD":"CE")

Macro do pré-processador C, 34

• 1 byte salvo graças a @TobySpeight

#define f(a,b)a?"AB":b?"ACD":"ACE"

Experimente online .

Haskell, 28 bytes

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

Exemplo de uso: False # True-> "ACD".

Usando os valores de entrada diretamente como guardas.

MATL , 15 17 bytes

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

As entradas são 0ou 1em linhas separadas. Como alternativa, 0pode ser substituído por F(MATL's false) e 1por T(MATL's true).

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

Brainfuck, 65 bytes

Isso pressupõe que C1 e C2 sejam inseridos como 0 ou 1 bytes brutos. por exemplo

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

Golfe:

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

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
]

Acredito que vale a pena notar que esta solução é , de fato, baseada em romper os loops while.

GNU Sed, 21

/^1/cAB
/1$/cACD
cACE

Ideone .

NTFJ , 110 bytes

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

Mais legível:

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

Isso foi certamente divertido. Experimente aqui , usando dois caracteres ( 0ou 1) como entrada.

Usando o método da ETHProduction para converter para 0, 1 (caracteres) em bits, isso se torna mais simples.

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

Este é o método mencionado. Pressionando 193 ( ##~~~~~#@), NANDing ( |) com o valor de entrada superior (nesse caso, o primeiro código de caractere, um 48 ou 49). Isso gera 254 para 1 e 255 para 0. NANDing com 255 ( ########@) produz um 0 ou 1 bit de acordo com a entrada.

~#~~~~~#@*

Isso imprime um A, pois todas as entradas começam com A. *aparece Aao imprimir, para que a pilha permaneça inalterada em relação ao estado anterior.

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

Caso 1: o primeiro bit é 1e (ativa o código dentro. ~#~~~~#~@*imprime Be ########@^empurra 255 e salta para essa posição no código. Sendo este o fim do programa, ele termina.

Caso 2: o primeiro bit é 0. (pula para )e o código continua.

~#~~~~##@*

Isso imprime a C, porque esse é o próximo caractere.

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

Isso converte nossa segunda entrada em um pouco.

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

Se o nosso segundo bit for 1, passamos a imprimir um E.

:~||

Esta é a representação NAND da negação booleana de nossa parte: A NAND (0 NAND A) = NOT A.

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

Isso agora é ativado se o bit foi ae é 0impresso E.

Pitão, 16 bytes

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

Suíte de teste

Ternários!

Explicação:

+\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.

Entrada em duas linhas consecutivas.

CJam, 15 16 17 bytes

'Ali'B'C'Eli-+?

Experimente online!

Um byte desligado graças a @randomra, e um byte desligado graças a @Dennis

Explicação:

'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

Versão antiga (16 bytes):

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

Explicação:

'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

Pitão, 13 caracteres, 19 bytes

.HC@"૎્««"iQ2

Recebe entrada no formato [a, b]

Explicação

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

Experimente aqui

Ou use uma suíte de testes

C, 76 bytes

Renomeei c1para c, c2para Ce resultpara r. Programadores em C vão ao extremo para evitar goto. Se você tiver um problema com sintaxe absurda em C, é mais provável que seja porque você não o usou 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:

C, 41 bytes

Não tenho certeza se a pergunta requer um programa, uma função ou um trecho de código.
Aqui está uma função:

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

Ele obtém a entrada em dois parâmetros, que devem ser 0 ou 1 (bem, bdeve) e é impresso em stdout.

Define apara um de 0x4241, 0x454341ou 0x444341. Quando impresso como uma string, em um sistema ASCII little endian, fornece a saída necessária.

R , 41 39 37 bytes

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

Experimente online!

Em R, TRUEe FALSEsão coagidos 1e 0respectivamente quando você tenta usá-los como números. Podemos converter esses números para os índices 1, 2e 3através da fórmula 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

Estes valores são então utilizados para indexar a lista ACD, ACE, ABpara se obter a saída correcta.

Economizou dois bytes graças ao JayCe.

Se você preferir uma versão com uma ifinstrução, há o seguinte para 41 bytes:

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

Experimente online!

Mathematica, 35 30 bytes

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

Muito simples. Função anônima.

Retina, 22 bytes

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

Experimente Online

JavaScript, 38 bytes

Use no-delimitador 0ou em 1vez de false/true

_=>"ACE ACD AB AB".split` `[+('0b'+_)]

Objeto Caché , 27 bytes

"A"_$s(x:"B",y:"CD",1:"CE")

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

Como o ArnoldC não parece ter uma entrada formal, basta alterar os 2 primeiros YOU SET US UPvalores para 0 ou 1.

Explicação

Este é apenas um monte de instruções condicionais que respondem por todas as saídas possíveis. Por que você pode perguntar? Bem, ArnoldC realmente não tem compreensão de strings. Não pode nem concatenar seqüências de caracteres! Como resultado, temos que recorrer ao método mais ... ineficiente.

Java, 28 bytes

O mesmo padrão de muitas das respostas. tipo é BiFunction<Boolean,Boolean, String>.

(c,d)->c?"AB":d?"ACD":"ACE"

Pitão, 21 bytes

@c"ACE ACD AB AB"diz2

Experimente aqui!

A entrada é tomada como 0 ou 1, em vez de verdadeiro / falso, enquanto C1 é o primeiro.

Explicação

Apenas usando o fato de que existem apenas 4 resultados possíveis. Funciona interpretando a entrada como binária, convertendo-a na base 10 e usando-a para escolher o resultado certo da string de pesquisa.

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

                  iz2 # Converter entrada binária na base 10
 c "ACE ACD AB AB" d # Dividir string em espaços
@ # Pega o elemento no índice

Y , 20 bytes

No caso de a primeira entrada ser uma, apenas uma entrada é aceita. Presumo que esse comportamento seja permitido. Experimente aqui!

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

Ungolfed:

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

Explicado:

'B'A

Isso empurra os personagens B, em seguida, Apara a pilha.

jh M

Isso requer uma entrada, a incrementa, a abre e se move sobre esse número de seções.

Caso 1: j1 = 0. Este é o mais interessante. r$inverte a pilha e exibe um valor, 'C'Eempurra caracteres Ce E. @converte Eem sua contraparte numérica, subtrai a segunda entrada e a converte em um caractere. rdesverte a pilha. Em seguida, o programa vê o link C e passa para o próximo link pe imprime a pilha.

Caso 2: o programa passa para o último link p, que apenas imprime a pilha inteira.

PowerShell, 40 bytes

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

Matrizes aninhadas indexadas por entrada. No PowerShell, $true/ 1e $false/ 0são praticamente equivalentes (graças à tipecasting muito flexível), de modo que os índices são bem classificados em uma matriz de dois elementos. Isso é realmente o mais próximo de um ternário que o PowerShell recebe, e eu o usei várias vezes no golfe.

Exemplos

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

K, 37 bytes

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

Vitsy , 26 bytes

Espera entradas como 1s ou 0s através de STDIN com uma nova linha separando.

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

Na verdade, descobri um problema sério com as declarações if durante esse desafio. D: Isso é publicado com a versão quebrada, mas funciona muito bem. (Eu atualizarei isso depois de corrigir o problema). Observe que atualizei o Vitsy com uma correção de if / ifnot. Essa mudança não me concede nenhuma vantagem, apenas esclarecimentos.

Explicação:

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.

Experimente Online!

cera de abelha , 26 bytes

Interpretando 0como falso, 1como verdadeiro.

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

Resultado:

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 meu intérprete de cera de abelha do meu repositório Github .

C, 47 45 bytes

Como existem apenas três resultados diferentes, podemos escolher uma das três cadeias de caracteres como esta:

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

Agradecimentos a Herman L por 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));
}

Perl, 23 bytes

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

Requer o -E| -M5.010sinalizador e recebe a entrada como 1 e 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

Solução alternativa que requer -pe é 22 + 1 = 23 bytes:

$_=/^1/?AB:/1/?ACD:ACE

perl -pe'$_=/^1/?AB:/1/?ACD:ACE' <<< '0 1'

05AB1E , 23 20 bytes

Código:

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

Experimente online!

Japonês, 19 bytes

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

Teste online!

Curiosidade: Seriam 16 bytes se não fosse por um bug:

"A{U?"B:C{V?"D:E