Избыточный логический

19

Вступление

Классически, логические значения - один бит; trueили false, 1или 0. Ведущие нули были бы просто лишними. Например, 001означает так же, как 00001или просто 1.

32-битный логический

Учитывая значение truey / falsey, выведите эквивалентный 32-битный логический тип в виде строки. (Или как число, если по какой-то причине ваш язык поддерживает начальные нули.)

Ваша программа не должна работать для каждого типа «истина / ложь», только то, для чего лучше всего работает ваш язык программирования.

Пример ввода / вывода

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

Это код-гольф , поэтому побеждают младшие байты!

code-golf  string 
— Гравитон
источник
6
Нужно ли нам обрабатывать любое возможное значение «истина» или «ложь» или просто логическое значение?
— xnor
Если мой язык поддерживает типы и имеет логическое значение, могу ли я использовать 1 (int) как истинный?
— LiefdeWen
@LiefdeWen конечно
— Гравитон
1
Больше не дублируется, так как ввод правдивых / ложных данных может отличаться для каждого ответа / языка.
— Гравитон
Я не понимаю почему, но да ~
— В. Куртуа

Ответы:

10

Python 3 , 33 25 18 15 байт

Спасибо @ jurjen-bos за __mod__подсказку.

'%.32d'.__mod__

Попробуйте онлайн!

— wrymug
источник
Будет lambda b:'%0.32d'%bработать?
— მოიმო
О, это None правда или ложь ?
— მოიმო
@BruceForte Falsey
— wrymug
1
также 25 байтов, но для python3.6 +: lambda b:f'{bool(b):032}'илиlambda b:f'{not b<1:032}'
— Фелипе Нарди Батиста
1
Вы можете сохранить 1 байт, удалив начальный ноль в 0.32d.
— GarethPW
9

Машинный код x86-16 (DOS), 16 байт

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

Приведенная выше функция получает логическое значение (0 == Falsey, 1 == Truey) в BL регистре ( байт BX) и печатает «лишнюю логическую» строку в стандартный вывод.

Он работает, вызывая прерывание (0x21) для вызова функции DOS (выбирается настройкой AH 2), которая печатает один символ (in DL) на стандартный вывод.

Сначала загружается символ ASCII '0' DL, счетчик ( CX) устанавливается в 31, и он зацикливается для вывода "лишних" байтов. Затем добавляется входное логическое значение DL(если BLfalse, добавление 0 не изменится DLкак ASCII '0'; если BLверно, DLбудет увеличено на единицу до ASCII '1'), и будет напечатан последний байт.

Функция не возвращает значение.

Довольно приличный для языка, который на самом деле не делает строк.

Полная программа, 21 байт

Если вы хотите превратить его в полную программу, потребуется всего 5 байтов. Вместо того, чтобы передавать ввод в регистр, он читает входные данные из аргументов, переданных в командной строке при вызове приложения. Аргумент 0 интерпретируется как фальси, как и полное отсутствие аргументов; аргумент больше 0 интерпретируется как правдивый.

Просто соберите следующий код как программу COM, а затем выполните его в командной строке.

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

Пример вывода:

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

Как это работает? Ну, это в основном то же самое, пока вы не приступите к CMPинструкции. Это сравнивает аргумент командной строки со значением DLрегистра (который, как вы помните, содержит ASCII '0'). В программе COM байты кода загружаются со смещением 0x100. За этим следует префикс сегмента программы (PSP) , который содержит информацию о состоянии программы DOS. В частности, по смещению 0x82 вы найдете первый (фактически второй, поскольку первый является пробелом) аргумент, который был указан в командной строке при запуске программы. Итак, мы просто сравниваем этот байт с ASCII '0'.

Сравнение устанавливает флаги, а затем SALCинструкция (недокументированный код операции до Pentium, эквивалентный sbb al, al, но только 1 байт вместо 2) устанавливает ALзначение 0, если два значения были равны, или -1, если они были разными. Тогда очевидно , что если вычесть ALиз DL, это приводит либо ASCII «0» или «1», в зависимости от обстоятельств.

(Обратите внимание, что, по иронии судьбы, вы сломаете его, если передадите аргумент с начальным 0 в командной строке, так как он смотрит только на первый символ. Поэтому 01будет рассматриваться как фальси. :-)

— Коди Грей
источник
8

Python 3 , 23 байта

lambda n:'0'*31+'01'[n]

Попробуйте онлайн!

— С МакЭвой
источник
8
'10'[not n]было бы достаточно, если бы они нуждались в поддержке.
— Андерс Касеорг
'{:032}'.formatна 15 байт и работают так же, как ваше текущее решение
— Фелипе Нарди Батиста
@rosslh bool(n)было бы достаточно
— Фелипе Нарди Батиста
7

Javascript, 23 байта

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

!!a приводит к логическому значению, которое унарный плюс превращается в int.

— SuperStormer
источник
a=>'0'.repeat(31)+(+a)на один байт короче.
— Kritixi Lithos
@ Cowsquack, который не работает со строками, пустыми массивами, NaN, функциями и другими значениями, где приведение к числу не приводит к 0 или 1
— SuperStormer
также пустые объекты, массивы, бесконечность и неопределенность
— SuperStormer
1
... но сейчас ...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)+~~aработает с true, false, 1,0
— edc65
5

Нейм , 6 5 байт

ᛝΨβ_I

Попробуйте онлайн!

Объяснение:

 ᛝ        # Constant 31
  Ψ       # Apply next token to all in list
    β     # Constant 0
     _    # Push each element to stack
      I   # Take Line of input.

Сохраненный байт благодаря Okx

— LiefdeWen
источник
5 байтов -ᛝΨβ_I
— Okx,
ᛝнет в вики, где ты его нашел?
— LiefdeWen
1
Это находится в списке переменных
— Okx
@Okx Хорошо, спасибо за совет.
— LiefdeWen
4

ArnoldC , 369 байт

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

Попробуйте онлайн!

— TemporalWolf
источник
2
Добро пожаловать в PPCG!
— Стивен
4

Brainfuck , 61 60 36 байт

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

Я уверен, что есть умный способ не перемещаться с указателями.

Я был прав. Существовал. Спасибо @Graviton за предоставленную мне идею!

Следующий шаг: получите значения 32 и 48 быстрее!

Попробуйте онлайн!

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

Было весело для первого Гольфа!

Сейчас стало слишком поздно. Что я вообще делаю

— Рафаэль Кот
источник
Благодаря энтропии я сделал это на 1 байт короче, чтобы добраться до числа 16.
— Raphaël Côté
Просто для удовольствия вот 60-байтовая версия: >-[-[-<]>>+<]>--<<-[>+<-----]>--->[-<.>],.(принимает входные данные как 0 или 1) Попробуйте онлайн!
— Гравитон
Ну, спасибо большое @Graviton. Вы заставили меня понять, что я прикладывал слишком много усилий, чтобы сбросить значение ASCII до 0, в то время как мне просто пришлось его выводить.
— Рафаэль Кот
3

Scala, 32 байта

Извините, но я был вынужден сделать это в 32 байта> _ <

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

Он заключен в функцию, принимающую в tкачестве параметра (как a, stringкоторая может быть «0» или «1» для ложных или правдивых), иs возвращается.

Попробуйте онлайн!

Допустимый ответ: Scala, 46 байт.

Так же, как мой ответ Java, я должен был принять логическое значение для параметра. Так :

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

Попробуйте онлайн!

— В. Куртуа
источник
3

Braingolf , 10 8 байт

#␟>[0_]N

Попробуйте онлайн!

␟является Разделителем модулей, ASCII 0x1Fили 31. Не удается найти фактический символ для вставки в TIO, поэтому вместо него используется TIO# 1- , который увеличивает пробел (32) и уменьшает до 31.

объяснение

#␟>[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
источник
Вот ссылка тио с характером 0x1F в нем Тио
— PunPun1000
@ PunPun1000 О, спасибо! Я буду обновлять пост
— Skidsdev
2

Октава , 23 байта

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

Попробуйте онлайн!

Это короче, чем все подходы, которые я пробовал printf. Я мог что-то пропустить, хотя, так как я сделал это на моем телефоне.

Только один байт дольше

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

Это может быть 18 байт, если я могу взять 1/0 в качестве строк.

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

Попробуйте онлайн!

— Стьюи Гриффин
источник
2

Java 8, 31 27 байт

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

-4 байта благодаря @ OlivierGrégoire .

Попробуй это здесь.

— Кевин Круйссен
источник
1
Да, все еще здесь, чтобы перещеголять тебя;; "".format)
— Оливье Грегуар
1
@ OlivierGrégoire Вот и все! Черт, я глупый .. xD Когда я печатал, String.formatя знал, что есть какой-то более короткий путь, но я подумал, что, вероятно, использовал переменную String в прошлый раз ... Спасибо. ;)
— Кевин Круйссен
1

Древесный уголь , 5 байт

×0³¹Ｓ

Попробуйте онлайн! (Ссылка на подробную версию.)

Как уголь понимает 0и 1как Trueили False, это просто печатает 31 0с и ввод ( 0или 1) в виде строки.

— Чарли
источник
: P Это на самом деле правильно , я думал, что сделал переменные stringify, Trueхотя, странно
— Только для ASCII
1

Python 2 , 26 25 байт

Спасибо Эрику Аутгольферу за сохранение байта!

Идет для полного программного подхода:

print+bool(input(31*'0'))

Попробуйте онлайн!

— Аднан
источник
Заменить ~~с +на -1. После этого полная программа больше не будет дорогой . ;)
— Эрик Outgolfer
@EriktheOutgolfer Я не знал, что это возможно, спасибо!
— Аднан
1

C, 26 байтов

Практически та же идея, что и у решения 1bluestone , но в C он короче и работает правильно для любого целочисленного ввода:

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

Конечно, это включает в себя некоторые неявно типизированные переменные / функции, как это делают все хорошие ответы C-golf ... !!Оператор - самый короткий способ преобразовать любое истинное значение 1в C (через двойное отрицание, !определено, чтобы возвращать либо 1или 0).

Тест с:

#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 - восстановить
источник
1

PHP, 28 байт

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

Сохраните как bool.php и запустите:

$ php bool.php 0
00000000000000000000000000000000
$ php bool.php 1
00000000000000000000000000000001
— Джаред Меллентин
источник
На 3 байта короче: printf('%032d',$argv[1]);(требуется -rфлаг).
— user63956
1

Ли , 20 15 13 байт

65*1+[0u1-]nu

РЕДАКТИРОВАТЬ: Сохранено 5 байтов благодаря ов.
РЕДАКТИРОВАТЬ: сохранить еще 2 байта, напечатав 0 как число, а не символ.

— LyricLy
источник
Будет 65*1+["0"o1-]nuработать?
— ов
1

Октава, 16 11 байт

@(x)x(1:32)

Попробуйте онлайн!

Функциональный дескриптор, который воспринимается "00000000000000000000000000000001"как правдивый и "00000000000000000000000000000000\0"ложный.

Объяснение:

В Octave массив считается ложным, если хотя бы один из его элементов равен нулю. 33-й элемент второй строки - это символ со значением ASCII, равным 0, поэтому его можно считать ложным.

— rahnema1
источник
1

Java, 40 символов, 40 байтов

Это принимает строку как параметр, что является неправильным (ложное / истинное значение java принудительно определяется OP, чтобы быть представленным логическим значением).

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

Попробуйте онлайн!

Допустимый ответ: Java, 60 символов, 60 байтов

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

Попробуйте онлайн!

Я знаю, что уже есть ответ Java, который короче этого, но все же :)

— В. Куртуа
источник
Да, returnоператор является частью вашего кода, поэтому часть вашего подсчета байтов. Но ваш ответ не соответствует правилам: вы должны получить в booleanкачестве входных данных. «Истина / ложь» переводится на Java как «либо», trueлибо « falseничего». Таким образом, вы не можете получить в Stringкачестве входного параметра.
— Оливье Грегуар
Понимаю. Я изменю это достаточно скоро. Благодарю.
— В. Куртуа
1
Вам не нужно ставить последнюю точку с запятой ( ;). Кроме того , вы можете сократить свой код , как это: c->{String k="";for(;k.length()<31;)k+=0;return k+=c?1:0;}. Это k+=c?1:0сократить k+(c?1:0).
— Оливье Грегуар,
@ OlivierGrégoire Спасибо, но почему окончательная точка с запятой не является обязательной?
— В. Куртуа
1
Это обязательно, в коде, но не во фрагменте. В TIO нижний колонтитул можно просто начать с ;. Для утверждения требуется точка с запятой. Лямбда это не утверждение.
— Оливье Грегуар,
1

Japt , 13 11 байт

?1:0 ¤i31ç0

Объяснение:

?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

Сохранение байта с использованием встроенного преобразования base-2!

Чтобы вставить строку из 0 перед 1/ 0, мне нужно привести 1и 0в строку. Типичный способ сделать это 1s (3 байта). Но поскольку мы конвертируем только 1 и 0, я могу использовать встроенный в base-21¤ (2 байта).

Ввод может быть в виде целого числа или строки.

0 и "" ложь в Япте.

Попробуйте онлайн!

Тестирование

— Оливер
источник
1

C # (.NET Core) , 29 байт

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

ОП сказал, что 1/0 может использоваться для правды / фальси, поэтому может сделать aint, и он становится

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

В C # на самом деле нет правды / фальши, поэтому я не буду использовать этот ответ.

Попробуйте онлайн!

— LiefdeWen
источник
1
Я не думаю, что второй действителен. Целые числа не являются ни правдой, ни ложью в C #, только bools.
— Скидсдев
@Mayube Я спросил, и OP сказал, что все в порядке, но я согласен с вами, поэтому отредактирую.
— LiefdeWen
1
Раздражающе Padleftвходит здесь с тем же количеством байтов.
— TheLethalCoder
@TheLethalCoder также начал с PadLeft :)
— LiefdeWen
2
Не уверен, если это возможно, но interpolated stringsможет быть весьма полезным здесь:b=>$"{(b?1:0):D32}" 19 bytes
— auhmaan
1

МОЙ , 10 9 байт

𝕫BṄiℑpέ←←

Попробуйте онлайн!

Пояснение (кодовая страница [с указанием символа) / шестнадцатеричный код):

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

Я не могу поверить, что это возможно без каких-либо команд с двумя аргументами вообще!

Редактировать: 1 байт, используя простые числа вместо арифметики, чтобы получить 31.

— Zachary
источник
0

APL, 11 байт

⍕¯32↑1↑1\⍨⊢

Как?

1\⍨⊢ - повторить 1 раз - вернуть пустой массив на ложное значение

1↑ - возьми первый предмет

¯32↑ - выровнять справа по 31 нулю

⍕ - отформатировать как строку

— Уриэль
источник
Просто ⍕¯32↑⊢должно работать
— Kritixi Lithos
1
@ Cowsquack & Uriel Ни то, ни другое не работает, поскольку они содержат пробелы. Вам нужно ∊⍕¨¯32↑⎕или что-то.
— Адам
0

J 11 байт

(31#'0'),":

Попробуйте онлайн!

как?

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

примечание: в J булевы значения 0 или 1, также известные как «соглашение о айверсоне», после Кена Айверсона, создателя J и APL

— Ион
источник
Я понимаю, что 1 и 0 являются логическими значениями в J, но вы просто добавляете ввод к 31 0. Разве не должно быть какой-либо формы логической проверки?
— Оливер
@Oliver В задаче указывается «Дано значение truey / falsey ...», так что нет, я не думаю, что вы должны проверять ... Кроме того, обратите внимание, что ":это необходимо для работы - оно заменяет логическое значение на строку ,
— Иона
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.