Gereksiz boolean

19

Giriş

Klasik olarak, booleans bir bit; trueveya false, 1veya 0. Baştaki sıfırlar artık gereksiz olurdu. Örneğin, ya da sadece 001aynı anlama gelir .000011

32 bit boole

Bir true / falsey değeri verildiğinde, eşdeğer 32 bit boole değerini dize olarak çıktılar. (Veya bir nedenle diliniz baştaki sıfırları destekliyorsa sayı olarak .)

Programınız her doğruluk / falsi türü için çalışmak zorunda değildir, sadece programlama dilinizin en iyi şekilde çalıştığı şeydir.

Örnek g / ç

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

Bu kod golf , bu yüzden en düşük bayt kazanır!

code-golf  string 
— Graviton
kaynak
6
Herhangi bir doğruluk veya falsey değerini veya sadece booleanları ele almamız gerekiyor mu?
— xnor
Dilim türleri destekliyorsa ve boolean varsa 1'leri (int) doğruluk olarak kullanabilir miyim?
— LiefdeWen
@LiefdeWen Tabii ki
— Graviton
1
Doğruluk / falsy girdileri her cevap / dil için farklı olabileceğinden artık çoğaltılmaz.
— Graviton
Nedenini bilmiyorum ama ha, tamam ~
— V. Courtois

Yanıtlar:

9

x86-16 Makine Kodu (DOS), 16 bayt

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

Yukarıdaki işlev, BLkayıt defterine (düşük bayt BX) bir boole değeri (0 == falsey, 1 == doğruluk) alır ve standart çıktıya bir "gereksiz boole" dizesi yazdırır.

Standart çıkışa AHtek bir karakter (in DL) yazdıran bir DOS işlev çağrısı ( 2'ye ayarlanarak seçilen) yapmak için bir kesme (0x21) çağırarak çalışır .

İlk olarak, ASCII karakteri '0' yüklenir DL, counter ( CX) 31 olarak ayarlanır ve "gereksiz" baytları yazdırmak için döngüler. Daha sonra, giriş boole değeri eklenir DL( falsey ise , 0 BLeklenmesi DLASCII '0' olarak değişmeden kalır; doğruysa ASCII '1'e bir arttırılır) ve son bayt yazdırılır.BLDL

İşlev bir değer döndürmez.

Gerçekten dizeleri olmayan bir dil için oldukça iyi.

Tam Program, 21 bayt

Tam bir program haline getirmek istiyorsanız, sadece 5 bayt daha gereklidir. Bu, girdiyi bir kayıt defterine geçirmek yerine, uygulamayı çağırırken komut satırında iletilen bağımsız değişkenlerden gelen girdiyi okur. 0 argümanı, tam argüman eksikliği gibi falsey olarak yorumlanır; 0'dan büyük bir argüman doğruluk olarak yorumlanır.

Aşağıdaki kodu bir COM programı olarak birleştirin ve komut satırında yürütün.

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

Örnek Çıktı:

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

O nasıl çalışır? CMPTalimatlara ulaşıncaya kadar temelde aynı şey . Bu, komut satırı bağımsız değişkenini DLkaydın değeriyle karşılaştırır (hatırladığınız gibi, bir ASCII '0' içerir). Bir COM programında, kod baytları 0x100 uzaklığına yüklenir. Bundan önce , bir DOS programının durumu hakkında bilgi içeren program segmenti önekidir (PSP) . Özellikle, 0x82 uzaklığında, program çağrıldığında komut satırında belirtilen ilk (aslında ikincisi, bir boşluk olduğu için) bağımsız değişkenini bulursunuz. Bu baytı ASCII '0' ile karşılaştırıyoruz.

Karşılaştırma bayrakları ayarlar ve ardından iki değer eşitse SALCkomut (Pentium'dan önce belgelenmemiş bir opcode sbb al, al, 2 yerine eşdeğer , ancak yalnızca 1 bayt) AL0 veya farklıysa -1 değerini ayarlar . Biz çıkarmak zaman o zaman açıktır ALdan DLuygun olarak, bu iki ASCII '0' in sonuçları veya '1'.

(Biraz ironik bir şekilde, komut satırında baştaki 0 ​​ile bir argüman iletirseniz, yalnızca ilk karaktere baktığından onu kıracağınızı unutmayın. Bu yüzden 01falsey olarak değerlendirilecektir. :-)

— Cody Gray
kaynak
7

Javascript, 23 bayt

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

!!a a'yı bir boole'ye zorlar; tekli artı bir int'e dönüşür.

— SuperStormer
kaynak
a=>'0'.repeat(31)+(+a)bir bayt daha kısadır.
— Kritixi Lithos
@ Bir sayıya zorlamanın 0 veya 1 ile sonuçlanmadığı dizeler, boş diziler, NaN, işlevler ve diğer değerlerde başarısız olan Coowsquack
— SuperStormer
ayrıca boş nesneler, diziler, Sonsuzluk ve undefined
— SuperStormer
1
... ama şimdi ...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)+~~adoğru, yanlış, 1,0 ile çalışır
— edc65
6

V , 8 bayt

32é0Àñl

Çevrimiçi deneyin!

Açıklama:

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

ArnoldC , 369 bayt

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

Çevrimiçi deneyin!

— TemporalWolf
kaynak
2
PPCG'ye Hoşgeldiniz!
— Stephen
4

Brainfuck , 61 60 36 bayt

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

Eminim işaretçilerle çok fazla hareket etmemenin akıllıca bir yolu vardır.

Haklıydım. Vardı. Bana fikir verdiği için @Graviton'a teşekkürler!

Sonraki adım: 32 ve 48 değerlerini daha hızlı alın!

Çevrimiçi deneyin!

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

İlk Golf için eğlenceliydi!

Artık çok geç oldu. Ben ne yapıyorum

— Raphaël Côté
kaynak
Entropi sayesinde, 16 numaraya ulaşmak için 1 bayt daha kısa yaptım
— Raphaël Côté
Sadece eğlence için 60 baytlık bir sürüm: >-[-[-<]>>+<]>--<<-[>+<-----]>--->[-<.>],.(girişi 0 veya 1 olarak alır) Çevrimiçi Deneyin!
— Graviton
@Graviton'a çok teşekkürler. Bana sadece çıkış yapmak zorunda kalırken ASCII değerini 0'a düşürmek için çok fazla çaba harcadığımı fark ettin.
— Raphaël Côté
3

Scala, 32 bayt

Üzgünüz ama bunu 32 baytta yapmak zorunda kaldım> _ <

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

tParametre olarak alan bir işlev ile çevrelenir ( stringbu, sırasıyla yanlış veya doğruluk için "0" veya "1" olabilir) ve sdöndürülür.

Çevrimiçi Deneyin!

Geçerli yanıt: Scala, 46 bayt

Java yanıtımla aynı, parametre için bir boole almam gerekiyordu. Yani :

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

Çevrimiçi Deneyin!

— V. Courtois
kaynak
3

Braingolf , 10 8 bayt

#␟>[0_]N

Çevrimiçi deneyin!

␟Bir Birim Ayırıcı, ASCII 0x1Fveya 31'dir. TIO'ya yapıştırılacak gerçek karakteri bulamıyoruz, bu nedenle TIO # 1-, alanı (32) ve 31'e düşüren iticileri kullanır .

açıklama

#␟>[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
kaynak
İşte içinde 0x1F karakteri olan tio bağlantısı TIO
— PunPun1000
@ PunPun1000 Ah teşekkürler! Gönderiyi güncelleyeceğim
— Yazıyı Skidsdev
2

Oktav , 23 bayt

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

Çevrimiçi deneyin!

Bu benim denediğim tüm yaklaşımlardan daha kısadır printf. Telefonumda yaptığımdan beri bir şeyleri kaçırmış olabilirdim.

Sadece bir bayt daha uzun

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

Dizeler olarak 1/0 alabilirsem bu 18 bayt olabilir.

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

Çevrimiçi deneyin!

— Stewie Griffin
kaynak
2

Java 8, 31 27 bayt

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

-4 bayt sayesinde @ OlivierGrégoire .

Burada deneyin.

— Kevin Cruijssen
kaynak
1
Evet, hala seni geride bırakmak için buradayız "".format;;)
— Olivier Grégoire
1
@ OlivierGrégoire Bu kadar! Lanet olsun ben aptal .. xD Yazarken String.formatbir şekilde daha kısa bir yol olduğunu biliyordum, ama muhtemelen son kez bir String değişkeni kullandığımı düşündüm ... Teşekkürler. ;)
— Kevin Cruijssen
2

Ruby, 21 bayt

Evet, o alanın orada olması gerekiyor ..: /

->x{"%032b"%(x ?1:0)}

Yakut ise her şeyi hariç falseve niltruthy olduğu; Çevrimiçi deneyin!

— daniero
kaynak
1

C, 26 bayt

1bluestone'un çözümü ile hemen hemen aynı fikir , ancak C'de daha kısadır ve herhangi bir tamsayı girişi için doğru şekilde çalışır:

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

Tabii ki, bu C-golf cevaplar yaptığımız tüm iyi gibi bazı dolaylı yazılan değişkenler / işlevleri içerir ... !!operatör için herhangi truthy değerini dönüştürmek için en kısa yoldur 1çift olumsuzlama yoluyla (C, !dönmek tanımlanır ya 1ya0 ).

Şununla test et:

#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 - Monica'yı eski durumuna döndür
kaynak
1

PHP, 28 bayt

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

Bool.php kaydedin ve çalıştırın:

$ php bool.php 0
00000000000000000000000000000000
$ php bool.php 1
00000000000000000000000000000001
— Jared Mellentine
kaynak
3 bayt daha kısa: printf('%032d',$argv[1]);( -rbayrağı gerektirir ).
— user63956
1

Ly , 20 15 13 bayt

65*1+[0u1-]nu

EDIT: Ovs sayesinde 5 bayt kaydedildi.
DÜZENLE: 0'ı karakter yerine sayı olarak yazdırarak 2 bayt daha kaydetti.

— LyricLy
kaynak
Çalışır mıydı 65*1+["0"o1-]nu?
— ovs
1

Oktav, 16 11 bayt

@(x)x(1:32)

Çevrimiçi deneyin!

Alan bir işlev tutamacı "00000000000000000000000000000001"Doğruluk ve falsey gibi "00000000000000000000000000000000\0" .

Açıklama:

Oktav'da, öğelerinden en az biri sıfırsa bir dizi falsey olarak kabul edilir. İkinci dizenin 33. elemanı ASCII değeri 0 olan bir karakterdir, bu yüzden falsey olarak kabul edilebilir.

— rahnema1
kaynak
1

Java, 40 karakter, 40 bayt

Bu, dizeyi doğru olmayan bir parametre olarak alır (falsy / truthy java değeri OP tarafından bir boole ile temsil edilmeye zorlanır).

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

Çevrimiçi Deneyin!

Geçerli yanıt: Java, 60 karakter, 60 bayt

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

Çevrimiçi Deneyin!

Zaten bundan daha kısa bir Java cevabı olduğunu biliyorum, ama yine de :)

— V. Courtois
kaynak
Evet, returnifade kodunuzun bir parçasıdır, bu nedenle bayt sayımınızın bir parçasıdır. Ama cevap kurallarını yerine getirmemesi: Eğer gereken bir olsun booleangiriş olarak. "Truthy / falsy", Java'da ya ya trueda olarak çevrilir falseve başka bir şey değildir. Yani Stringgiriş parametresi olarak alamazsınız .
— Olivier Grégoire
Anlıyorum. Yakında değiştireceğim. Teşekkürler.
— V. Courtois
1
Son noktalı virgül ( ;) koymanıza gerek yoktur . Ayrıca, böyle kodunuzu kısaltabilirsiniz: c->{String k="";for(;k.length()<31;)k+=0;return k+=c?1:0;}. k+=c?1:0Kısaltmak olduğunu k+(c?1:0).
— Olivier Grégoire
@ OlivierGrégoire Teşekkürler ama son noktalı virgül neden zorunlu değil?
— V. Courtois
1
Kodda zorunludur, ancak kod parçasında yoktur. TIO'da altbilgi basitçe başlayabilir ;. Bir ifade noktalı virgül gerektirir. Bir lambda bir ifade değildir.
— Olivier Grégoire
1

Japt , 13 11 bayt

?1:0 ¤i31ç0

Açıklama:

?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

Yerleşik bir base-2 dönüşümü kullanarak bir bayt kaydetti!

Önündeki 0 ların dize eklemek için 1/ 0ben döküm gerek 1ve 0bir dizeye. Bunu yapmanın tipik yolu 1s (3 bayt) olacaktır. Ancak yalnızca 1'leri ve 0'ları dönüştürdüğümüz için, base-2 yerleşik 1¤(2 bayt) kullanabilirim.

Giriş bir tamsayı veya dize biçiminde olabilir.

0ve ""Japt'te sahtelidir.

Çevrimiçi deneyin!

Test odası

— Oliver
kaynak
1

C # (.NET Core) , 29 bayt

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

OP 1/0 doğruluk / falsey için kullanılabileceğini söyledi, bu yüzden abir int yapabilir ve olur

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

C # olsa gerçekten doğru / falsey yok, bu yüzden bu cevap kullanmayacağım.

Çevrimiçi deneyin!

— LiefdeWen
kaynak
1
İkincisinin geçerli olduğunu sanmıyorum. Tamsayılar C # 'da ne doğru ne de falsey, sadece bools.
— Skidsdev
@Mayube sordum ve OP tamam dedi, ama ben sana katılıyorum bu yüzden düzenleyecektir.
— LiefdeWen
1
Can sıkıcı bir şekilde Padleftburada aynı bayt sayımı geliyor.
— TheLethalCoder
@TheLethalCoder PadLeft ile de başladı :)
— LiefdeWen
2
Bunun mümkün olup olmadığından emin değilim, ancak interpolated stringsburada oldukça yararlı olabilir:b=>$"{(b?1:0):D32}" 19 bytes
— auhmaan
1

MY , 10 9 bayt

𝕫BṄiℑpέ←←

Çevrimiçi deneyin!

Açıklama (kod sayfası [karakterin arkasında akıl yürütme ile birlikte] / onaltılı kod):

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

Bunun iki bağımsız değişken komutları olmadan mümkün olduğuna inanamıyorum!

Düzenleme: 31 almak için aritmetik yerine asal kullanarak 1 bayt kaydedildi.

— Zachary
kaynak
0

APL, 11 bayt

⍕¯32↑1↑1\⍨⊢

Nasıl?

1\⍨⊢ - 1 giriş süresini tekrarlayın - falsy değerinde boş diziye dönün

1↑ - ilk öğeyi al

¯32↑ - 31 sıfırla sağa hizala

⍕ - dize olarak biçimlendir

— Uriel
kaynak
Sadece ⍕¯32↑⊢çalışmalı
— Kritixi Lithos
1
@Cowsquack & Uriel İkisi de boşluk içerdiklerinden çalışmaz. Bir ∊⍕¨¯32↑⎕şeye ihtiyacın var .
— Adám
0

J, 11 bayt

(31#'0'),":

Çevrimiçi deneyin!

Nasıl?

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

not: J'de, booleans 0 veya 1'dir, ayrıca "iverson konvansiyonu" olarak da bilinir, J ve APL'nin yaratıcısı ken iverson'dan sonra

— Jonah
kaynak
1 ve 0'ın J'de boolean olduğunu anlıyorum, ancak girdiyi 31 0'lara ekliyorsunuz. Bir tür boolean validasyonu olmamalı mı?
— Oliver
@Oliver Sorun "Doğruluk / falsey değeri verildi ..." belirtir, bu yüzden hayır, ben doğrulamak gerektiğini sanmıyorum ... Ayrıca, bunun ":çalışması için gerekli olduğunu unutmayın - bir dize boolean değiştirir .
— Jonah
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.