Nadmiarowa wartość logiczna

19

Wprowadzenie

Klasycznie booleany mają jeden bit; truealbo false, 1albo 0. Zera wiodące byłyby po prostu zbędne. Na przykład 001oznacza to samo co 00001lub tylko 1.

32-bitowa wartość logiczna

Biorąc pod uwagę wartość true / falsey, wypisuje ekwiwalent 32-bitowej wartości logicznej jako ciąg. (Lub jako liczba, jeśli dla jakiegoś powodu twój język obsługuje wiodące zera).

Twój program nie musi działać na każdy typ prawdy / fałszu, tylko na to, na co najlepiej działa Twój język programowania.

Przykład we / wy

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

To jest golf golfowy , więc wygrywa najmniej bajtów!

code-golf  string 
— Grawiton
źródło
6
Czy musimy sobie poradzić z jakąkolwiek możliwą wartością prawdy lub falseya, czy po prostu boolami?
— xnor
Jeśli mój język obsługuje typy i ma wartość logiczną, czy mogę używać 1 (int) jako prawdy?
— LiefdeWen,
@LiefdeWen oczywiście
— Graviton
1
Nie jest już duplikowany, ponieważ dane wprowadzane zgodnie z prawdą / fałszem nie mogą być różne dla każdej odpowiedzi / języka.
— Graviton,
Nie rozumiem dlaczego, ale dobrze ~
— V. Courtois,

Odpowiedzi:

9

x86-16 Kod maszynowy (DOS), 16 bajtów

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

Powyższa funkcja otrzymuje w BLrejestrze wartość logiczną (0 == falsey, 1 == prawda) BXi wypisuje na standardowym wyjściu ciąg znaków „redundantny”.

Działa poprzez wywołanie przerwania (0x21), aby wykonać wywołanie funkcji DOS (wybrane przez ustawienie AHna 2), które wypisuje pojedynczy znak (wDL ) na standardowe wyjście.

Najpierw ładowany jest znak ASCII „0” DL, licznik ( CX) jest ustawiony na 31 i zapętla się, aby wydrukować „nadmiarowe” bajty. Następnie dodawana jest wartość logiczna wejściowa DL(jeśli BLjest falsey, dodanie 0 pozostawi DLniezmienioną jako ASCII „0”; jeśli BLjest prawdą, DLzostanie zwiększone o jeden do ASCII „1”), i zostanie wydrukowany ostatni bajt.

Funkcja nie zwraca wartości.

Całkiem przyzwoicie jak na język, który tak naprawdę nie robi nici.

Pełny program, 21 bajtów

Jeśli chcesz przekształcić go w pełny program, potrzeba tylko 5 dodatkowych bajtów. Zamiast przekazywać dane wejściowe do rejestru, odczytuje dane wejściowe z argumentów przekazanych w wierszu poleceń podczas wywoływania aplikacji. Argument 0 jest interpretowany jako falsey, podobnie jak całkowity brak argumentów; argument większy niż 0 jest interpretowany jako prawdziwy.

Po prostu złóż poniższy kod jako program COM, a następnie uruchom go w wierszu poleceń.

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

Przykładowe dane wyjściowe:

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

Jak to działa? Cóż, to w zasadzie to samo, dopóki nie przejdziesz do CMPinstrukcji. Porównuje to argument wiersza poleceń z wartością parametruDL rejestru (który, jak pamiętacie, zawiera ASCII „0”). W programie COM bajty kodu są ładowane z przesunięciem 0x100. Poprzednikiem jest prefiks segmentu programu (PSP) , który zawiera informacje o stanie programu DOS. W szczególności przy przesunięciu 0x82 znajduje się pierwszy (właściwie drugi, ponieważ pierwszy jest spacją) argument, który został podany w wierszu poleceń podczas wywoływania programu. Właśnie porównujemy ten bajt z ASCII „0”.

Porównanie ustawia flagi, a następnie SALCinstrukcja (nieudokumentowany kod operacyjny przed Pentium, równoważny sbb al, al, ale tylko 1 bajt zamiast 2) ustawia ALna 0, jeśli dwie wartości były równe, lub -1, jeśli były różne. Jest wtedy oczywiste, że kiedy odejmujemyAL od DLpowoduje to zarówno ASCII „0” lub „1”, odpowiednio.

(Zauważ, że nieco ironicznie złamiesz go, jeśli podasz argument z wiodącym 0 w wierszu poleceń, ponieważ wygląda tylko na pierwszy znak. 01Będzie to traktowane jak falsey. :-)

— Cody Gray
źródło
7

JavaScript, 23 bajty

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

!!a wymusza a na boolean, który unary plus zmienia się w int.

— SuperStormer
źródło
a=>'0'.repeat(31)+(+a)jest o jeden bajt krótszy.
— Kritixi Lithos
@Cowsquack, który nie działa na łańcuchy, puste tablice, NaN, funkcje i inne wartości, w których przymus na liczbę nie powoduje 0 lub 1
— SuperStormer
także puste obiekty, tablice, Nieskończoność i niezdefiniowane
— SuperStormer
1
... ale teraz ...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)+~~adziała z true, false, 1,0
— edc65
6

V , 8 bajtów

32é0Àñl

Wypróbuj online!

Wyjaśnienie:

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
źródło
4

ArnoldC , 369 bajtów

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

Wypróbuj online!

— TemporalWolf
źródło
2
Witamy w PPCG!
— Stephen
4

Brainfuck , 61 60 36 bajtów

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

Jestem pewien, że istnieje sprytny sposób, aby nie poruszać się tak bardzo za pomocą wskaźników.

Miałem rację. Byli. Dzięki @Graviton za pomysł!

Następny krok: Uzyskaj wartości 32 i 48 szybciej!

Wypróbuj 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.

To była zabawa dla pierwszego golfa!

Było już za późno. Co ja w ogóle robię

— Raphaël Côté
źródło
Dzięki entropii skróciłem o 1 bajt, aby dostać się do numeru 16.
— Raphaël Côté
Dla zabawy jest tutaj wersja 60-bajtowa: >-[-[-<]>>+<]>--<<-[>+<-----]>--->[-<.>],.(przyjmuje dane wejściowe jako 0 lub 1) Wypróbuj online!
— Graviton,
Dziękuję bardzo @ Graviton. Uświadomiłeś mi, że wkładam zbyt wiele wysiłku w upuszczanie wartości ASCII do zera, a ja po prostu muszę ją wyprowadzać.
— Raphaël Côté
3

Scala, 32 bajty

Przepraszam, ale byłem zmuszony to zrobić w 32 bajtach> _ <

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

Jest on zawarty w funkcji przyjmującej tjako parametr (jako, stringże może to być „0” lub „1” dla odpowiednio fałszu lub prawdy) orazs jest zwracany.

Wypróbuj online!

Prawidłowa odpowiedź: Scala, 46 bajtów

Tak jak moja odpowiedź w języku Java, miałem wziąć wartość logiczną dla parametru. Więc :

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

Wypróbuj online!

— V. Courtois
źródło
3

Braingolf , 10 8 bajtów

#␟>[0_]N

Wypróbuj online!

␟ jest separatorem jednostek, ASCII 0x1F lub 31. Nie można znaleźć rzeczywistego znaku do wklejenia do TIO, więc TIO zamiast tego używa # 1-, co przesuwa spację (32) i zmniejsza do 31.

Wyjaśnienie

#␟>[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
źródło
Oto link tio ze znakiem 0x1F TIO
— PunPun1000,
@ PunPun1000 O dzięki! Zaktualizuję post
— Skidsdev,
2

Oktawa , 23 bajty

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

Wypróbuj online!

Jest to krótsze niż wszystkie podejścia, z którymi próbowałem printf. Mogłem coś przeoczyć, ponieważ zrobiłem to na telefonie.

Tylko jeden bajt dłużej

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

Może to być 18 bajtów, gdybym mógł wziąć 1/0 jako łańcuch.

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

Wypróbuj online!

— Stewie Griffin
źródło
2

Java 8, 31 27 bajtów

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

-4 bajty dzięki @ OlivierGrégoire .

Wypróbuj tutaj.

— Kevin Cruijssen
źródło
1
Tak, wciąż tu jestem, aby cię ogłuszyć:; "".format)
— Olivier Grégoire,
1
@ OlivierGrégoire To było to! Cholera, jestem głupia .. xD Kiedy pisałem String.format, wiedziałem, że jest jakoś krótszy sposób, ale myślałem, że ostatnio użyłem zmiennej String ... Dzięki. ;)
— Kevin Cruijssen
1

C, 26 bajtów

Prawie taki sam pomysł jak rozwiązanie 1bluestone , ale w C jest krótszy i działa poprawnie dla każdego wejścia liczb całkowitych:

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

Oczywiście, to zawiera kilka niejawnie wpisywanych zmiennych / funkcji, jak wszystkie dobre odpowiedzi C-golf zrobić ... The !!operator jest najkrótsza droga do konwersji wszelkich wartość truthy się 1w C (przez podwójne zaprzeczenie, !definiuje się wrócić albo 1albo 0).

Testuj z:

#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 - przywróć monikę
źródło
1

PHP, 28 bajtów

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

Zapisz jako bool.php i uruchom:

$ php bool.php 0
00000000000000000000000000000000
$ php bool.php 1
00000000000000000000000000000001
— Jared Mellentine
źródło
3 bajty krótsze: printf('%032d',$argv[1]);(wymaga -rflagi).
— user63956,
1

Ly , 20 15 13 bajtów

65*1+[0u1-]nu

EDYCJA: Oszczędność 5 bajtów dzięki ovs.
EDYCJA: Zapisano kolejne 2 bajty, drukując 0 jako liczbę, a nie znak.

— LyricLy
źródło
Czy 65*1+["0"o1-]nuzadziała?
— ovs
1

Oktawa, 16 11 bajtów

@(x)x(1:32)

Wypróbuj online!

Uchwyt funkcyjny, który przyjmuje "00000000000000000000000000000001"zarówno prawdę, "00000000000000000000000000000000\0"jak i falsey.

Wyjaśnienie:

In Octave an array is considered as falsey if at least one of its elements is zero. The 33th element of the second string is a character with the ASCII value of 0 so it can be considered as falsey.

— rahnema1
źródło
1

Java, 40 chars, 40 bytes

This takes string as parameter, which is not correct (falsy/truthy java value is forced by OP to be represented by a boolean).

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

Try It Online!

Valid response : Java, 60 chars, 60 bytes

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

Try It Online!

I know there is already a Java answer which is shorter than this one, but still :)

— V. Courtois
źródło
Yes, the return statement is part of your code, so part of your byte-count. But your answer doesn't fulfill the rules: you must get a boolean as input. "Truthy/falsy" is translated in Java as either true or false, and nothing else. So you can't get a String as input parameter.
— Olivier Grégoire
I see. I'll modify it soon enough. Thanks.
— V. Courtois
1
You don't need to put the final semicolon (;). Also, you can shorten your code like this: c->{String k="";for(;k.length()<31;)k+=0;return k+=c?1:0;}. The k+=c?1:0 is to shorten k+(c?1:0).
— Olivier Grégoire
@OlivierGrégoire Thanks but why isn't the final semicolon mandatory?
— V. Courtois
1
It is mandatory, in the code, but not in the snippet. In the TIO, the footer can simply start with ;. A statement requires a semicolon. A lambda is not a statement.
— Olivier Grégoire
1

Japt, 13 11 bytes

?1:0 ¤i31ç0

Explanation:

?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

Saved a byte using a base-2 conversion built-in!

To insert the string of 0s in front of the 1/0, I need to cast the 1 and 0 into a string. The typical way of doing that would be 1s  (3 bytes). But because we're only converting 1s and 0s, I can use the base-2 built-in 1¤ (2 bytes).

Input can be in the form of an integer or string.

0 and "" are falsy in Japt.

Try it online!

Test suite

— Oliver
źródło
1

C# (.NET Core), 29 bytes

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

OP said 1/0 can be used for truthy/falsey, so can make a an int and it becomes

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

C# doesn't really have truthy/falsey though so I will not use this answer.

Try it online!

— LiefdeWen
źródło
1
I don't think the second one is valid. Integers are neither truthy nor falsey in C#, only bools are.
— Skidsdev
@Mayube I did ask and OP said its okay, but I kinda agree with you so will edit.
— LiefdeWen
1
Annoyingly Padleft comes in at the same byte count here.
— TheLethalCoder
@TheLethalCoder Started with PadLeft as well :)
— LiefdeWen
2
Not sure if this is possible, but interpolated strings can be quite useful here: b=>$"{(b?1:0):D32}" 19 bytes
— auhmaan
1

MY, 10 9 bytes

𝕫BṄiℑpέ←←

Try it online!

Explanation (codepage [with reasoning behind the character]/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)

I can't believe that this is possible without any two-argument commands whatsoever!

Edit: Saved 1 byte by using primes instead of arithmetic to get 31.

— Zacharý
źródło
0

APL, 11 bytes

⍕¯32↑1↑1\⍨⊢

How?

1\⍨⊢ - repeat 1 input times - return empty array on falsy value

1↑ - take the first item

¯32↑ - align right with 31 zeros

⍕ - format as string

— Uriel
źródło
Simply ⍕¯32↑⊢ should work
— Kritixi Lithos
1
@Cowsquack & Uriel Neither works as they include spaces. You need ∊⍕¨¯32↑⎕ or something.
— Adám
0

J, 11 bytes

(31#'0'),":

Try it online!

how?

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

note: in J, booleans are 0 or 1, also known as "the iverson convention," after ken iverson, creator of J and APL

— Jonah
źródło
I understand that 1 and 0 are booleans in J, but you're just appending the input to 31 0s. Shouldn't there be some form of boolean validation?
— Oliver
@Oliver The problem specifies "Given a truthy/falsey value..." so no, I don't think you should be validating... Also, note that ": is required for this to work -- it changes a boolean to a string.
— Jonah
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.