ตัวแปลงไบนารีเป็นทศนิยม

เท่าที่ฉันเห็นเราไม่มีการแปลงเลขฐานสองเป็นทศนิยมแบบธรรมดา

เขียนโปรแกรมหรือฟังก์ชั่นที่รับจำนวนเต็มเลขฐานสองบวกและส่งออกค่าทศนิยม

คุณไม่ได้รับอนุญาตให้ใช้ฟังก์ชันการแปลงฐานในตัวใด ๆ ฟังก์ชันจำนวนเต็มถึงทศนิยม (เช่นฟังก์ชันที่เปลี่ยน101010เป็น[1, 0, 1, 0, 1, 0]หรือ"101010") ได้รับการยกเว้นจากกฎนี้และอนุญาตให้ใช้

กฎ:

• รหัสจะต้องรองรับตัวเลขไบนารี่ถึงค่าตัวเลขสูงสุดที่ภาษาของคุณรองรับ
• คุณอาจเลือกที่จะมีศูนย์นำหน้าในการเป็นตัวแทนไบนารี
• เอาต์พุตทศนิยมอาจไม่มีศูนย์นำหน้า
• รูปแบบอินพุตและเอาต์พุตเป็นตัวเลือก แต่จะไม่มีตัวคั่นใด ๆ ระหว่างตัวเลข (1,0,1,0,1,0,1,0)ไม่ใช่รูปแบบอินพุตที่ถูกต้อง แต่ทั้งสองอย่าง10101010และ(["10101010"])เป็น
  • คุณจะต้องป้อนข้อมูลในทิศทาง "ปกติ" 1110คือไม่ได้147

กรณีทดสอบ:

1
1

10
2

101010
42

1101111111010101100101110111001110001000110100110011100000111
2016120520371234567

ความท้าทายนี้จะเกี่ยวข้องกับความท้าทายอื่น ๆ ไม่กี่เช่นนี้ , นี้และนี้

เยลลี่ 5 ไบต์

DḤ+¥/

ลองออนไลน์!

คำอธิบาย

นักแสดง

• Dเป็น monad (ฟังก์ชันอาร์กิวเมนต์เดียว): ตัวเลขหันเข้า1234[1, 2, 3, 4]

• Ḥ เป็น monad ที่เพิ่มอาร์กิวเมนต์เป็นสองเท่า

• + เป็น dyad (ฟังก์ชันอาร์กิวเมนต์สองตัว) ที่เพิ่มอาร์กิวเมนต์ซ้ายและขวา

จากนั้นมันก็จะยุ่งยากเล็กน้อย

นี่คือสิ่งที่เกิดขึ้นในเวลาในการแยกวิเคราะห์

• D,, Ḥและ+ถูกอ่าน [D, Ḥ, +]ห่วงโซ่ดูเหมือน

• อักขระสองตัวถัดไปเป็นแบบรวดเร็วซึ่งทำหน้าที่เหมือนกับตัวดำเนินการ postfix แบบแยกวิเคราะห์เวลาในลิงก์ (ฟังก์ชัน) ที่เราได้อ่านมา

• เมื่อ¥อ่านแล้วลิงค์สองอันสุดท้ายจะถูกตอกและแทนที่ด้วยลิงค์ที่ทำหน้าที่คล้ายกับ dyad ที่เกิดจากการเขียน [D, dyad(Ḥ+)]ดังนั้นตอนนี้ลักษณะห่วงโซ่ชอบ

• เมื่อ/อ่านแล้วลิงค์สุดท้าย (ซึ่งควรจะเป็น dyad) จะถูกตอกและแทนที่ด้วย monad ที่พับใช้ dyad นี้ (สังหรณ์ใจ: f/รับรายการแทนที่เครื่องหมายจุลภาคในนั้นfและประเมินผลลัพธ์)

• ห่วงโซ่สุดท้ายดูเหมือนว่า[D, fold(dyad(Ḥ+))]พระสององค์

นี่คือสิ่งที่เกิดขึ้นในเวลาทำงาน

• อินพุต (ตัวเลข) จะอ่านค่าการทำงานโดยปริยาย (พูด, 101010)

• Dถูกดำเนินการแทนที่ค่าการทำงานด้วยตัวเลข ( [1,0,1,0,1,0])

• fold(dyad(Ḥ+))จะถูกดำเนินการเปลี่ยนค่าการทำงานกับ1∗0∗1∗0∗1∗0ที่เป็นคู่∗Ḥ+

ดังนั้นx∗yประเมินอะไร

• ในความหมายที่ dyadic ค่าการทำงานเป็นขั้นแรกซ้ายxอาร์กิวเมนต์

• Ḥที่คู่ monad คู่ผสมค่านี้ 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

Python 2, 49 37 31 30 Bytes

ตอนนี้จะใช้เลขฐานสองในการแทนทศนิยมเนื่องจาก Python สามารถจัดการกับจำนวนเต็มขนาดใหญ่โดยพลการ

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

^{ขอบคุณ xnor สำหรับการบันทึกไบต์ :)}

วิธีที่ง่ายที่สุดในการดูว่าการทำงานนี้คือการเห็นสูตรพื้นฐานสำหรับการแปลงไบนารีเป็นทศนิยม:

= 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

นี่เป็นวิธีการแปลง 'มาตรฐาน' คุณสามารถขยายบรรทัดที่สามดังนี้:

= ((((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+

สำหรับ explantion ขอใช้ตัวอย่าง101010 เราเริ่มต้นด้วยหมายเลข1 (ซึ่งแทนด้วยหลักแรก) หลังจากนั้นเรามีสองกรณี:

• หากตัวเลขคือ0ให้คูณตัวเลขด้วย 2
• หากตัวเลขคือ1ให้คูณตัวเลขด้วย 2 แล้วบวก 1

ดังนั้นสำหรับกรณี1,01010การคำนวณต่อไปนี้:

• 1 01010 เริ่มต้นด้วยหมายเลข1
• 1 0 1010 คูณด้วยสองผลในการเข้า2
• 10 1 010 คูณด้วยสองคนและเพิ่มอีกหนึ่งผลในการเข้า5
• 101 0 10 คูณด้วยสองผลในการเข้า10
• 1010 1 0 คูณด้วยสองคนและเพิ่มอีกหนึ่งผลในการเข้า21
• 1,0101 0 , คูณด้วยสอง, ส่งผลเป็น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 ที่แท้จริงเกิดขึ้น,ระหว่างองค์ประกอบ รายการต่อ se ไม่ได้รับอนุญาต ในรุ่นใหม่ของฉันฉันใช้ฟังก์ชั่นที่เหมือนกันมากชื่อตอนนี้fแต่ฉันเกิน "อ้างลำดับตัวละครที่อ้างถึง" ฟังก์ชั่นยังคงใช้รายการของจำนวนเต็มตามที่คุณเห็นในหมายเหตุประกอบชนิด[Int] -> Intแต่รายการที่มีจำนวนเต็มหลักเดียวสามารถเขียน"1234"ได้เช่น

f "101010"

ซึ่งประเมิน42ว่า Unlucky Haskell เนื่องจากรูปแบบรายการเนทิฟไม่ตรงกับกฎท้าทาย Btw f [1,0,1,0,1,0]ยังคงใช้งานได้

เรติน่า 15 ไบต์

แปลงจากไบนารีเป็น unary จากนั้นกลายเป็นทศนิยม

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

แก้ไข: สั้นลง แต่หวานน้อยกว่า: บันทึก 2 ไบต์ด้วย @ETHproductions

เขาวงกต , 17 15 ไบต์

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

ลองออนไลน์!

เขาวงกตเป็นภาษาสองมิติตามกองซ้อน ในทางคดเคี้ยวการใช้รหัสเป็นไปตามเส้นทางของรหัสเช่นเขาวงกตที่มีช่องว่างทำหน้าที่เป็นกำแพงและเริ่มต้นด้วยอักขระบนซ้ายสุดที่ไม่ใช่ช่องว่าง การไหลของรหัสจะถูกกำหนดโดยเครื่องหมายของด้านบนของสแต็ก เนื่องจากสแต็กมีค่าศูนย์เป็นนัยที่ด้านล่างคำสั่งสี่คำแรก ( -+:+) จึงไม่มีผล

วนรอบเริ่มต้นที่ ,

• , กดค่ารหัส ascii ของอักขระอินพุตถัดไปไปยังจุดหยุดของสแต็กหรือกด -1 ถ้า EOF
• _48 ผลัก 48 ไปด้านบนสุดของสแต็ก
• -Pop Y, ป๊อป x x-yผลักดัน คำแนะนำก่อนหน้านี้มีผลในการลบ 48 จากอินพุตที่ให้ 0 สำหรับ "0" และ 1 สำหรับ "1"
• +Pop Y, ป๊อป x x+yผลักดัน
• : ทำซ้ำส่วนบนสุดของสแต็ก
• + คำสั่งนี้และคำสั่งก่อนหน้ามีผลในการคูณมูลค่าปัจจุบันด้วย 2

ดังนั้นส่วนวงกลมของรหัสจึงคูณจำนวนปัจจุบันด้วย 2 และเพิ่ม 1 หรือ 0 ขึ้นอยู่กับว่าอักขระ 1 หรือ 0 เป็นอินพุต

หาง

หากด้านบนสุดของสแต็กเป็นลบ (หมายถึงพบ EOF) รหัสจะเลี้ยวซ้ายที่ทางแยก (ไปสู่อัฒภาค)

• `` `ลบส่วนบนสุดของสแต็กเพื่อรับ 1
• ) ใส่ส่วนบนสุดของสแต็กเพื่อรับ 2
• /ป๊อป y, ป๊อป x, กด x / y (การหารจำนวนเต็ม) สิ่งนี้มีผลในการเลิกการล่าสุด*2จากลูป
• !เอาต์พุตการแทนค่าจำนวนเต็มของด้านบนของสแต็ก เมื่อถึงจุดนี้โปรแกรมจะหมุนไปรอบ ๆ เพราะมันเข้าใกล้จุดตายแล้วออกจากด้วยข้อผิดพลาดเพราะมันพยายามหารด้วยศูนย์

ขอบคุณ@Martin Ender ที่ช่วยฉัน 2 ไบต์ (และสอนวิธีคิดให้ดีขึ้นใน Labyrinth)

Brain-Flak , 46 , 28 bytes

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

ลองออนไลน์!

ไบต์จำนวนมากที่บันทึกไว้ต้องขอบคุณ @Riley!

เนื่องจากส่วนที่ต่อกันของสมองไม่สามารถรับข้อมูลเข้าไบนารีได้ข้อมูลจึงเป็นรายการ '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*+

ลองออนไลน์!

อ่านหนึ่งตัวอักษรในเวลาหนึ่งจากการป้อนข้อมูลแปลงเป็น 0 หรือ 1 โดยการใช้ค่าโมดูโล 2 (0 คือถ่าน (48), 1 คือถ่าน (49)) จากนั้นใช้อัลกอริทึมปกติของการเพิ่มมูลค่าปัจจุบันและเพิ่ม ตัวเลขใหม่ทุกครั้ง

โบนัส: มันใช้งานได้กับสตริงอินพุตทุกชนิดฉันพยายามไปชั่วขณะหนึ่งเพื่อหาชุดค่าผสมอินพุต - เอาท์พุตที่ตลก แต่ฉันไม่สามารถสร้างอะไรได้เลย (น่าเศร้า, "answer" = 46) คุณสามารถ?

Javascript (ES7) 41 40 36 ไบต์

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

ใช้สตริงเป็นอินพุต

โกนได้หนึ่งไบต์ขอบคุณ ETHproductions

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;

• ขอบคุณKadeสำหรับการบันทึก 41 ไบต์!
• การเปลี่ยนเป็น 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;}

เช่นเดียวกับคำตอบจาวาสคริปต์ของฉัน

ทดสอบไอเดีย

Perl, 25 ไบต์

-3 ไบต์ขอบคุณ @Dom Hastings

โค้ด 24 ไบต์ + 1 ไบต์สำหรับ-pแฟล็ก

$\|=$&<<$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

เร่งความเร็ว 10 ไบต์

จะเข้าเป็นรายการของ 0/1 $ pushy binary.pshy 1,0,1,0,1,0ในบรรทัดคำสั่งนี้:

L:vK2*;OS#

อัลกอริทึมแสดงให้เห็นถึงความงามที่แท้จริงของการมีสแต็กที่สอง:

            \ 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 - nเท่าก่อนถึงจำนวนnซึ่งจะถูกทิ้งลงในสแต็กที่สองในภายหลัง นี่คือกระบวนการที่ดูเหมือนกับอินพุต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

คำอธิบาย

นี่อาจจะง่ายกว่าที่จะอธิบายตามเวอร์ชั่นเก่าที่ไม่ค่อยตีกอล์ฟแล้วแสดงว่าฉันย่อให้สั้นลงได้อย่างไร ฉันเคยแปลงเลขฐานสองเป็นทศนิยมเช่นนี้

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

วิธีเดียวที่สมเหตุสมผลในการสร้างตัวเลขทศนิยมใน Retina คือการนับสิ่งต่าง ๆ (เพราะ Retina มีคุณสมบัติสองอย่างที่ให้มันพิมพ์ตัวเลขทศนิยมแทนจำนวน) ดังนั้นวิธีที่เป็นไปได้เพียงอย่างเดียวคือการแปลงไบนารี่เป็นเอกและจากนั้นก็นับจำนวนหลักเอก บรรทัดสุดท้ายทำการนับดังนั้นสี่ตัวแรกจะแปลงเป็นไบนารี

เราจะทำอย่างนั้นได้อย่างไร? โดยทั่วไปการแปลงจากรายการของบิตเป็นจำนวนเต็มเราเริ่มต้นผลลัพธ์เป็น0และจากนั้นไปถึงบิตจากที่สำคัญมากที่สุดไปถึงอย่างน้อยที่สุดเพิ่มค่าที่เรามีและเพิ่มบิตปัจจุบันเป็นสองเท่า เช่นถ้าเลขฐานสองเป็นจำนวน1011จริงเราจะคำนวณ:

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

โดยที่ฉันทำเครื่องหมายบิตแต่ละรายการเพื่อความชัดเจน

กลอุบายในการทำสิ่งนี้โดยไม่รวมกันคือก) การเพิ่มเป็นสองเท่านั้นหมายถึงการทำซ้ำหมายเลขและ b) เนื่องจากเรานับจำนวน1s ตอนท้ายเราไม่จำเป็นต้องแยกแยะระหว่าง0s และ1s ในกระบวนการ สิ่งนี้จะชัดเจนขึ้นในไม่กี่วินาที

สิ่งที่โปรแกรมทำคือการเพิ่มเครื่องหมายจุลภาคแรกไปยังจุดเริ่มต้นเป็นเครื่องหมายสำหรับจำนวนการป้อนข้อมูลที่เราประมวลผลแล้ว:

^
,

ด้านซ้ายของตัวทำเครื่องหมายเราจะมีค่าที่เรากำลังสะสม (ซึ่งถูกเริ่มต้นอย่างถูกต้องกับการเป็นตัวแทนของศูนย์ unary) และด้านขวาของค่าจะเป็นบิตถัดไปในการประมวลผล ตอนนี้เราใช้การทดแทนต่อไปนี้ในลูป:

,(.)
$`$1,

เพียงแค่ดู,(.)และ$1,สิ่งนี้จะย้ายเครื่องหมายหนึ่งบิตไปทางขวาในแต่ละครั้ง แต่เราก็แทรก$`ซึ่งก็คือทุกสิ่งที่อยู่ข้างหน้าของเครื่องหมายเช่นค่าปัจจุบันซึ่งเราเพิ่มเป็นสองเท่า นี่คือขั้นตอนแต่ละขั้นตอนในการประมวลผลอินพุต1011โดยที่ฉันได้ทำเครื่องหมายผลลัพธ์ของการแทรก$`ด้านบนแต่ละบรรทัด (ว่างเปล่าสำหรับขั้นตอนแรก):

,1011

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

คุณจะเห็นว่าเราได้รักษาไว้และเพิ่มศูนย์เป็นสองเท่าพร้อมกับทุกอย่างอื่น แต่เนื่องจากเราไม่สนใจพวกเขาในตอนท้ายมันไม่สำคัญว่าเราจะเพิ่มพวกเขาเป็นสองเท่าตราบใดที่จำนวน1s เป็น แก้ไข. หากคุณนับพวกเขามี11พวกเขาเพียงแค่สิ่งที่เราต้องการ

นั่นทำให้คำถามเกี่ยวกับวิธีตีกอล์ฟนี้ลงถึง 12 ไบต์ ส่วนที่แพงที่สุดของรุ่น 18 ไบต์ต้องใช้เครื่องหมาย เป้าหมายคือการกำจัดสิ่งนั้น เราต้องการเพิ่มส่วนนำหน้าของทุก ๆ สองบิตดังนั้นความคิดแรกอาจเป็นเช่นนี้:

.
$`$&

ปัญหาคือการแทนที่เหล่านี้เกิดขึ้นพร้อมกันดังนั้นบิตแรกจะไม่เพิ่มเป็นสองเท่าสำหรับแต่ละบิต แต่จะได้รับการคัดลอกหนึ่งครั้งในแต่ละครั้ง สำหรับการป้อนข้อมูล1011เราจะได้รับ (ทำเครื่องหมายการแทรก$`):

 _ __ ___
1101011011

เรายังคงต้องดำเนินการอินพุตซ้ำเพื่อให้คำนำหน้าแรกสองเท่าเป็นสองเท่าอีกครั้งโดยที่สองและอื่น ๆ แนวคิดหนึ่งคือการแทรกเครื่องหมายทุกที่และแทนที่ด้วยคำนำหน้าซ้ำ ๆ :

\B
,
+%`,
¶$`

หลังจากแทนที่เครื่องหมายแต่ละตัวด้วยคำนำหน้าเป็นครั้งแรกเราจำเป็นต้องจำตำแหน่งที่จุดเริ่มต้นของอินพุตดังนั้นเราจึงแทรก linefeeds ด้วยและใช้%ตัวเลือกเพื่อให้แน่ใจว่าสิ่งต่อไปนี้$`จะเลือกเฉพาะตัวป้อนข้อมูลที่ใกล้เคียงที่สุดเท่านั้น

วิธีนี้ใช้งานได้ แต่ก็ยังยาวเกินไป (16 ไบต์เมื่อนับ1s ตอนท้าย) แล้วเราจะเปลี่ยนสิ่งต่าง ๆ สถานที่ที่เราต้องการแทรกเครื่องหมายถูกระบุด้วย\B(ตำแหน่งระหว่างตัวเลขสองหลัก) ทำไมเราไม่ใส่คำนำหน้าเข้าไปในตำแหน่งเหล่านั้น? เกือบจะใช้งานได้ แต่ความแตกต่างคือในโซลูชันก่อนหน้านี้เราลบเครื่องหมายเดียวในแต่ละการแทนที่และที่สำคัญคือการทำให้กระบวนการยุติลง อย่างไรก็ตาม\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;

เราย้อนกลับจำนวนไบนารี่ของเราแบ่งออกเป็นตัวเลของค์ประกอบและรวมพวกเขาตามตำแหน่ง

ยูทิลิตี Bash + GNU ขนาด 29 ไบต์

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

I / O ผ่าน stdin / stdout

sedแสดงออกแยกขึ้นไบนารีในแต่ละหลักและสร้างการแสดงออก RPN สำหรับdcในการประเมิน

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[#+##&]

รับ a Listบิตเป็นอินพุต (เช่น{1, 0, 1, 1, 0}- การแทนเลขฐานสองของMathematicaของจำนวน22)

Clojure, 114 105 63 41 ไบต์

V4: 41 ไบต์

-22 ไบต์ขอบคุณ @cliffroot เนื่องจาก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!

Ungolfed:

(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ส่งกลับสองเท่าที่ต้องมีการแปลงจากและ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)%))

ซิปสตริงด้วยดัชนีจากมากไปน้อยแสดงถึงหมายเลขสถานที่ ลดลงในรายการผลลัพธ์

Ungolfed:

(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 ไบต์

-4 ไบต์ขอบคุณ @Dada

เรียกใช้ด้วย-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 $\

นี่ใช้อัลกอริทึมส่วนตัวของฉันที่เลือกสำหรับการแปลงแบบไบนารีเป็นทศนิยม ให้เลขฐานสองเริ่มสะสมของคุณที่ 0 และไปทีละบิต เพิ่มตัวสะสมเป็นสองเท่าในแต่ละบิตจากนั้นเพิ่มบิตเข้าไปในตัวสะสมของคุณและคุณจะได้ค่าทศนิยม มันทำงานได้เพราะแต่ละบิตจบลงจะถูกเพิ่มเป็นสองเท่าของจำนวนครั้งที่เหมาะสมสำหรับตำแหน่งของมันตามจำนวนบิตที่เหลืออยู่ในเลขฐานสองเดิม

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