Faire tandis que faux

Au travail aujourd'hui, un de mes collègues décrivait le cas d'utilisation de do while (false). La personne à qui il parlait a pensé que c'était ridicule et aussi simple que de simples déclarations. Nous avons ensuite passé la moitié de notre journée à discuter de la meilleure façon d’écrire quelque chose d’équivalent à:

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

C’est un idiome qui se trouve assez souvent dans c. Votre programme devrait produire le même résultat que le pseudo-code ci-dessous en fonction des conditions.

do
{
   result += "A";

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

   result += "C"

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

   result += "E";

}
while(false);

print(result);

Par conséquent, l'entrée pourrait être:

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

et le résultat devrait être:

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

C'est du code-golf, donc les réponses seront jugées sur des octets. Les échappatoires standard sont interdites.

Oui, c’est simple, mais j'espère que nous trouverons des réponses créatives. J'espère que la simplicité encouragera les gens à utiliser des langues avec lesquelles ils ont moins confiance.

Python 3, 31

Sauvegardé 1 octet grâce à xnor.

Un seul octet de distance de ES6. : / Stupid Python et sa syntaxe de fonction anonyme longue.

Hourra pour un paquebot!

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

Cas de test:

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 octets

Une simple fonction anonyme prenant deux entrées. Attribuer à une variable à appeler. Mise à jour : Passons au mouvement d'index. Il sauve 4 octets. J'ai sécurisé mon avance sur Python . Enregistré un octet en currying la fonction; appeler comme (...)(a)(b). Merci Patrick Roberts!

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

Ancienne version originale, 30 octets (inclus pour ne pas fondre dans la réponse en python (;):

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

Macro de préprocesseur C, 34

• 1 octet enregistré grâce à @TobySpeight

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

Essayez-le en ligne .

Haskell, 28 octets

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

Exemple d'utilisation: False # True-> "ACD".

Utiliser les valeurs d'entrée directement en tant que gardes.

MATL , 15 17 octets

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

Les entrées sont 0ou 1sur des lignes séparées. Alternativement, 0peut être remplacé par F(MATL false) et 1par T(MATL true).

Essayez-le en ligne!

?           % 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 octets

Cela suppose que C1 et C2 sont entrés sous forme brute de 0 ou 1 octet. par exemple

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

Golfé:

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

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
]

Je pense qu'il est intéressant de noter que cette solution est en fait basée sur la rupture des boucles while.

GNU Sed, 21

/^1/cAB
/1$/cACD
cACE

Idéone .

NTFJ , 110 octets

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

Plus lisible:

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

C'était certainement amusant. Essayez-le ici , en utilisant deux caractères ( 0ou 1) comme entrée.

En utilisant la méthode de conversion de ETHProduction en 0, 1 (caractères) en bits, cela devient plus simple.

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

C'est la dite méthode. En ##~~~~~#@appuyant sur 193 ( ), appuyez sur NAND ( |) avec la valeur d'entrée supérieure (dans ce cas, le premier code de caractère, a 48 ou 49). Cela donne 254 pour 1 et 255 pour 0. NAND avec 255 ( ########@) donne 0 ou 1 bit en fonction de l'entrée.

~#~~~~~#@*

Ceci imprime un A, puisque toutes les entrées commencent par A. *apparaît Alors de l’impression pour que la pile reste inchangée par rapport à son état précédent.

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

Cas 1: le premier bit est 1, et (active le code à l'intérieur. ~#~~~~#~@*imprime Bet ########@^pousse 255 et saute à cette position dans le code. Ceci étant la fin du programme, il se termine.

Cas 2: le premier bit est 0. (passe à )et le code continue.

~#~~~~##@*

Ceci affiche un C, car c'est le caractère suivant.

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

Ceci convertit notre deuxième entrée en un peu.

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

Si notre deuxième bit est un 1, nous procédons à l'impression d'un fichier E.

:~||

Ceci est la représentation NAND de la négation booléenne de notre bit: A NAND (0 NAND A) = NOT A.

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

Ceci s’active maintenant si le bit était un 0et imprime E.

Pyth, 16 octets

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

Suite de tests

Ternaires!

Explication:

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

Entrée sur deux lignes consécutives.

CJam, 15 16 17 octets

'Ali'B'C'Eli-+?

Essayez-le en ligne!

Un octet à l’aide de @randomra et un octet à l’aide de @Dennis

Explication:

'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

Ancienne version (16 octets):

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

Explication:

'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

Pyth, 13 caractères, 19 octets

.HC@"૎્««"iQ2

Prend la saisie sous forme [a, b]

Explication

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

Essayez-le ici

Ou utilisez une suite de tests

C, 76 octets

J'ai renommé c1à c, c2à Cet resultà r. C les programmeurs vont aux extrêmes pour éviter goto. Si vous avez un problème avec la syntaxe absurde en C, c'est probablement parce que vous ne l'avez pas utilisé 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 octets

Je ne sais pas si la question nécessite un programme, une fonction ou un extrait de code.
Voici une fonction:

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

Il obtient l'entrée dans deux paramètres, qui doivent être 0 ou 1 (enfin, bdoit), et imprime sur stdout.

Définit aà l'un des 0x4241, 0x454341ou 0x444341. Lorsqu'il est imprimé sous forme de chaîne, sur un système ASCII little-endian, donne la sortie requise.

R , 41 39 37 octets

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

Essayez-le en ligne!

Dans R, TRUEet FALSEsont forcés à 1et 0respectivement lorsque vous essayez de les utiliser comme nombres. Nous pouvons convertir ces chiffres en indices 1, 2et 3par la formule 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

Ces valeurs sont ensuite utilisées pour indexer la liste ACD, ACE, ABpour obtenir la sortie correcte.

Enregistré deux octets grâce à JayCe.

Si vous préférez une version avec une ifinstruction, voici ce qui suit pour 41 octets:

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

Essayez-le en ligne!

Mathematica, 35 à 30 octets

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

Très simple. Fonction anonyme.

Rétine, 22 octets

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

Essayez-le en ligne

JavaScript, 38 octets

Utilisez sans délimiteur 0ou à la 1place de false/true

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

Caché ObjectScript , 27 octets

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

ArnoldC , 423 octets

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

Comme ArnoldC ne semble pas avoir d'entrée formelle, il suffit de remplacer les 2 premières YOU SET US UPvaleurs par 0 ou 1.

Explication

Ceci est juste un tas d'instructions conditionnelles qui représentent toutes les sorties possibles. Pourquoi, vous pouvez demander? ArnoldC n'a pas vraiment de compréhension des cordes. Il ne peut même pas concaténer des chaînes! En conséquence, nous devons recourir à la méthode la plus ... inefficace ....

Java, 28 octets

Même passe-partout que beaucoup de réponses. le type est BiFunction<Boolean,Boolean, String>.

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

Pyth, 21 octets

@c"ACE ACD AB AB"diz2

Essayez-le ici!

L'entrée est prise comme 0 ou 1 au lieu de vrai / faux pendant que C1 vient en premier.

Explication

En utilisant simplement le fait qu'il n'y a que 4 résultats possibles. Fonctionne en interprétant l'entrée en tant que binaire, en la convertissant en base 10 et en l'utilisant pour choisir le bon résultat dans la chaîne de recherche.

@c "ACE ACD AB AB" diz2 # z = entrée

                  iz2 # Convertir une entrée binaire en base 10
 c "ACE ACD AB AB" d # Fractionner la chaîne aux espaces
@ # Récupère l'élément à l'index

Y , 20 octets

Dans le cas où la première entrée est une, une seule entrée est prise. Je suppose que ce comportement est autorisé. Essayez-le ici!

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

Ungolfed:

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

A expliqué:

'B'A

Cela pousse les personnages Bpuis Aà la pile.

jh M

Cela prend une entrée, l'incrémente, l'affiche et se déplace sur ce nombre de sections.

Cas 1: j1 = 0. C'est le plus intéressant. r$inverse la pile et affiche une valeur, 'C'Epousse des caractères Cet E. @convertit Een son équivalent numérique, en soustrait la deuxième entrée et le reconvertit en un caractère. rannule la pile. Ensuite, le programme voit le lien C, passe au lien suivant pet imprime la pile.

Cas 2: le programme passe au dernier lien p, qui affiche simplement la pile entière.

PowerShell, 40 octets

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

Tableaux imbriqués indexés par entrée. Dans PowerShell, $true/ 1et $false/ 0sont pratiquement équivalents (grâce à une conversion de texte très lâche), ce qui permet de les indexer correctement dans un tableau à deux éléments. C’est vraiment aussi proche d’un ternaire que PowerShell, et je l’ai utilisé à de nombreuses reprises au golf.

Exemples

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 octets

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

Vitsy , 26 octets

Attend les entrées sous forme de 1 ou de 0 via STDIN avec une nouvelle ligne de séparation.

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

J'ai en fait découvert un problème sérieux avec les déclarations if lors de ce défi. D: Ceci est posté avec la version cassée, mais cela fonctionne très bien. (Je mettrai à jour ceci après avoir résolu le problème) Veuillez noter que j'ai mis à jour Vitsy avec un correctif de if / ifnot. Ce changement ne me donne aucun avantage, mais seulement une clarification.

Explication:

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.

Essayez-le en ligne!

cire d'abeille , 26 octets

Interpréter 0comme faux, 1comme vrai.

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

Sortie:

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!

Cloner mon interprète en cire d'abeille à partir de mon référentiel Github .

C, 47 45 octets

Comme il n'y a que 3 résultats différents, nous pouvons choisir l'une des trois chaînes suivantes:

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

Merci à Herman L pour 2 octets

Démo

#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 octets

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

Nécessite le -E| -M5.010flag et prend les entrées 1 et 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

Solution alternative qui nécessite -pet qui est 22 + 1 = 23 octets:

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

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

05AB1E , 23 à 20 octets

Code:

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

Essayez-le en ligne!

Japt, 19 octets

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

Testez-le en ligne!

Fait amusant: Ce serait 16 octets s'il n'y avait pas de bogue:

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