2進数から10進数へのコンバーター

私の知る限り、単純な2進数から10進数への変換の課題はありません。

正の2進整数を取り、その10進値を出力するプログラムまたは関数を作成します。

組み込みの基本変換関数を使用することはできません。整数対小数機能（例えば、ターンその関数101010に[1, 0, 1, 0, 1, 0]又は"101010"）この規則から除外され、したがって、可能にしました。

ルール：

• コードは、言語がサポートする最大の数値までの2進数をサポートする必要があります（デフォルト）
• バイナリ表現で先行ゼロを選択することもできます
• 10進出力には先行ゼロがない場合があります。
• 入力形式と出力形式はオプションですが、数字の間に区切り文字を含めることはできません。(1,0,1,0,1,0,1,0)有効な入力形式ではなく、両方10101010と(["10101010"])しています。
  • 「通常の」方向で入力を取得する必要があります。1110ではあり14ません7。

テストケース：

1
1

10
2

101010
42

1101111111010101100101110111001110001000110100110011100000111
2016120520371234567

この課題は、他のいくつかの課題、たとえばthis、this、thisに関連しています。

ゼリー、5バイト

DḤ+¥/

オンラインでお試しください！

説明

キャスト

• Dモナド（単一引数関数）は次のとおりです。数字、ターニング1234へ[1, 2, 3, 4]。

• Ḥ 単一の引数を2倍にするモナドです。

• + は、左右の引数を追加するダイアド（2つの引数関数）です。

そこから、少しトリッキーになります。

解析時に起こることは次のとおりです

• D、Ḥと+読んでいます。チェーンは次のようになり[D, Ḥ, +]ます。

• 次の2文字はquicksです。これは、これまでに読んだリンク（関数）で解析時の接尾辞演算子のように動作します。

• ときに¥読み込まれ、最後の2つのリンクがポップし、それらを合成することによって形成ダイアドのような役割を果たしリンクに置き換えられます。したがって、チェーンは次のようになり[D, dyad(Ḥ+)]ます。

• ときに/読み込まれ、最後のリンクは（これはダイアドであるべき）ポップとモナドによって置き換えられます襞このダイアドを使用して（直感的に：f/リストを取り、でそれにカンマを置き換えf、その結果を評価します。）

• 最終的なチェーンは[D, fold(dyad(Ḥ+))]、2つのモナドのように見えます。

実行時に何が起こるか

• 入力（数値）は暗黙的に作業値（たとえば、101010）に読み込まれます。

• D作業値をその数字（[1,0,1,0,1,0]）に置き換えて実行されます。

• fold(dyad(Ḥ+))が実行され、作業値がに置き換えられます。1∗0∗1∗0∗1∗0ここ∗ではdyad Ḥ+です。

では、何にx∗y評価されますか？

• 二項定義では、作業値は最初は左引数ですx。

• Ḥ、二重モナド、この値を2倍にします。現在の作業値は2xです。

• +、プラスダイアドには正しい引数がないため、これはフックです+。このダイアドの正しい引数がに挿入される特別な構文パターンです。これが2x + y最終的な作業値として返され、返されます。

したがって、式全体は次のように評価されます。

1∗0∗1∗0∗1∗0 = 2×(2×(2×(2×(2×1+0)+1)+0)+1)+0
            = 32×1 + 16×0 + 8×1 + 4×0 + 2×1 + 1×0
            = 42

パイソン2、49 37 31の 30バイト

Pythonは任意の大きな整数を処理できるため、これは10進表現の2進数を取ります。

b=lambda n:n and n%2+2*b(n/10)

^{バイトを保存してくれたxnorに感謝します:)}

これがどのように機能するかを確認する最も簡単な方法は、2進数を10進数に変換するための基本的な式を見ることです。

= 101010 
= 1*(2^5) + 0*(2^4) + 1*(2^3) + 0*(2^2) + 1*(2^1) + 0*(2^0)
= 1*32 + 0*16 + 1*8 + 0*4 + 1*2 + 0*1
= 42

これは「標準」の変換方法です。次のように3行目を展開できます。

= ((((1*2 + 0)*2 + 1)*2 + 0)*2 + 1)*2 + 0

そして、これは基本的に、私が作成した再帰的な方法で行っていることです。

私が持っていた代替ソリューション：

b=lambda n:n and n%10+2*b(n/10)
b=lambda n:n%10+2*(n and b(n/10))
b=lambda n:0if n<1else n%10+2*b(n/10)
b=lambda n:0**(n/10)or n%10+2*b(n/10)
b=lambda n,o=0:o*(n<'0')or b(n[1:],2*o+int(n[0]))
lambda j:sum(int(b)*2**a for a,b in enumerate(j,1))

05AB1E、6バイト

コード：

$¦v·y+

外植については、例101010を見てみましょう。数字の1から始めます（最初の数字で表されます）。その後、2つのケースがあります。

• 数字が0の場合数値に2を掛けます。
• 数字が1の場合、数値に2を掛けて1を加算します。

したがって、101010の場合、以下が計算されます。

• 1 01010、数字で始まる 1ます。
• 1 0 1010、2で乗算し、結果として 2。
• 10 1 010、2を掛けて1を加算し、結果として 5になります。
• 101 0 10、2を掛けて、結果として 10になります。
• 1010 1 0、2を掛けて1を加算し、結果として 21になります。
• 10101 0に2を掛けると、42になります。これは望ましい結果です。

コードの説明：

$         # Push 1 and input
 ¦        # Remove the first character
  v       # For each character (starting with the first)
   ·      #   Multiply the carry number by two
    y+    #   Add the current character (converted automatically to a number)

CP-1252エンコードを使用します。オンラインでお試しください！

Haskell、16 111 + 57 = 168バイト

import Data.String
instance IsString[Int]where fromString=map((-48+).fromEnum)
f::[Int]->Int
f=foldl1((+).(2*))

+57バイトのコンパイルフラグ-XOverloadedStrings、-XOverlappingInstancesおよび-XFlexibleInstances。

このチャレンジには、ソースコードでのデータ型の表現方法に大きく依存するため、面倒なIOフォーマットがあります。私の最初のバージョン（16バイト）、すなわち

foldl1((+).(2*))

は整数のリストを取ります。たとえば[1,0,1,0,1,0]、リテラルHaskellリスト,が要素間にあるために無効と宣言されました。リスト自体は禁止されていません。私の新しいバージョンでは、今という名前の非常に同じ関数を使用していますが、f「引用文字列を引用符で囲む」をオーバーロードしています。関数は、型注釈[Int] -> Intで見ることができるように整数のリストを取りますが、1桁の整数を持つリストは"1234"、たとえば

f "101010"

これはに評価され42ます。残念なのは、ネイティブリスト形式がチャレンジルールに適合しないためです。ところで、f [1,0,1,0,1,0]まだ動作します。

網膜、15バイト

バイナリから単項に変換し、次に単項から10進数に変換します。

1
01
+`10
011
1

オンラインで試す

PHP、44バイト

for(;""<$c=$argv[1][$i++];)$n+=$n+$c;echo$n;

以前にその質問を見たことがあると誓ったかもしれません。しかしよく。

数値を左から右に読み取り、左にシフトして現在のビットを追加します。

JavaScript（ES6）、33 31バイト

s=>[...s].map(c=>r+=+c+r,r=0)|r

編集：短くても甘くない：@ETHproductionsのおかげで2バイト節約されました。

ラビリンス、17 15バイト

-+:
8 +
4_,`)/!

オンラインでお試しください！

Labyrinthは、2次元のスタックベースの言語です。ラビリンスでは、コード実行は、壁として機能し、左上にあるスペース以外の文字から始まる迷路のようなコードのパスに従います。コードフローは、スタックの最上部の符号によって決まります。スタックの下部に暗黙的なゼロがあるため、最初の4つの命令（-+:+）は効果がありません。

で始まるループ ,

• , 次の入力文字のASCIIコード値をスタックのストップにプッシュするか、EOFの場合は-1をプッシュします。
• _48 48をスタックの一番上にプッシュします
• - ポップy、ポップx、プッシュ x-y。前の命令は、入力から48を減算して、「0」の場合は0、「1」の場合は1を生成します。
• + ポップy、ポップx、プッシュ x+y。
• : スタックの一番上を複製する
• + この命令と前の命令には、現在の値に2を掛ける効果があります

したがって、コードの円形部分は、実際には現在の数値に2を掛け、文字1または0が入力されたかどうかに応じて1または0を追加します。

尾

スタックのトップが負の場合（EOFが見つかったことを意味する）、コードはジャンクションで左に曲がります（セミコロンに向かって）。

• `` `1を得るためにスタックのトップを否定します
• ) スタックの最上部をインクリメントして2を取得します
• /ポップy、ポップx、プッシュx / y（整数除算）。これには、最後の*2ループのあります。
• !スタックの最上部の整数表現を出力します。この時点で、プログラムは行き止まりになったために向きを変え、ゼロで​​除算しようとするためエラーで終了します。

@Martin Enderに2バイトの節約をしてくれてありがとう（そして迷宮でもっとよく考える方法を教えてくれた）。

脳高射砲、46、28のバイト

([]){{}({}<>({}){})<>([])}<>

オンラインでお試しください！

@Rileyのおかげで多くのバイトが節約されました

brain-flakはバイナリ入力を取得できないため、入力は「0」と「1」のリストです。

説明：

#Push the height of the stack
([])

#While true:
{

 #Pop the height of the stack
 {}

 #Push this top number to (the other stack * 2)
 ({}<>({}){})

 #Toggle back on to the main stack
 <>

 #Push the new height of the stack
 ([])

#endwhile
}

#Toggle back to the other stack, implicitly display.
<>

Java、84 79 46 48バイト

• バージョン3.1

long/ 48バイトに変更：

s->{long x=0;for(char c:s)x=c-48l+x*2;return x;}

• バージョン3.0

ゴルフをしましたか/ 46バイト：

s->{int x=0;for(char c:s)x=c-48+x*2;return x;}

• バージョン2.0

@Geobits！/ 79バイトのおかげで：

s->{int i=Math.pow(2,s.length-1),j=0;for(char c:s){j+=c>48?i:0;i/=2;}return j;}

• バージョン1.0

84バイト：

s->{for(int i=-1,j=0;++i<s.length;)if(s[i]>48)j+=Math.pow(2,s.length-i+1);return j;}

Befunge-98、12バイト

2j@.~2%\2*+

オンラインでお試しください！

入力から一度に1つの文字を読み取り、2を法とする値（0はchar（48）、1はchar（49））を使用して0または1に変換し、現在の値を2倍して加算する通常のアルゴリズムを使用します毎回新しい数字。

ボーナス： これは、あらゆる種類の入力文字列で機能します。しばらくの間、面白い入力->出力の組み合わせを見つけようとしましたが、何も生成できませんでした（悲しいことに、 "answer" = 46）。あなたはできる？

Javascript（ES7）41 40 36バイト

f=([c,...b])=>c?c*2**b.length+f(b):0

入力として文字列を受け取ります

ETHproductionsのおかげで1バイト削りました

f=([c,...b])=>c?c*2**b.length+f(b):0
document.write([
    f('101010'),
    f('11010'),
    f('10111111110'),
    f('1011110010110'),
].join("<br>"))

C＃6、85 37 36バイト

long b(long n)=>n>0?n%2+2*b(n/10):0;

• 41バイトを節約してくれたKadeに感謝します！
• C＃6に変更すると、さらに7バイト節約されました。

05AB1E、7バイト

RvNoy*O

オンラインでお試しください！

説明

R         # reverse input
 v     O  # sum of
  No      # 2^index
     *    # times
    y     # digit

C、53

v(char*s){int v=0,c;while(c=*s++)v+=v+c-48;return v;}

私のjavascriptの答えと同じ

テストIdeone

Perl、25バイト

@Dom Hastingsのおかげで-3バイト。

24バイトのコード+ -pフラグ用の1バイト。

$\|=$&<<$v++while s/.$//

実行するには：

perl -pe '$\|=$&<<$v++while s/.$//' <<< 101010

説明：

$\|=$&<<$v++  # Note that: we use $\ to store the result
              # at first $v=0, and each time it's incremented by one
              # $& contains the current bit (matched with the regex, see bellow)
              # So this operation sets a $v-th bit of $\ to the value of the $v-th bit of the input
while         # keep doing this while...
s/.$//        #  ... there is a character at the end of the string, which we remove.
         # $\ is implicitly printed thanks to -p flag

Pushy、10バイト

コマンドラインで入力を0/1のリストとして受け取ります：$ pushy binary.pshy 1,0,1,0,1,0。

L:vK2*;OS#

このアルゴリズムは、2番目のスタックを持つことの美しさを実際に示しています。

            \ Implicit: Input on stack
L:    ;     \ len(input) times do:
  v         \   Push last number to auxiliary stack
   K2*      \   Double all items
       OS#  \ Output sum of auxiliary stack

このメソッドは、スタックがstack length - nnumberに達する前に倍になりn、後で2番目のスタックにダンプされるため機能します。入力のプロセスは次のようになります101010。

1：[1,0,1,0,1,0]
2：[]

1：[2,0,2,0,2]
2：[0]

1：[4,0,4,0]
2：[2]

1：[8,0,8]
2：[2,0]

1：[16,0]
2：[2,0,8]

1：[32]
2：[2,0,8,0]

1：[]
2：[2,0,8,0,32]

2 + 8 + 32-> 42

Matlab、30バイト

@(x)sum(2.^find(flip(x)-48)/2)

最後のテストケースには丸めエラーがあります（ためdouble）ので、完全な精度が必要な場合：

@(x)sum(2.^uint64(find(flip(x)-48))/2,'native')

47バイト。

網膜、12バイト

バイトカウントはISO 8859-1エンコードを前提としています。

+%`\B
¶$`:
1

オンラインでお試しください！

代替ソリューション：

+1`\B
:$`:
1

説明

これはおそらく、ゴルフの少ない古いバージョンに基づいて説明し、それを短縮した方法を示すのがおそらく簡単です。次のようにバイナリを10進数に変換していました。

^
,
+`,(.)
$`$1,
1

Retinaで10進数を構築する唯一の賢明な方法は、物事を数えることです（Retinaには、金額を表す10進数を出力できる機能がいくつかあるため）。したがって、実際に唯一可能なアプローチは、バイナリを単項に変換し、単項の桁数をカウントすることです。最後の行はカウントを行うため、最初の4行はバイナリを単項に変換します。

どうすればいいですか？一般に、ビットのリストから整数に変換するには、結果を次のように初期化します。0からビットを最上位から最下位まで調べ、既存の値を2倍にして現在のビットを追加します。たとえば、2進数がの場合、1011実際に計算します：

(((0 * 2 + 1) * 2 + 0) * 2 + 1) * 2 + 1 = 11
           ^        ^        ^        ^

明確にするために個々のビットにマークを付けました。

単項でこれを行うためのトリックは、a）倍にすることは単に数を繰り返すことを意味し、b）カウントしているので 1最後にsをているため、プロセスで0sと1s を区別する必要さえありません。これはすぐに明らかになります。

プログラムが行うことは、最初にカンマをマーカーとして最初に追加し、すでに処理した入力の量を示すことです。

^
,

マーカーの左側には、累積する値（ゼロの単項表現に正しく初期化されます）があり、値の右側は処理する次のビットになります。次に、ループ内で次の置換を適用します。

,(.)
$`$1,

とを見るだけで,(.)、$1,毎回マーカーが1ビット右に移動します。ただし$`、マーカーの前にあるすべて、つまり現在の値を挿入して、2倍にします。inputを処理する際の個々のステップを以下に示します。各行の上1011に挿入した結果をマークしました$`（最初のステップでは空です）。

,1011

1,011
 _
110,11
   ___
1101101,1
       _______
110110111011011,

ゼロを保持し、他のすべてと一緒にゼロを2倍にしたことがわかりますが、最後にそれらを無視しているので、1s の数が2正しい。あなたがそれらを数えるなら11、私たちが必要なものだけがあります。

そのため、これをゴルフする方法の問題は12バイトまで残されます。18バイトバージョンの最も高価な部分は、マーカーを使用する必要があることです。目標はそれを取り除くことです。すべてのビットのプレフィックスを2倍にしたいので、最初のアイデアは次のようになります。

.
$`$&

問題は、これらの置換が同時に発生するため、最初のビットがビットごとに2倍になるのではなく、毎回1回だけコピーされることです。入力1011については、挿入されたマークを付け$`ます：

 _ __ ___
1101011011

入力を再帰的に処理して、2番目のプレフィックスが2番目のプレフィックスで再び2倍になるようにする必要があります。1つのアイデアは、どこにでもマーカーを挿入し、プレフィックスを繰り返し置換することです。

\B
,
+%`,
¶$`

各マーカーを最初にプレフィックスで置き換えた後、入力の開始位置を覚えておく必要があります。そのため、ラインフィードも挿入し、%オプションを使用して、次の$`ものが最も近いラインフィードのみを拾うようにします。

これは機能しますが、それでも長すぎます（1最後にsをカウントするときは16バイト）。物事を好転させるのはどうですか？マーカーを挿入する場所は\B（2桁の間の位置）で識別されます。なぜそれらの位置にプレフィックスを挿入しないのですか？これはほとんど機能しますが、違いは、以前のソリューションでは、各置換で実際に1つのマーカーを削除したことです。これは、プロセスを終了させるために重要です。ただし、\B文字ではなく位置だけなので、何も削除されません。私たちはすることができますしかし、停止します\B代わりに、この場所に数字以外の文字を挿入することにより、マッチングから。これにより、非単語境界が単語境界に変わります。これは、マーカー文字を以前に削除するのと同じです。そして、それが12バイトのソリューションの機能です。

+%`\B
¶$`:

完全を期すために、ここに処理の個々のステップを示します1011。各ステップの後に空の行があります。

1
1:0
10:1
101:1

1
1:0
1
1:0:1
1
1:0
10:1:1

1
1:0
1
1:0:1
1
1:0
1
1:0:1:1

繰り返しますが、最後の結果には正確に11が含まれていることがわかります1。

読者のための演習として、これが他のベースに非常に簡単に一般化する方法を見ることができます（ベースの増分ごとに数バイト追加します）。

T-SQL、202バイト

DECLARE @b varchar(max)='1',@ int=1 declare @l int=LEN(@b)declare @o bigint=CAST(SUBSTRING(@b,@l,1)AS bigint)WHILE @<@l BEGIN SET @o=@o+POWER(CAST(SUBSTRING(@b,@l-@,1)*2AS bigint),@)SET @=@+1 END PRINT @o

PHP、64バイト

foreach(str_split(strrev($argv[1]))as$k=>$v)$t+=$v*2**$k;echo$t;

2進数を反転し、そのコンポーネントの数字に分割し、位置に基づいて合計します。

Bash + GNUユーティリティ、29バイト

sed 's/./2*&+/g;s/.*/K&p/'|dc

stdin / stdoutを介したI / O。

このsed式は、バイナリを各桁に分割し、dc評価するRPN式を作成します。

PowerShell v2 +、55バイト

param($n)$j=1;$n[$n.length..0]|%{$i+=+"$_"*$j;$j*=2};$i

長く感じます...それを下にゴルフすることはできません-ヒントを高く評価しています。

説明

param($n)$j=1;$n[$n.length..0]|%{$i+=+"$_"*$j;$j*=2};$i
param($n)$j=1;                                          # Take input $n as string, set $j=1
              $n[$n.length..0]                          # Reverses, also converts to char-array
                              |%{                  };   # Loop over that array
                                 $i+=+"$_"*$j;          # Increment by current value of $j times current digit
                                              $j*=2     # Increase $j for next loop iteration
                                                     $i # Leave $i on pipeline
                                                        # Implicit output

JavaScript（ES6）、32バイト

f=([...n])=>n+n&&+n.pop()+2*f(n)

再帰は一日を再び救います！パラメーター化は少し長いようですが...

Mathematica、27 13 11バイト

Fold[#+##&]

受け付けるList入力としてビット（例えば{1, 0, 1, 1, 0}- のMathematicaの数のバイナリ表現22）

Clojureは、114の 105 63 41バイト

V4：41バイト

@cliffrootのおかげで-22バイト。digitはであるため、を介してコードに変換しint、48を減算して実際の数を取得できます。マップも考慮されました。なぜ必要なように思えたのかわかりません。

#(reduce(fn[a d](+(* a 2)(-(int d)48)))%)

V3：63バイト

(fn[s](reduce #(+(* %1 2)%2)(map #(Integer/parseInt(str %))s)))

-42バイト（！）他の回答を覗く。私の「ジッピング」は明らかに非常にナイーブでした。2を現在の場所の累乗にし、現在の桁で乗算して結果をアキュムレーターに加算する代わりに、アキュムレーターに2を乗算するだけで、現在の桁に加算してからアキュムレーターに加算します。また、リデュース関数をマクロに変換して、少し削ります。

@nimiと@Adnanに感謝します！

ゴルフをしていない：

(defn to-dec [binary-str]
  (reduce (fn [acc digit]
            (+ (* acc 2) digit))
          (map #(Integer/parseInt (str %)) binary-str)))

V2：105バイト

#(reduce(fn[a[p d]](+ a(*(Integer/parseInt(str d))(long(Math/pow 2 p)))))0(map vector(range)(reverse %)))

文字列を逆にすることで-9バイトなので、厄介な下降範囲を作成する必要はありません。

V1：114バイト

まあ、私は確かに勝っていません！私の弁護では、これは私がこれまで書いた最初のプログラムであり、拠点間で変換するため、その方法を学ぶ必要がありました。またMath/pow、変換を必要とするdouble を返すのに役立ちません。またInteger/parseInt、文字を受け入れないため、渡す前に数字をラップする必要があります。

#(reduce(fn[a[p d]](+ a(*(Integer/parseInt(str d))(long(Math/pow 2 p)))))0(map vector(range(dec(count %))-1 -1)%))

場所番号を表す降順のインデックスで文字列を圧縮します。結果のリストを縮小します。

ゴルフをしていない：

(defn to-dec [binary-str]
  (reduce (fn [acc [place digit]]
            (let [parsed-digit (Integer/parseInt (str digit))
                  place-value (long (Math/pow 2 place))]
              (+ acc (* parsed-digit place-value))))
          0
          (map vector (range (dec (count binary-str)) -1 -1) binary-str)))

Perl、21 19 16 + 4 = 20バイト

@Dadaのおかげで-4バイト

で実行します-F -p（の後の余分なスペースを含むF）。を使用して関数に値をパイプするecho -n

$\+=$_+$\for@F}{

として実行 echo -n "101010" | perl -F -pE '$\+=$_+$\for@F}{'

これは、@ Dadaの回答とは大きく異なり、独自のエントリに値するものだと思います。

説明：

-F                              #Splits the input character by character into the @F array
-p                              #Wraps the entire program in while(<>){ ... print} turning it into
while(<>){$\+=$_+$\for@F}{print}
                   for@F        #Loops through the @F array in order ($_ as alias), and...
          $\+=$_+$\             #...doubles $\, and then adds $_ to it (0 or 1)...
while(<>){              }       #...as long as there is input.
                         {print}#Prints the contents of $_ (empty outside of its scope), followed by the output record separator $\

これは、バイナリから10進数への変換に使用する個人用アルゴリズムを使用しています。2進数が与えられたら、アキュムレーターを0から開始し、そのビットを1つずつ調べます。アキュムレータを各ビットを2倍にして、ビット自体をアキュムレータに追加すると、最終的に10進値になります。元の2進数に残っているビット数に基づいて、各ビットの位置が適切な回数倍になるため、機能します。

R（32ビット）、64バイト

関数の入力は文字として指定する必要があります。Rの基本関数は32ビット整数をサポートします。

入力：

# 32-bit version (base)
f=function(x)sum(as.double(el(strsplit(x,"")))*2^(nchar(x):1-1))
f("1")
f("10")
f("101010")
f("1101111111010101100101110111001110001000110100110011100000111")

出力：

> f("1")
[1] 1
> f("10")
[1] 2
> f("101010")
[1] 42
> f("1101111111010101100101110111001110001000110100110011100000111")
[1] 2.016121e+18

R（64ビット）、74バイト

関数の入力は文字として指定する必要があります。その包みbit64は64ビット整数に使用する必要があります。

入力：

# 64-bit version (bit64)
g=function(x)sum(bit64::as.integer64(el(strsplit(x,"")))*2^(nchar(x):1-1))
g("1")
g("10")
g("101010")
g("1101111111010101100101110111001110001000110100110011100000111")

出力：

> g("1")
integer64
[1] 1
> g("10")
integer64
[1] 2
> g("101010")
integer64
[1] 42
> g("1101111111010101100101110111001110001000110100110011100000111")
integer64
[1] 2016120520371234567

Dyalog APL、12 バイト

(++⊢)/⌽⍎¨⍞

⍞ 文字列入力を取得

⍎¨ 各文字を数字に変換します

⌽ 逆

(... )/数字の間に次の関数を挿入します

 ++⊢ 引数と正しい引数の合計

ngnは2バイトを削りました。

k、8バイト

上記のHaskellの回答と同じ方法。

{y+2*x}/

例：

{y+2*x}/1101111111010101100101110111001110001000110100110011100000111b
2016120520371234567