Фон :

Вам было дано задание преобразовать числа 10 из базы в базу 2 без использования каких-либо готовых функций преобразования базы. Вы также не можете использовать любые импортированные библиотеки.

Проблема :

Преобразуйте входную строку из базы 10 (десятичная) в базу 2 (двоичная). Вы не можете использовать какой-либо готовый базовый код преобразования / функции / методы или импортированные библиотеки. Поскольку это код-гольф , победит самый короткий ответ в байтах.

Входные данные будут от -32768 до 32767 (включая обработку байтов знака в вашем коде)

GolfScript - 17 байт

~{.1&\2/}16*;]-1%

Не слишком многословный, чем встроенный ~2base.

JavaScript, 46

for(x=prompt(o='');x;x>>>=1)o=(x&1)+o;alert(o)

Brainf * ck, 98 77

Очевидно, что это не для того, чтобы выиграть, но что было бы для конкуренции, если бы у нее не было мозгового решения

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

Так как brainfk может работать только с 8-битными целыми числами и без негативов, я думаю, что он не полностью соответствует правилам, но эй, я никогда не был в нем, чтобы выиграть его.

Это действительно работает для 16-битного ввода, если ваш интерпретатор поддерживает

Я даже получил его для вывода в значениях ASCII

Вот аннотированный код:

++[>++++<-]                       preload 8 onto cell 1
>>,<                                input into cell 2
[-                                  iterate over cell 1
    >>++<                               put 2 in cell 3
    [->-[>+>>]>[+[-<+>]>+>>]<<<<<]      division algorithm: converts {n d} into {0 d_minus_n%d n%d n/d}
    >[-]++++++[->++++++++<]>           clears cell 4 and puts 48(ascii of 0) into cell 5
    .[-]                                output n%2 and clear it (the bit)
    >[-<<<+>>>]                         bring n/2 into cell 2 (to be used for division in next iteration)
<<<<]                               end iterate

Более короткий алгоритм (77):

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

Этот может обрабатывать только 8-битные целые числа.

Алгоритм работает с использованием двоичного счетчика, который на самом деле очень короткий (один шаг, >[->]++[-<+]-<-который затем раскладывает биты. Проблема в том, что сложно распечатать все биты

Этот последний алгоритм может быть адаптирован к любому количеству битов за счет байтов. Чтобы иметь возможность иметь дело с N битными целыми числами, требуется 53 + 3 * N байтов для кодирования.

Примеры:

(1 bit) +>,>-<[>>[->]++[-<+]-<-]++++++++[->++++++<]>+[->+<]>[.>]
(2 bit) +>,>-<[>>[->]++[-<+]-<-]++++++++[->++++++<]>+[->+>+<<]>[.>]
(3 bit) +>,>-<[>>[->]++[-<+]-<-]++++++++[->++++++<]>+[->+>+>+<<<]>[.>]
etc

Обязательный ответ APL - 21 22

"01"[1+2|⌊⎕÷2⋆⊖0,⍳15]

Примеры:

      "01"[1+2|⌊⎕÷2⋆⊖0,⍳15]
⎕: 0
0000000000000000
      "01"[1+2|⌊⎕÷2⋆⊖0,⍳15]
⎕: 13
0000000000001101
      "01"[1+2|⌊⎕÷2⋆⊖0,⍳15]
⎕: 9999
0010011100001111
      "01"[1+2|⌊⎕÷2⋆⊖0,⍳15]
⎕: -3
1111111111111101
      "01"[1+2|⌊⎕÷2⋆⊖0,⍳15]
⎕: 32767
0111111111111111

Машинный код Тьюринга, 272 байта

Как обычно, я использую синтаксис таблицы правил, определенный здесь. Вы можете протестировать его на этом сайте или, альтернативно, использовать эту реализацию Java.

Большая часть кода скопирована из моего десятичного в шестнадцатеричный конвертер здесь.

0 * * l B
B * * l C
C * 0 r D
D * * r E
E * * r A
A _ * l 1
A * * r *
1 0 9 l 1
1 1 0 l 2
1 2 1 l 2
1 3 2 l 2
1 4 3 l 2
1 5 4 l 2
1 6 5 l 2
1 7 6 l 2
1 8 7 l 2
1 9 8 l 2
1 _ * r Y
Y * * * X
X * _ r X
X _ _ * halt
2 * * l 2
2 _ _ l 3
3 * 1 r 4
3 1 0 l 3
4 * * r 4
4 _ _ r A

Обратный отсчет от входа в базе 10 при увеличении от 0 в базе 2. При уменьшении нуля он стирает блок ввода и завершается.

Javascript 59

o='';i=parseInt(prompt());do{o=(i&1)+o}while(i>>=1)alert(o)

Perl, 44

Это моя первая программа на Perl, так что, пожалуйста, прости меня, если это можно легко продолжить. Редактировать: Спасибо @primo за то, что убрали 7 символов из моего ответа.

$x=<>;do{@s=($x&1,@s)}while($x>>=1);print@s

$x=<>;do{push@s,$x&1}while($x>>=1);print reverse@s

Логика по сути та же, что и в моем предыдущем C-решении.

Также использует 64 бита.

Javascript - 56 48 и 36 28 символов

• Не работает с отрицательными числами.

Спасибо @Blender за бритье 8 символов.

Эта форма принимает ввод и показывает вывод, 48 символов:

x=prompt();for(a="";x;x=~~(x/2))a=x%2+a;alert(a)

Если нужна просто инструкция, которая вставляет переменную aв двоичную форму переменной x(и вы не потрудитесь уничтожить xзначение как побочный эффект), то здесь это с 28 символами:

for(a="";x;x=~~(x/2))a=x%2+a

Python - 61 60 символов

x=input();print"".join("01"[x>>i&1]for i in range(15,-1,-1))

С, 55 символов

Печатает дополнительный ведущий ноль (ради 2 байтов).
Рекурсия внутриprintf реверсируется порядок печати, поэтому алгоритм извлекает биты справа налево, но печатает слева направо.

РЕДАКТИРОВАТЬ : сохранить символ с помощью putcharвместо printf.

f(x){(x*=x<0?-printf("-"):1)&&f(x/2);putchar(48+x%2);}

Дьялог АПЛ , 11 байт

2|⌊⎕÷2*⌽⍳16

2|Остаток от деления на половину
⌊округленного значения
⎕на входе,
÷деленного на каждое из
2*двух до степени каждого из
⍳16{0, 1, 2, ..., 15}

Требуется ⎕IO←0по умолчанию во многих системах.

Попробуй APL онлайн!

С, 81

char b[17];i=15;main(x){scanf("%d",&x);while(i+1)b[i--]=(x&1)+48,x>>=1;puts(b);}

Вывод имеет строго 16 бит (включая нули заполнения)

Apps Script + Google Sheets, 147 144 121 байт

скрипт

function j(decNumb){var str='';do{str=String(decNumb%2)+str;decNumb=decNumb/2|0;}while(decNumb>=1);return parseInt(str);}

Простыня

=j(b1)

Модифицированная версия этого скрипта от ZygD.

Haskell, 66 байт

c 0=0
c n=c(div n 2)*10+mod n 2
b('-':r)='-':b r
b r=show.c.read$r

Позвоните b "-1023", добавьте main=interact bполную программу или попробуйте ее на Ideon.

cвыполняет преобразование для натуральных чисел.
b r=show.c.read$rпреобразует строку в число, применяет cи преобразует обратно в строку.
b('-':r)='-':b rлишает возможного лидерства -и повторно добавляет его к результату.

PowerShell, 59 87 82 70 bytes

+28 bytes for supporting negative numbers.
-12 bytes thanks to @ASCII-only

param($d)$m=$d-lt0;while($d){$n="01"[$d%2]+$n;$d=($d-$d%2)/2}'-'*$m+$n

Try it online!

Adapted from this code. Takes input through a commandline parameter -d.

APL (NARS), 17 символов, 34 байта

{2∣⌊⍵÷2*(⍺-1)..0}

Это копия и модификация ответа Адама /codegolf//a/90107 так, как можно добавить параметр для длины битов, и ⎕IO для этой функции (здесь ⎕IO = 1) должен не имеет значения ...

  f←{2∣⌊⍵÷2*(⍺-1)..0}
  16 f 2
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 
  32 f 2
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 
  32 f ¯1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 
  16 f ¯1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 
  64 f ¯12345678
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 

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

Smalltalk (Smalltalk / X), 63/78

первая версия создает промежуточную строку (78):

t:=Number readFrom:Stdin.
((15to:1by:-1)collect:[:i|$0+(t>>i&1)]as:String)print

на самом деле, нет необходимости создавать строку; просто выведите символы (63):

t:=Number readFrom:Stdin.
15to:1by:-1 do:[:i|($0+(t>>i&1))print]

ммм - есть ли более короткий способ чтения числа?

Python 3.x: 65 characters

b=lambda n:n<2 and'01'[n]or b(n//2)+b(n%2);print(b(int(input())))

Bash, 44

f=b+=n/2**e%2*10**e,2**e++/n?f=b:f;echo $[f]

Pass an input value to the script through the environment variable n. The decimal representation of the binary result cannot exceed LONG_MAX.

This should also be compatible with ksh93 and zsh if b and e are initialized to 0 and proper arithmetic expansion is used.

C# - 104

string p(int d){var r="";long i=1;while(r.Length<=64){var g=d&i;r=(g!=0)? "1"+r:"0"+r;i=i<<1;}return r;}

This method will convert decimal to binary up to 64 bits.

When executed the above method in Linqpad - rr = p(-32768); rr.Dump();

Output: 01111111111111111111111111111111111111111111111111000000000000000

Java 8, 80 71 bytes

n->{String r="";for(int i=n<0?-n:n;i>0;i/=2)r=i%2+r;return n==0?"0":r;}

-9 bytes due to a rule in the comments.. Negative base-10 inputs may return the positive/absolute base-2 value as output apparently.

Explanation:

Try it online.

n->{                   // Method with integer parameter and String return-type
  String r="";         //  Result-String, starting empty
  for(int i=n<0?-n:n;  //  Start `i` at the absolute (non-negative) value of the input
      i>0;             //  Loop as long as `i` is not 0
      i/=2)            //    After every iteration: integer-divide `i` by 2
    r=i%2+r;           //   Prepend the result with `i` modulo-2
  return n==0?         //  If the input is 0:
          "0"          //   Return literal "0"
         :             //  Else:
          r;           //   Return the result-String

Kotlin, 82 bytes

{s:String->{var i=s.toInt()
var r=""
(0..15).map{r="${i and 1}$r"
i=i shr 1}
r}()}

Try it online!

Small Basic, 133 bytes

A script that inputs from and outputs to the TextWindow console.

n=TextWindow.Read()
While n>0
c=c+1
x[c]=Math.Remainder(n,2)
n=Math.Floor(n/2)
EndWhile
For i=0To c-1
TextWindow.Write(x[c-i])
EndFor

Try it at SmallBasic.com Requires Silverlight and thus must be run in IE.

I/O is taken/given from the black console.

-22 bytes thanks to @Neil

MATL, 15 17 bytes

t0<?16Ww+]`2&\t]x

Try it on MATL Online

TIO

(+2 bytes removing leading 0 for negative numbers, sign bit should be the first bit.)

Output on MATL Online should be read bottom-up (MSB is at the bottom).

The main part is pretty simple: `2&\t = while the value is greater than 0, divide by 2 and accumulate the remainders.

Handling negative numbers and giving them 2's complement representation was the tricky part. In the end I went with the "subtract from $2^N$" method of getting a number's two's complement. Since we're only required to handle values upto -32768, for negative numbers the code creates $2^{16} = 65536$ with 16W, adds the input to that (eg. 65536 + (-42)), which gives something MATLAB sees as a positive number but represents the input's signed binary representation in 16-bit form.

C (gcc), 50 43 bytes

-7 bytes thanks to ceilingcat.

f(n){printf("-%d"+(~n?n&&f(n/2),1:0),n&1);}

Try it online!

PowerShell, 43 bytes

param($n)15..0|%{$r+='01'[($n-shr$_)%2]}
$r

Try it online!

><>,  34  33 bytes

|!/?=0:,2-}:%2:+***"  @"(0:
n{\~{

Try it online!