O booleano redundante

19

Introdução

Classicamente, os booleanos são um pouco; trueou false, 1ou 0. Os zeros à esquerda seriam redundantes. Por exemplo, 001significa o mesmo 00001ou apenas 1.

O booleano de 32 bits

Dado um valor truthy / falsey, emita o booleano de 32 bits equivalente como uma string. (Ou como um número, se por algum motivo seu idioma suportar zeros à esquerda.)

Seu programa não precisa funcionar para todos os tipos de verdade / falsidade, apenas para o que sua linguagem de programação funciona melhor.

Exemplo de E / S

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

Isso é código-golfe , então os bytes mais baixos vencem!

code-golf  string 
— Graviton
fonte
6
Precisamos lidar com qualquer valor possível de verdade ou falsey, ou apenas booleanos?
— Xnor
Se meu idioma suportar tipos e tiver booleano, posso usar 1's (int) como verdade?
— LiefdeWen
@LiefdeWen é claro
— Graviton
11
Não é mais duplicado, pois as entradas verdadeiras / falsas podem ser diferentes para cada resposta / idioma.
— Graviton
Eu não vejo por que, mas huh, ok ~
— V. Courtois

Respostas:

9

x86-16 Código da Máquina (DOS), 16 bytes

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

A função acima recebe um valor booleano (0 == falsey, 1 == truthy) no BLregistro (byte baixo de BX) e imprime uma string "booleana redundante" na saída padrão.

Ele funciona chamando uma interrupção (0x21) para fazer uma chamada de função do DOS (selecionada pela configuração AH2) que imprime um único caractere (in DL) na saída padrão.

Primeiro, o caractere ASCII '0' é carregado DL, o contador ( CX) é definido como 31 e faz um loop para imprimir os bytes "redundantes". Em seguida, o valor booleano de entrada é adicionado a DL(se BLfor falsey, adicionar 0 DLpermanecerá inalterado como ASCII '0'; se BLfor verdade, DLserá incrementado em um para ASCII '1') e o byte final será impresso.

A função não retorna um valor.

Bastante decente para uma linguagem que realmente não faz cordas.

Programa completo, 21 bytes

Se você deseja transformá-lo em um programa completo, são necessários apenas mais 5 bytes. Em vez de passar a entrada em um registro, ela lê a entrada dos argumentos transmitidos na linha de comando ao invocar o aplicativo. Um argumento de 0 é interpretado como falsey, assim como a completa falta de argumentos; um argumento maior que 0 é interpretado como verdade.

Simplesmente monte o código a seguir como um programa COM e execute-o na linha de comando.

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

Saída de amostra:

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

Como funciona? Bem, é basicamente a mesma coisa, até você chegar às CMPinstruções. Isso compara o argumento da linha de comando com o valor do DLregistrador (que você se lembra, contém um ASCII '0'). Em um programa COM, os bytes de código são carregados no deslocamento 0x100. O precedente é o prefixo do segmento de programa (PSP) , que contém informações sobre o estado de um programa DOS. Especificamente, no deslocamento 0x82, você encontra o primeiro argumento (na verdade o segundo, já que o primeiro é um espaço) que foi especificado na linha de comando quando o programa foi chamado. Então, estamos apenas comparando esse byte com um ASCII '0'.

A comparação define os sinalizadores e, em seguida, a SALCinstrução (um código de operação não documentado anterior ao Pentium, equivalente a sbb al, al, mas apenas 1 byte em vez de 2) define ALcomo 0 se os dois valores forem iguais ou -1 se forem diferentes. Em seguida, é óbvio que, quando nós subtraímos ALa partir DL, isso resulta em ASCII '0' ou '1', conforme o caso.

(Observe que, ironicamente, você o quebrará se passar um argumento com um 0 à esquerda na linha de comando, pois ele olha apenas para o primeiro caractere. Portanto 01, será tratado como falsey. :-)

— Cody Gray
fonte
7

Javascript, 23 bytes

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

!!a coage a em um booleano, que o plus unário se transforma em um int.

— SuperStormer
fonte
a=>'0'.repeat(31)+(+a)é um byte mais curto.
— Kritixi Lithos
@Cowsquack que falha em cordas, matrizes vazias, NaN, funções, e outros valores onde a coerção em um número não resulta em 0 ou 1
— SuperStormer
também vazio objectos, matrizes, Infinito e indefinido
— SuperStormer
11
... mas agora ...Your program doesn't have to work for every truthy/falsy type, only what your programming language work best for.
— edc65 20/07/19
11
a=>'0'.repeat(31)+~~afunciona com true, false, 1,0
— edc65
6

V , 8 bytes

32é0Àñl

Experimente online!

Explicação:

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
fonte
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

Experimente online!

— TemporalWolf
fonte
2
Bem-vindo ao PPCG!
— Stephen
4

Brainfuck , 61 60 36 bytes

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

Tenho certeza de que existe uma maneira inteligente de não se mexer tanto com os ponteiros.

Eu tinha razão. Havia. Obrigado a @Graviton por me dar a ideia!

Próxima etapa: obtenha os valores 32 e 48 mais rapidamente!

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

Foi divertido para um primeiro golfe!

Chegou tarde demais agora. O que eu estou fazendo?

— Raphaël Côté
fonte
Graças à entropia, reduzi em 1 byte o número 16.
— Raphaël Côté
Apenas por diversão, aqui está uma versão de 60 bytes: >-[-[-<]>>+<]>--<<-[>+<-----]>--->[-<.>],.(aceita entrada como 0 ou 1) Experimente Online!
— Graviton
Bem, muito obrigado @Graviton. Você me fez perceber que eu estava me esforçando demais para reduzir o valor ASCII para 0 enquanto só precisava produzi-lo.
— Raphaël Côté
3

Scala, 32 bytes

Desculpe, mas fui forçado a fazê-lo em 32 bytes> _ <

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

É delimitada por uma função que assume tcomo parâmetro (como um stringque pode ser "0" ou "1" para resp. Falsy ou truthy) es é retornado.

Experimente Online!

Resposta válida: Scala, 46 bytes

Igual à minha resposta java, eu deveria usar um booleano para o parâmetro Então :

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

Experimente Online!

— V. Courtois
fonte
3

Braingolf , 10 8 bytes

#␟>[0_]N

Experimente online!

␟é um separador de unidade, ASCII 0x1Fou 31. Não é possível encontrar o caractere realmente para colar no TIO; portanto, o TIO usa# 1- , o que empurra o espaço (32) e diminui para 31.

Explicação

#␟>[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
fonte
Aqui está o link do tio com o caractere 0x1F nele TIO
— PunPun1000 20/17
@ PunPun1000 Oh, obrigado! Vou atualizar o post
— Skidsdev 20/07
2

Oitava , 23 bytes

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

Experimente online!

Isso é mais curto do que todas as abordagens que tentei printf. Talvez eu tenha perdido alguma coisa, desde que fiz isso no meu telefone.

Apenas um byte a mais

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

Isso poderia ter 18 bytes se eu pudesse usar 1/0 como seqüências de caracteres.

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

Experimente online!

— Stewie Griffin
fonte
2

Java 8, 31 27 bytes

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

-4 bytes graças a @ OlivierGrégoire .

Experimente aqui.

— Kevin Cruijssen
fonte
11
Sim, ainda estou aqui para enganar você:; "".format)
— Olivier Grégoire
11
@ OlivierGrégoire Foi isso! Porra, eu sou estúpido .. xD Quando eu estava digitando String.format, sabia que havia uma maneira mais curta, mas pensei que provavelmente havia usado uma variável String da última vez ... Obrigado. ;)
— Kevin Cruijssen 19/07
2

Ruby, 21 bytes

Sim, esse espaço precisa estar lá ..: /

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

Em Ruby, tudo, exceto falsee nilé verdadeiro; Experimente online!

— daniero
fonte
1

C, 26 bytes

Praticamente a mesma idéia que a solução da 1bluestone , mas em C é mais curta e funciona corretamente para qualquer entrada inteira:

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

Obviamente, isso inclui algumas variáveis ​​/ funções de tipo implícito, como todas as boas respostas C-golf ... O !!operador é a maneira mais curta de converter qualquer valor verdadeiro 1em C (via dupla negação, !é definido para retornar 1ou0 ).

Teste com:

#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 - restabelece monica
fonte
1

Haskell , 37 32 bytes

(('0'<$[1..31])++).show.fromEnum

Experimente online!

Obrigado @nimi pelos -5bytes!

— ბიმო
fonte
2
show(fromEnum x)em vez de last(...). Pointfree ainda mais curto: (('0'<$[1..31])++).show.fromEnum.
— nimi
@nimi Não sabia que Boolé um Enum, obrigado!
— #
1

PHP, 28 bytes

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

Salve como bool.php e execute:

$ php bool.php 0
00000000000000000000000000000000
$ php bool.php 1
00000000000000000000000000000001
— Jared Mellentine
fonte
3 bytes mais curto: printf('%032d',$argv[1]);(requer o -rsinalizador).
— user63956
1

Ly , 20 15 13 bytes

65*1+[0u1-]nu

EDIT: Salvo 5 bytes graças a ovs.
EDIT: Salva outros 2 bytes imprimindo 0 como um número e não como um caractere.

— LyricLy
fonte
Funcionaria 65*1+["0"o1-]nu?
— ovs 19/07/19
1

Oitava, 16 11 bytes

@(x)x(1:32)

Experimente online!

Um identificador de função que leva "00000000000000000000000000000001"como verdade e "00000000000000000000000000000000\0"como falsey.

Explicação:

Na oitava, uma matriz é considerada falsey se pelo menos um de seus elementos for zero. O 33º elemento da segunda string é um caractere com o valor ASCII de 0, para que possa ser considerado como falsey.

— rahnema1
fonte
1

Java, 40 caracteres, 40 bytes

Isso usa string como parâmetro, o que não está correto (o valor java falsy / truthy é forçado pelo OP a ser representado por um booleano).

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

Experimente Online!

Resposta válida: Java, 60 caracteres, 60 bytes

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

Experimente Online!

Eu sei que já existe uma resposta Java que é mais curta que esta, mas ainda :)

— V. Courtois
fonte
Sim, a returndeclaração faz parte do seu código, portanto faz parte da sua contagem de bytes. Mas sua resposta não cumpre as regras: você deve obter um booleancomo entrada. "Verdade / falsidade" é traduzido em Java como um trueou falseoutro nada. Portanto, você não pode obter um Stringparâmetro como entrada.
— Olivier Grégoire
Entendo. Vou modificá-lo em breve. Obrigado.
— V. Courtois
11
Você não precisa colocar o ponto e vírgula final ( ;). Além disso, você pode encurtar o seu código como este: c->{String k="";for(;k.length()<31;)k+=0;return k+=c?1:0;}. O k+=c?1:0é encurtar k+(c?1:0).
— Olivier Grégoire
@ OlivierGrégoire Obrigado, mas por que o ponto-e-vírgula final não é obrigatório?
— V. Courtois
11
É obrigatório, no código, mas não no trecho. No TIO, o rodapé pode simplesmente começar ;. Uma declaração requer um ponto e vírgula. Um lambda não é uma afirmação.
— Olivier Grégoire
1

Japonês , 13 11 bytes

?1:0 ¤i31ç0

Explicação:

?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

Salvou um byte usando uma conversão de base 2 integrada!

Para inserir a sequência de 0s na frente do 1/ 0, preciso converter a sequência 1e 0em uma sequência. A maneira típica de fazer isso seria 1s (3 bytes). Mas, como estamos convertendo apenas 1s e 0s, posso usar a base 2 integrada 1¤(2 bytes).

A entrada pode estar na forma de um número inteiro ou sequência.

0e ""são falsas em Japt.

Experimente online!

Suíte de teste

— Oliver
fonte
1

C # (.NET Core) , 29 bytes

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

O OP disse que 1/0 pode ser usado para truthy / falsey, então pode fazer aum int e torna-se

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

C # realmente não tem truthy / falsey, então não usarei esta resposta.

Experimente online!

— LiefdeWen
fonte
11
Não acho que o segundo seja válido. Inteiros não são verdadeiros nem falsos em C #, apenas bools.
— 21417 Skidsdev
@ Mayube eu perguntei e OP disse que está tudo bem, mas eu meio que concordo com você, então irá editar.
— LiefdeWen
11
Irritantemente Padleftchega na mesma contagem de bytes aqui.
— TheLethalCoder
@TheLethalCoder Começou com PadLeft bem :)
— LiefdeWen
2
Não sei se isso é possível, mas interpolated stringspode ser bastante útil aqui:b=>$"{(b?1:0):D32}" 19 bytes
— auhmaan
1

MY , 10 9 bytes

𝕫BṄiℑpέ←←

Experimente online!

Explicação (página de códigos [com raciocínio por trás do caractere] / código hexadecimal):

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

Não acredito que isso seja possível sem nenhum comando de dois argumentos!

Editar: economizou 1 byte usando números primos em vez de aritmético para obter 31.

— Zacharý
fonte
0

APL, 11 bytes

⍕¯32↑1↑1\⍨⊢

Quão?

1\⍨⊢ - repetir 1 vezes de entrada - retornar matriz vazia com valor falso

1↑ - pegue o primeiro item

¯32↑ - alinhar à direita com 31 zeros

⍕ - formato como string

— Uriel
fonte
Simplesmente ⍕¯32↑⊢deve funcionar
— Kritixi Lithos
11
@Cowsquack & Uriel Nem funciona, pois incluem espaços. Você precisa ∊⍕¨¯32↑⎕ou algo assim.
— Adám 19/07/19
0

J, 11 bytes

(31#'0'),":

Experimente online!

como?

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

nota: em J, os booleanos são 0 ou 1, também conhecido como "a convenção iverson", depois de ken iverson, criador de J e APL

— Jonah
fonte
Entendo que 1 e 0 são booleanos em J, mas você está apenas acrescentando a entrada a 31 0s. Não deveria haver alguma forma de validação booleana?
— Oliver
@ Oliver O problema especifica "Dado um valor de verdade / falsey ...", então não, acho que você não deveria estar validando ... Além disso, observe que isso ":é necessário para que isso funcione - ele altera um booleano para uma string .
— Jonah
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.