Le booléen redondant

19

introduction

Classiquement, les booléens sont un bit; trueou false, 1ou 0. Les zéros non significatifs seraient simplement redondants. Par exemple, 001signifie la même chose que 00001ou juste 1.

Le booléen 32 bits

Étant donné une valeur truey / falsey, sortez l'équivalent booléen 32 bits sous forme de chaîne. (Ou sous forme de nombre si, pour une raison quelconque, votre langue prend en charge les zéros non significatifs.)

Votre programme ne doit pas fonctionner pour tous les types de vérités / fausses, mais uniquement pour ce que votre langage de programmation fonctionne le mieux.

Exemple i / o

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

Il s'agit de code-golf , donc les octets les plus bas gagnent!

code-golf  string 
— Graviton
source
6
Avons-nous besoin de gérer toute valeur véridique ou falsey possible, ou simplement des booléens?
— xnor
Si ma langue prend en charge les types et a un booléen, puis-je utiliser 1 (int) comme véridique?
— LiefdeWen
@LiefdeWen bien sûr
— Graviton
1
Ne plus dupliquer car les entrées véridiques / fausses peuvent être différentes pour chaque réponse / langue.
— Graviton
Je ne vois pas pourquoi mais hein, d'accord ~
— V. Courtois

Réponses:

9

Code machine x86-16 (DOS), 16 octets

B4 02          mov  ah,  2
B2 30          mov  dl, '0'
B9 1F 00       mov  cx, 31

            PrintZeros:
CD 21          int  0x21
E2 FC          loop PrintZeros

00 CA          add  dl, bl
CD 21          int  0x21
C3             ret

La fonction ci-dessus reçoit une valeur booléenne (0 == falsey, 1 == truey) dans le BLregistre (octet bas de BX) et imprime une chaîne "booléenne redondante" sur la sortie standard.

Il fonctionne en appelant une interruption (0x21) pour effectuer un appel de fonction DOS (sélectionné en définissant AHsur 2) qui imprime un seul caractère (in DL) sur la sortie standard.

Tout d'abord, le caractère ASCII «0» est chargé dans DL, le compteur ( CX) est défini sur 31 et il boucle pour imprimer les octets «redondants». Ensuite, la valeur booléenne d'entrée est ajoutée à DL(s'il BLs'agit de falsey, l'ajout de 0 restera DLinchangé en tant que ASCII '0'; s'il BLest véridique, DLsera incrémenté de un à ASCII '1'), et l'octet final sera imprimé.

La fonction ne renvoie pas de valeur.

Assez décent pour une langue qui ne fait pas vraiment de cordes.

Programme complet, 21 octets

Si vous voulez en faire un programme complet, seulement 5 octets supplémentaires sont nécessaires. Au lieu de passer l'entrée dans un registre, cela lit l'entrée des arguments passés sur la ligne de commande lors de l'appel de l'application. Un argument de 0 est interprété comme falsey, tout comme l'absence totale d'arguments; un argument supérieur à 0 est interprété comme véridique.

Assemblez simplement le code suivant en tant que programme COM, puis exécutez-le sur la ligne de commande.

B4 02            mov   ah,  2
B2 30            mov   dl, '0'
B9 1F 00         mov   cx, 31

               PrintZeros:
CD 21            int   0x21
E2 FC            loop  PrintZeros

3A 16 82 00      cmp   dl, BYTE PTR [0x82]  ; compare to 2nd arg, at offset 0x82 in PSP
D6               salc                       ; equivalent to sbb al, al
28 C2            sub   dl, al
CD 21            int   0x21
C3               ret                        ; you can simply 'ret' to end a COM program

Exemple de sortie:

C:\>bool.com
00000000000000000000000000000000
C:\>bool.com 0
00000000000000000000000000000000
C:\>bool.com 1
00000000000000000000000000000001 
C:\>bool.com 2
00000000000000000000000000000001
C:\>bool.com 7
00000000000000000000000000000001

Comment ça marche? Eh bien, c'est essentiellement la même chose, jusqu'à ce que vous arriviez à l' CMPinstruction. Cela compare l'argument de ligne de commande avec la valeur du DLregistre (qui, vous vous en souvenez, contient un «0» ASCII). Dans un programme COM, les octets de code sont chargés à l'offset 0x100. Il s'agit du préfixe de segment de programme (PSP) , qui contient des informations sur l'état d'un programme DOS. Plus précisément, à l'offset 0x82, vous trouvez le premier argument (en fait le second, car le premier est un espace) qui a été spécifié sur la ligne de commande lorsque le programme a été appelé. Donc, nous comparons simplement cet octet avec un «0» ASCII.

La comparaison définit les indicateurs, puis l' SALCinstruction (un opcode non documenté avant le Pentium, équivalent à sbb al, al, mais seulement 1 octet au lieu de 2) prend la valeur AL0 si les deux valeurs sont égales, ou -1 si elles sont différentes. Il est alors évident que lorsque nous soustrayons ALde DL, cela se traduit par ASCII «0» ou «1», selon le cas.

(Notez que, quelque peu ironiquement, vous le casserez si vous passez un argument avec un 0 de tête sur la ligne de commande, car il ne regarde que le premier caractère. Il 01sera donc traité comme falsey. :-)

— Cody Grey
source
7

Javascript, 23 octets

a=>'0'.repeat(31)+ +!!a

!!a transforme un en booléen, que l'unaire plus transforme en int.

— SuperStormer
source
a=>'0'.repeat(31)+(+a)est un octet plus court.
— Kritixi Lithos
@Cowsquack qui échoue sur les chaînes, les tableaux vides, NaN, les fonctions et autres valeurs où la coercition en un nombre ne donne pas 0 ou 1
— SuperStormer
également des objets vides, des tableaux, Infinity et undefined
— SuperStormer
1
... mais maintenant ...Your program doesn't have to work for every truthy/falsy type, only what your programming language work best for.
— edc65
1
a=>'0'.repeat(31)+~~afonctionne avec vrai, faux, 1,0
— edc65
6

V , 8 octets

32é0Àñl

Essayez-le en ligne!

Explication:

32é0            " Insert 32 '0's
    Àñ          " Arg1 times...
      <C-a>     "   Increment the number under the cursor
           l    "   Move one char to the right. This will break the loop since there is 
                "   no more room on this line
— DJMcMayhem
source
4

ArnoldC , 369 octets

IT'S SHOWTIME
HEY CHRISTMAS TREE A
YOU SET US UP 0
GET YOUR ASS TO MARS A
DO IT NOW
I WANT TO ASK YOU A BUNCH OF QUESTIONS AND I WANT TO HAVE THEM ANSWERED IMMEDIATELY
BECAUSE I'M GOING TO SAY PLEASE A
TALK TO THE HAND "00000000000000000000000000000001"
BULLSHIT
TALK TO THE HAND "00000000000000000000000000000000"
YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE BEEN TERMINATED

Essayez-le en ligne!

— TemporalWolf
source
2
Bienvenue chez PPCG!
— Stephen
4

Brainfuck , 61 60 36 octets

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

Je suis sûr qu'il existe un moyen intelligent de ne pas trop se déplacer avec les pointeurs.

J'avais raison. Il y avait. Merci à @Graviton de m'avoir donné l'idée!

Étape suivante: obtenez les valeurs 32 et 48 plus rapidement!

Essayez-le en ligne!

++++        - Increment 1st slot by 4
[           - Loop until 4 becomes 0
    >++++   - Add 4 to 2nd slot
    <-      - Decrement loop
]           - At this point, we point to slot 1 and slot 2 contains 16, which is the Greatest Common Divisor of 48 (value 0 in ASCII) and 32 (final length of answer)
>           - Point to value 16 (slot 2)
[           - Start loop to get our target values 32 and 48
    >++     - Point to slot 3 and multiply 16 by 2 = 32
    >+++    - Point to slot 4 and multiply 16 by 3 = 48
    <<-     - Decrement the loop so that slot 2 becomes 0
]           - We now point slot 2
>-          - Move to slot 3 and remove one so we can spam (output) 31 zeroes
[           - Start outputting until slot 3 is empty
    >.      - Move to slot 4 where our ASCII value for 0 is
    <-      - Decrement the loop so that slot 3 becomes 0
]           - We are now at slot 3 and it is empty.
,.          - We can now gather input from the user and output it.

C'était amusant pour un premier golf!

Il est devenu trop tard maintenant. Qu'est-ce que je fais même

— Raphaël Côté
source
Grâce à l'entropie, je l'ai raccourci d'un octet pour arriver au chiffre 16.
— Raphaël Côté
Juste pour le plaisir, voici une version de 60 octets: >-[-[-<]>>+<]>--<<-[>+<-----]>--->[-<.>],.(prend l'entrée comme 0 ou 1) Essayez-le en ligne!
— Graviton
Eh bien, merci beaucoup @Graviton. Vous m'avez fait réaliser que je mettais beaucoup trop d'efforts pour faire chuter la valeur ASCII à 0 alors que je devais juste la sortir.
— Raphaël Côté
3

Scala, 32 octets

Désolé mais j'ai été obligé de le faire en 32 octets> _ <

var s=t
for(u<-0 to 30)s="0"+s
s

Il est entouré par une fonction prenant tcomme paramètre (comme un stringqui peut être "0" ou "1" pour resp. Fausses ou véridiques), et sest retourné.

Essayez-le en ligne!

Réponse valide: Scala, 46 octets

Identique à ma réponse java, je devais prendre un booléen pour le paramètre. Donc :

var s=if(t)"1"else"0"
for(u<-0 to 30)s="0"+s
s

Essayez-le en ligne!

— V. Courtois
source
3

Braingolf , 10 8 octets

#␟>[0_]N

Essayez-le en ligne!

␟est un séparateur d'unités, ASCII 0x1Fou 31. Impossible de trouver le caractère à coller dans TIO, donc TIO utilise à la place # 1-, ce qui pousse l'espace (32) et diminue à 31.

Explication

#␟>[0_]N  Implicit input from commandline args
#␟        Push unit separator (31)
   >       Move top item to bottom of stack
    [..]   Loop, runs 31 times
     0_    Print 0
        N  Boolean conversion, truthy values become 1, falsey values become 0
           Implicit output of top of stack
— Skidsdev
source
Voici le lien tio avec le caractère 0x1F qu'il
— contient
@ PunPun1000 Oh merci! Je mettrai à jour le post
— Skidsdev
2

Octave , 23 octets

@(x)[48+[!(1:31),x],'']

Essayez-le en ligne!

C'est plus court que toutes les approches avec lesquelles j'ai essayé printf. J'ai peut-être manqué quelque chose, puisque je l'ai fait sur mon téléphone.

Un seul octet de plus

@(x)[dec2bin(0,31),x+48]

Cela pourrait être de 18 octets si je pouvais prendre 1/0 comme chaînes.

@(x)[48+!(1:31),x]

Essayez-le en ligne!

— Stewie Griffin
source
2

Java 8, 31 27 octets

b->"".format("%032d",b?1:0)

-4 octets grâce à @ OlivierGrégoire .

Essayez-le ici.

— Kevin Cruijssen
source
1
Oui, toujours là pour vous surpasser:; "".format)
— Olivier Grégoire
1
@ OlivierGrégoire C'était tout! Merde, je suis stupide .. xD Quand je tapais, String.formatje savais qu'il y avait un moyen plus court en quelque sorte, mais je pensais que j'avais probablement utilisé une variable String la dernière fois ... Merci. ;)
— Kevin Cruijssen
1

C, 26 octets

À peu près la même idée que la solution de 1bluestone , mais en C, elle est plus courte et fonctionne correctement pour toute entrée entière:

f(a){printf("%032i",!!a);}

Bien sûr, cela inclut certaines variables / fonctions typées implicitement comme le font toutes les bonnes réponses de C-golf ... L' !!opérateur est le moyen le plus court pour convertir n'importe quelle valeur véridique 1en C (via la double négation, il !est défini pour retourner soit 1ou 0).

Testez avec:

#include <stdio.h>
f(a){printf("%032i",!!a);}
int main() {
    f(0), printf("\n");
    f(1), printf("\n");
    f(2), printf("\n");
    f(-1), printf("\n");
}
— cmaster - réintégrer monica
source
1

PHP, 28 octets

<?=str_pad($argv[1],32,0,0);

Enregistrez sous bool.php et exécutez:

$ php bool.php 0
00000000000000000000000000000000
$ php bool.php 1
00000000000000000000000000000001
— Jared Mellentine
source
3 octets plus court: printf('%032d',$argv[1]);(nécessite l' -rindicateur).
— user63956
1

Ly , 20 15 13 octets

65*1+[0u1-]nu

EDIT: 5 octets enregistrés grâce aux ovs.
EDIT: enregistré 2 octets supplémentaires en imprimant 0 sous forme de nombre plutôt que de caractère.

— LyricLy
source
Ça 65*1+["0"o1-]numarcherait?
— ovs
1

Octave, 16 11 octets

@(x)x(1:32)

Essayez-le en ligne!

Une poignée de fonction qui prend "00000000000000000000000000000001"aussi vrai "00000000000000000000000000000000\0"que falsey.

Explication:

Dans Octave, un tableau est considéré comme falsey si au moins un de ses éléments est nul. Le 33e élément de la deuxième chaîne est un caractère avec la valeur ASCII de 0, il peut donc être considéré comme falsey.

— rahnema1
source
1

Java, 40 caractères, 40 octets

Cela prend la chaîne comme paramètre, ce qui n'est pas correct (la valeur java falsifiée / vraie est forcée par OP pour être représentée par un booléen).

c->{for(int i=0;++i<32;c=0+c);return c;}

Essayez-le en ligne!

Réponse valide: Java, 60 caractères, 60 octets

c->{String k="";for(k+=c?1:0;k.length()<32;k=0+k);return k;}

Essayez-le en ligne!

Je sais qu'il existe déjà une réponse Java qui est plus courte que celle-ci, mais quand même :)

— V. Courtois
source
Oui, l' returninstruction fait partie de votre code, donc une partie de votre nombre d'octets. Mais votre réponse ne respecte pas les règles: vous devez obtenir une booleanentrée. "Truthy / falsy" est traduit en Java comme trueou false, et rien d'autre. Vous ne pouvez donc pas obtenir un Stringparamètre d'entrée.
— Olivier Grégoire
Je vois. Je vais le modifier assez tôt. Merci.
— V. Courtois
1
Vous n'avez pas besoin de mettre le dernier point-virgule ( ;). Aussi, vous pouvez raccourcir votre code comme ceci: c->{String k="";for(;k.length()<31;)k+=0;return k+=c?1:0;}. C'est k+=c?1:0de raccourcir k+(c?1:0).
— Olivier Grégoire
@ OlivierGrégoire Merci mais pourquoi le dernier point-virgule n'est-il pas obligatoire?
— V. Courtois
1
Il est obligatoire, dans le code, mais pas dans l'extrait. Dans le TIO, le pied de page peut simplement commencer par ;. Une instruction nécessite un point-virgule. Un lambda n'est pas une déclaration.
— Olivier Grégoire
1

Japt , 13 11 octets

?1:0 ¤i31ç0

Explication:

?1:0 ¤i31ç0
?              // If the input is a truthy, return:
 1             //   1
  :0           //   Else, 0
     ¤         // Convert to a base-2 string
      i        // Insert at index 0:
       31ç0    //   A string filled with 0s, length 31

Enregistré un octet en utilisant une conversion en base 2 intégrée!

Pour insérer la chaîne de 0 devant le 1/ 0, je dois lancer le 1et 0dans une chaîne. La façon typique de le faire serait 1s (3 octets). Mais comme nous ne convertissons que des 1 et des 0, je peux utiliser la base 2 intégrée 1¤(2 octets).

L'entrée peut être sous la forme d'un entier ou d'une chaîne.

0et ""sont fausses dans Japt.

Essayez-le en ligne!

Suite de tests

— Oliver
source
1

C # (.NET Core) , 29 octets

a=>new string('0',31)+(a?1:0)

OP dit que 1/0 peut être utilisé pour truey / falsey, donc peut faire aun int et il devient

a=>new string('0',31)+a

C # n'a pas vraiment de vérité / falsey, donc je n'utiliserai pas cette réponse.

Essayez-le en ligne!

— LiefdeWen
source
1
Je ne pense pas que le second soit valide. Les entiers ne sont ni véridiques ni falsey en C #, seuls les bools le sont.
— Skidsdev
@ Mayube, j'ai demandé et OP a dit que ça allait, mais je suis plutôt d'accord avec vous donc je vais modifier.
— LiefdeWen
1
Ici Padleftvient énormément le même nombre d'octets.
— TheLethalCoder
@TheLethalCoder A également commencé avec PadLeft :)
— LiefdeWen
2
Je ne sais pas si cela est possible, mais interpolated stringspeut être très utile ici:b=>$"{(b?1:0):D32}" 19 bytes
— auhmaan
1

MY , 10 9 octets

𝕫BṄiℑpέ←←

Essayez-le en ligne!

Explication (page de code [avec le raisonnement derrière le caractère] / code hexadécimal):

𝕫: 1A - Push an integer from STDIN (lowercase integers)
B: 0B - Push 11 (B is 11 in hex)
Ṅ: 36 - Pop n; push the nth prime, 11th prime is 31 (Ṅ-th)
i: 49 - Pop n; push [1,...,n] (index/iota)
ℑ: 34 - Pop n; push imag(n) (ℑmaginary part, applied to each element, which gives 0 for real numbers)
p: 60 - Pop n; push stringified n (0=>"0" ... 35=>"Z", the b in base upside down)
έ: 56 - Pop n; push n joined by "" (έmpty string)
←: 26 - Pop n; output n with no newline (out←in)
←: 26 - Pop n; output n with no newline (out←in)

Je ne peux pas croire que cela soit possible sans aucune commande à deux arguments!

Edit: enregistré 1 octet en utilisant des nombres premiers au lieu de l'arithmétique pour obtenir 31.

— Zacharý
source
0

APL, 11 octets

⍕¯32↑1↑1\⍨⊢

Comment?

1\⍨⊢ - répéter 1 fois l'entrée - retourner un tableau vide sur la valeur falsifiée

1↑ - prenez le premier article

¯32↑ - aligner à droite avec 31 zéros

⍕ - format sous forme de chaîne

— Uriel
source
⍕¯32↑⊢
— Ça
1
@Cowsquack & Uriel Aucun ne fonctionne car ils incluent des espaces. Vous avez besoin ∊⍕¨¯32↑⎕ou quelque chose.
— Adám
0

J, 11 octets

(31#'0'),":

Essayez-le en ligne!

Comment?

31 zeros
00...000  append     turn the 0 or 1 input into string
(31#'0')    ,       ":

note: en J, les booléens sont 0 ou 1, également connu comme "la convention d'iverson", d'après ken iverson, créateur de J et APL

— Jonas
source
Je comprends que 1 et 0 sont des booléens en J, mais vous ajoutez simplement l'entrée à 31 0. Ne devrait-il pas y avoir une forme de validation booléenne?
— Oliver
@Oliver Le problème spécifie "Étant donné une valeur truey / falsey ..." donc non, je ne pense pas que vous devriez valider ... Notez également que cela ":est nécessaire pour que cela fonctionne - il change un booléen en chaîne .
— Jonah
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.