Der redundante Boolesche Wert

19

Einführung

Klassischerweise sind Boolesche Werte ein Bit. trueoder false, 1oder 0. Führende Nullen wären einfach überflüssig. Zum Beispiel 001bedeutet das gleiche wie 00001oder nur 1.

Der 32-Bit-Boolesche Wert

Wenn Sie einen Wert für "truthy / falsey" angeben, geben Sie den entsprechenden 32-Bit-Booleschen Wert als Zeichenfolge aus. (Oder als Zahl, wenn Ihre Sprache aus irgendeinem Grund führende Nullen unterstützt.)

Ihr Programm muss nicht für jeden Wahrheits- / Falschtyp geeignet sein, sondern nur für das, wofür Ihre Programmiersprache am besten geeignet ist.

Beispiel I / O

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

Das ist Code-Golf , also gewinnt das niedrigste Byte!

code-golf  string 
— Graviton
quelle
6
Müssen wir mit möglichen Wahrheiten oder falschen Werten umgehen oder nur mit Booleschen?
— Xnor
Wenn meine Sprache Typen unterstützt und Boolesche Werte hat, kann ich Einsen (int) als wahrheitsgemäß verwenden?
— LiefdeWen
@LiefdeWen natürlich
— Graviton
1
Nicht mehr duplizieren, da wahrheitsgemäße / falsche Eingaben nicht für jede Antwort / Sprache unterschiedlich sein können.
— Graviton
Ich verstehe nicht warum, aber huh, okay ~
— V. Courtois

Antworten:

9

x86-16-Computercode (DOS), 16 Byte

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

Die obige Funktion empfängt einen Booleschen Wert (0 == Falsey, 1 == Truthy) im BLRegister (Low-Byte von BX) und gibt einen "redundanten Booleschen" String an die Standardausgabe aus.

Es funktioniert durch Aufrufen eines Interrupts (0x21), um einen DOS-Funktionsaufruf (ausgewählt durch Setzen AHauf 2) auszuführen, der ein einzelnes Zeichen (in DL) an die Standardausgabe ausgibt.

Zuerst wird das ASCII-Zeichen '0' geladen DL, der Zähler ( CX) wird auf 31 gesetzt und es wird eine Schleife ausgeführt, um die "redundanten" Bytes zu drucken. Dann wird der boolesche Eingabewert addiert DL(wenn BLfalsch ist, bleibt das Addieren von 0 DLunverändert als ASCII '0'; wenn BLwahr, DLwird es um eins zu ASCII '1' inkrementiert), und das letzte Byte wird gedruckt.

Die Funktion gibt keinen Wert zurück.

Ziemlich anständig für eine Sprache, die nicht wirklich Streicher ist.

Volles Programm, 21 Bytes

Wenn Sie ein vollständiges Programm erstellen möchten, sind nur noch 5 Bytes erforderlich. Anstatt die Eingabe in ein Register zu übergeben, wird die Eingabe aus den Argumenten gelesen, die beim Aufrufen der Anwendung in der Befehlszeile übergeben wurden. Ein Argument von 0 wird ebenso wie das völlige Fehlen von Argumenten als falsch interpretiert. Ein Argument größer als 0 wird als wahr interpretiert.

Stellen Sie einfach den folgenden Code als COM-Programm zusammen und führen Sie ihn dann in der Befehlszeile aus.

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

Beispielausgabe:

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

Wie funktioniert es? Nun, es ist im Grunde dasselbe, bis Sie zur CMPAnweisung kommen. Dadurch wird das Befehlszeilenargument mit dem Wert des DLRegisters verglichen (das, wie Sie sich erinnern, eine ASCII-0 enthält). In einem COM-Programm werden die Codebytes mit dem Offset 0x100 geladen. Davor steht das Programmsegment-Präfix (PSP) , das Informationen zum Status eines DOS-Programms enthält. Insbesondere finden Sie bei Offset 0x82 das erste (eigentlich das zweite, da das erste ein Leerzeichen ist) Argument, das in der Befehlszeile angegeben wurde, als das Programm aufgerufen wurde. Wir vergleichen dieses Byte also nur mit einer ASCII-0.

Beim Vergleich werden die Flags gesetzt, und dann wird der SALCBefehl (ein undokumentierter Opcode vor dem Pentium, der sbb al, alnur 1 Byte anstelle von 2 entspricht) ALauf 0 gesetzt, wenn die beiden Werte gleich waren, oder auf -1, wenn sie unterschiedlich waren. Es ist dann klar , dass , wenn wir subtrahieren ALaus DL, ergibt sich daraus entweder ASCII ‚0‘ oder ‚1‘, als angemessen.

(Beachte, dass du es ironischerweise kaputt machst, wenn du ein Argument mit einer führenden 0 in der Kommandozeile 01übergibst , da es nur auf das erste Zeichen abzielt. Also wird es als falsch behandelt. :-)

— Cody Gray
quelle
7

Javascript, 23 Bytes

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

!!a zwingt a zu einem Booleschen Wert, aus dem das unäre Plus ein int wird.

— SuperStormer
quelle
a=>'0'.repeat(31)+(+a)ist ein Byte kürzer.
— Kritixi Lithos
@Cowsquack, das bei Zeichenfolgen, leeren Arrays, NaN, Funktionen und anderen Werten fehlschlägt, bei denen das Erzwingen einer Zahl nicht zu 0 oder 1 führt
— SuperStormer
auch leere Objekte, Arrays, Infinity und undefined
— SuperStormer
1
... aber jetzt ...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)+~~afunktioniert mit true, false, 1,0
— edc65 20.07.17
6

V , 8 Bytes

32é0Àñl

Probieren Sie es online!

Erläuterung:

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
quelle
4

ArnoldC , 369 Bytes

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

Probieren Sie es online!

— TemporalWolf
quelle
2
Willkommen bei PPCG!
— Stephen
4

Brainfuck , 61 60 36 Bytes

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

Ich bin sicher, es gibt eine clevere Möglichkeit, sich mit den Zeigern nicht so viel zu bewegen.

Ich lag richtig. Dort gab es. Vielen Dank an @Graviton für die Idee!

Nächster Schritt: Holen Sie sich die Werte 32 und 48 schneller!

Probieren Sie es online!

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

Hat Spaß gemacht für einen ersten Golf!

Es ist viel zu spät geworden. Was mache ich überhaupt?

— Raphaël Côté
quelle
Dank Entropie habe ich es 1 Byte kürzer gemacht, um zur Nummer 16 zu gelangen.
— Raphaël Côté
Nur zum Spaß hier ist eine 60-Byte-Version: >-[-[-<]>>+<]>--<<-[>+<-----]>--->[-<.>],.(Eingabe als 0 oder 1) Probieren Sie es online!
— Graviton
Nun, vielen Dank @Graviton. Sie haben mir klar gemacht, dass ich mir viel zu viel Mühe gegeben habe, den ASCII-Wert auf 0 zu setzen, während ich ihn nur ausgeben musste.
— Raphaël Côté
3

Scala, 32 Bytes

Sorry, aber ich musste es in 32 Bytes> _ <tun

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

Es wird von einer Funktion eingeschlossen, die tals Parameter verwendet wird (als string"0" oder "1" für bzw. falsch oder wahr) und szurückgegeben.

Probieren Sie es online!

Gültige Antwort: Scala, 46 Bytes

Genau wie meine Java-Antwort sollte ich einen Booleschen Wert für den Parameter verwenden. So :

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

Probieren Sie es online!

— V. Courtois
quelle
3

Braingolf , 10 8 Bytes

#␟>[0_]N

Probieren Sie es online!

␟ist ein Unit Separator, ASCII 0x1Foder 31. Kann das tatsächliche Zeichen nicht finden, das in TIO eingefügt werden soll, daher verwendet TIO stattdessen # 1-das Leerzeichen (32) und dekrementiert es auf 31.

Erläuterung

#␟>[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
quelle
Hier ist die tio Verbindung mit dem 0x1F Zeichen in ihm Tio
— PunPun1000
@ PunPun1000 Oh danke! Ich werde den Beitrag aktualisieren
— Skidsdev 20.07.17
2

Oktave , 23 Bytes

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

Probieren Sie es online!

Dies ist kürzer als alle Ansätze, mit denen ich versucht habe printf. Möglicherweise habe ich jedoch etwas verpasst, da ich dies auf meinem Telefon getan habe.

Nur noch ein Byte länger

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

Das könnten 18 Bytes sein, wenn ich 1/0 als Zeichenkette nehmen könnte.

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

Probieren Sie es online!

— Stewie Griffin
quelle
2

Java 8, 31 27 Bytes

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

-4 Bytes dank @ OlivierGrégoire .

Probieren Sie es hier aus.

— Kevin Cruijssen
quelle
1
Ja, immer noch hier, um dich zu überraschen:; "".format)
— Olivier Grégoire
1
@ OlivierGrégoire Das war es! Verdammt, ich bin dumm ... xD Als ich getippt String.formathabe, wusste ich, dass es irgendwie einen kürzeren Weg gibt, aber ich dachte, ich habe letztes Mal wahrscheinlich eine String-Variable verwendet ... Danke. ;)
— Kevin Cruijssen
1

C 26 Bytes

Ziemlich die gleiche Idee wie die Lösung von 1bluestone , aber in C ist sie kürzer und funktioniert bei jeder Ganzzahleingabe korrekt:

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

Dies schließt natürlich einige implizit eingegebene Variablen / Funktionen ein, wie dies bei allen guten C-Golf-Antworten !!der Fall ist ... Der Operator ist der kürzeste Weg, um einen Wahrheitswert 1in C umzuwandeln (über doppelte Negation !wird definiert, ob er entweder 1oder zurückgibt 0).

Testen Sie mit:

#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");
}
— In cmaster stellst du Monica wieder her
quelle
1

PHP, 28 Bytes

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

Als bool.php speichern und ausführen:

$ php bool.php 0
00000000000000000000000000000000
$ php bool.php 1
00000000000000000000000000000001
— Jared Mellentine
quelle
3 Bytes kürzer: printf('%032d',$argv[1]);(erfordert das -rFlag).
— user63956
1

Ly , 20 15 13 Bytes

65*1+[0u1-]nu

BEARBEITEN: 5 Bytes dank ovs gespeichert.
BEARBEITEN: Speichert weitere 2 Bytes, indem 0 als Zahl und nicht als Zeichen gedruckt wird.

— Textlich
quelle
Würde 65*1+["0"o1-]nufunktionieren
— Ovs
1

Oktave, 16 11 Bytes

@(x)x(1:32)

Probieren Sie es online!

Ein Funktionshandle, das "00000000000000000000000000000001"als wahr und "00000000000000000000000000000000\0"als falsch gilt.

Erläuterung:

In Octave wird ein Array als falsch betrachtet, wenn mindestens eines seiner Elemente Null ist. Das 33. Element der zweiten Zeichenfolge ist ein Zeichen mit dem ASCII-Wert 0, sodass es als falsch betrachtet werden kann.

— rahnema1
quelle
1

Java, 40 Zeichen, 40 Bytes

Als Parameter wird ein String verwendet, der nicht korrekt ist (der Java-Wert falsy / truthy wird von OP gezwungen, durch einen Booleschen Wert dargestellt zu werden).

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

Probieren Sie es online!

Gültige Antwort: Java, 60 Zeichen, 60 Byte

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

Probieren Sie es online!

Ich weiß, dass es bereits eine Java-Antwort gibt, die kürzer ist als diese, aber immer noch :)

— V. Courtois
quelle
Ja, die returnAnweisung ist Teil Ihres Codes, also Teil Ihrer Byteanzahl. Aber Ihre Antwort erfüllt nicht die Regeln: Sie müssen eine booleanals Eingabe erhalten. "Wahrheit / Falsch" wird in Java als entweder trueoder falseund sonst nichts übersetzt. Sie können also keinen Stringals Eingabeparameter erhalten.
— Olivier Grégoire
Aha. Ich werde es bald genug ändern. Vielen Dank.
— V. Courtois
1
Sie müssen das letzte Semikolon ( ;) nicht setzen. Außerdem können Sie Ihren Code wie folgt verkürzen: c->{String k="";for(;k.length()<31;)k+=0;return k+=c?1:0;}. Das k+=c?1:0ist zu verkürzen k+(c?1:0).
— Olivier Grégoire
@ OlivierGrégoire Danke, aber warum ist das letzte Semikolon nicht obligatorisch?
— V. Courtois
1
Es ist obligatorisch im Code, aber nicht im Snippet. In der TIO kann die Fußzeile einfach mit beginnen ;. Eine Anweisung erfordert ein Semikolon. Ein Lambda ist keine Aussage.
— Olivier Grégoire
1

Japt , 13 11 Bytes

?1:0 ¤i31ç0

Erläuterung:

?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

Ein Byte mit einer integrierten Base-2-Konvertierung gespeichert!

Um die Zeichenfolge von 0s vor dem 1/ einzufügen 0, muss das 1und 0in eine Zeichenfolge umgewandelt werden. Die typische Vorgehensweise wäre 1s (3 Bytes). Da wir jedoch nur Einsen und Nullen konvertieren, kann ich die integrierte Basis 2 1¤(2 Byte) verwenden.

Die Eingabe kann in Form einer Ganzzahl oder einer Zeichenfolge erfolgen.

0und ""sind falsch in Japt.

Probieren Sie es online!

Testsuite

— Oliver
quelle
1

C # (.NET Core) , 29 Byte

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

OP sagte 1/0 kann für Truthy / Falsey verwendet werden, kann also aein Int machen und es wird

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

C # hat zwar nicht wirklich Wahrhaftigkeit / Falschheit, daher werde ich diese Antwort nicht verwenden.

Probieren Sie es online!

— LiefdeWen
quelle
1
Ich denke nicht, dass der zweite gültig ist. Ganzzahlen sind in C # weder wahr noch falsch, nur Bools.
— Skidsdev
@ Mayube Ich habe gefragt und OP sagte, dass es in Ordnung ist, aber ich stimme dir irgendwie zu, also werde ich es bearbeiten.
— LiefdeWen
1
Ärgerlicherweise Padleftkommt hier die gleiche Byteanzahl rein.
— TheLethalCoder
@TheLethalCoder Begonnen auch mit PadLeft :)
— LiefdeWen
2
Ich interpolated stringsb=>$"{(b?1:0):D32}" 19 bytes
— bin
1

MEIN , 10 9 Bytes

𝕫BṄiℑpέ←←

Probieren Sie es online!

Erklärung (Codepage [mit Begründung hinter dem Zeichen] / Hex-Code):

𝕫: 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)

Ich kann nicht glauben, dass dies ohne irgendwelche Befehle mit zwei Argumenten möglich ist!

Bearbeiten: 1 Byte gespeichert, indem Primzahlen anstelle von Arithmetik verwendet werden, um 31 zu erhalten.

— Zacharý
quelle
0

APL, 11 Bytes

⍕¯32↑1↑1\⍨⊢

Wie?

1\⍨⊢ - 1 Eingabe wiederholen - leeres Array bei falschem Wert zurückgeben

1↑ - Nimm den ersten Gegenstand

¯32↑ - Mit 31 Nullen rechts ausrichten

⍕ - Format als Zeichenfolge

— Uriel
quelle
⍕¯32↑⊢
— Sollte
1
@Cowsquack & Uriel Weder funktioniert, als sie Leerzeichen enthalten. Du brauchst ∊⍕¨¯32↑⎕oder so.
— Adám
0

J, 11 Bytes

(31#'0'),":

Probieren Sie es online!

Wie?

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

Anmerkung: In J sind Boolesche Werte 0 oder 1, auch als "Iverson-Konvention" bekannt, nach Ken Iverson, dem Schöpfer von J und APL

— Jona
quelle
Ich verstehe, dass 1 und 0 in J Boolesche Werte sind, aber Sie hängen die Eingabe nur an 31 0s an. Sollte es keine Form der booleschen Validierung geben?
— Oliver
@Oliver Das Problem gibt an, dass "ein Wahrheits- / Falsch-Wert angegeben wurde ...", also nein, ich glaube nicht, dass Sie validieren sollten ... Beachten Sie auch, dass dies ":erforderlich ist - es ändert einen Booleschen Wert in einen String .
— Jonah
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.