Giới thiệu:

Tôi nhớ, khi tôi còn là một đứa trẻ, tôi sẽ lấy một máy tính và tiếp tục nhấn +nút, và xem tôi có thể đếm cao đến mức nào. Bây giờ, tôi thích lập trình và tôi đang phát triển cho iOS.

Đếm là một kỹ năng cơ bản cho cả con người và máy tính để làm. Không có nó, phần còn lại của toán học không thể được thực hiện. Nó được thực hiện đơn giản bằng cách bắt đầu tại 1và lặp đi lặp lại thêm 1vào nó.

Các thách thức:

Đây là nhưng một thách thức đơn giản. Những gì tôi muốn chương trình của bạn làm là in từ 1bất cứ thứ gì Integernó đưa vào. Tuy nhiên, tôi sẽ vặn vẹo nó, vì việc đếm thập phân khá nhàm chán:

Việc đếm không thể ở cơ sở 10, nó phải thể hiện chính nó đang đếm ở dạng nhị phân.

Vì vậy, để đếm đến 5, sử dụng số nguyên 32 bit, nó sẽ trông như thế này:

0000 0000 0000 0000 0000 0000 0000 0001 ..... 1
0000 0000 0000 0000 0000 0000 0000 0010 ..... 2
0000 0000 0000 0000 0000 0000 0000 0011 ..... 3
0000 0000 0000 0000 0000 0000 0000 0100 ..... 4
0000 0000 0000 0000 0000 0000 0000 0101 ..... 5

Nó là một cái máy vi tính. Họ biết nhị phân tốt nhất. Đầu vào của bạn có thể là số nguyên 32 bit hoặc 64 bit. Nó thực sự là tùy thuộc vào bạn. Tuy nhiên, nếu bạn sử dụng số nguyên 32 bit, đầu ra của bạn phải là số nguyên 32 bit ở dạng nhị phân và nếu bạn sử dụng số nguyên 64 bit, đầu ra của bạn phải là số nguyên 64 bit ở dạng nhị phân .

Đầu vào mẫu:

số nguyên 32 bit, 5

Đầu ra mẫu:

0000 0000 0000 0000 0000 0000 0000 0001
0000 0000 0000 0000 0000 0000 0000 0010
0000 0000 0000 0000 0000 0000 0000 0011
0000 0000 0000 0000 0000 0000 0000 0100
0000 0000 0000 0000 0000 0000 0000 0101

Ghi điểm:

Điểm của bạn bằng với nhiều mã của bạn. Vì đây là Code Golf, điểm số thấp nhất sẽ thắng.

Điểm thưởng:

Nếu bạn hiển thị, trong đầu ra, số đó là số 10 cơ sở (ví dụ: 0000 0000 0000 0000 0000 0000 0000 0001ở dạng nhị phân bằng với số 10 1), hãy nhân số điểm của bạn với 0.8.

Nếu bạn nhóm 4 chữ số đầu ra như tôi đã làm, thì hãy nhân số điểm của bạn với 0.8(một lần nữa). Điều này không bắt buộc.

Không làm tròn, và không làm tròn xuống. Điểm của bạn là một số dấu phẩy động.

Chúc may mắn!

APL, 10 ký tự

Một cái khác trong APL. Giả sử ⎕IO←1(mặc định). Không có điểm thưởng. Đọc số từ thiết bị đầu vào. Nếu APL của bạn sử dụng số nguyên 64 bit thay vì số nguyên 32 bit, hãy thay thế 64 cho 32 nếu cần.

Lưu ý rằng APL chuyển đổi trong suốt thành số dấu phẩy động khi vượt quá phạm vi của một số nguyên. Do đó, thật khó để nói chính xác APL có kích thước nguyên nào.

⍉(32⍴2)⊤⍳⎕

giải trình

2          ⍝ the number 2
32⍴2       ⍝ a vector of 32 twos.
(32⍴2)⊤X   ⍝ X represented as base 2 to 32 digits precision
⍳X         ⍝ a vector of the integers from 1 to X
⎕          ⍝ a number queried from the terminal
(32⍴2)⊤⍳⎕  ⍝ the output we want, flipped by 90°
⍉(32⍴2)⊤⍳⎕ ⍝ the output we want in correct orientation (⍉ is transpose)

JavaScript ( ES6 ) 56,8 (71 * 0,8)

Phiên bản 32 bit, vì JavaScript không thể xử lý độ chính xác 64 bit (tối đa 53 bit bằng cách sử dụng nhân đôi dấu phẩy động)

Không nhóm

f=n=>{for(i=0;i++<n;)console.log((8*(8<<26)+i).toString(2).slice(1),i)} 

Với nhóm - điểm 60,16 (94 * .64)

f=n=>{for(i=0;i++<n;)console.log((8*(8<<26)+i).toString(2).slice(1).match(/..../g).join` `,i)}

Kiểm tra trong mọi trình duyệt (ES5)

function f(n)
{
  for(i=0;i++<n;)console.log((8*(8<<26)+i).toString(2).substr(1).match(/..../g).join(' '),i)
}

// Test
console.log = function(x,y) { O.innerHTML += x+' '+y+'\n' }

Count to: <input id=I><button onclick="O.innerHTML='';f(+I.value)">-></button>
<pre id=O></pre>

Pyth, 18 * 0,8 * 0,8 = 11,52 byte

VSQjd+c.[64.BN\04N

Ví dụ đầu ra:

0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0101 5
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0110 6
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0111 7
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1000 8
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1001 9
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1010 10

Pyth, 19 * 0,8 * 0,8 = 12,16 byte

VSQjd+cjk.[032.BN4N

Ví dụ đầu ra cho đầu vào 5:

0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0101 5

Trình diễn.

Trăn 2, 48 * 0,8 = 38,4

i=0;exec"i+=1;print format(i,'032b'),i;"*input()

Chuyển đổi một số thành nhị phân, sử dụng định dạng chuỗi để chuyển đổi nó thành nhị phân với 32 chữ số, sau đó cũng in số thập phân cho phần thưởng. Sử dụng một execvòng lặp để tăng từ 1giá trị đầu vào.

CJam, 13,44 (21 × 0,64)

ri{)_2b64Ue[4/S*S@N}/

Hãy thử trực tuyến.

APL, 23,68 (37 × .8 × .8)

{⎕←(⍕⍵),⍨⊃,/,/' ',⍨⍕¨8 4⍴(32⍴2)⊤⍵}¨⍳⎕

KDB (Q), 50 * 0,8 * 0,8 = 32

Tôi cảm thấy hơi buồn với bài nộp của mình :( Nên có cách tốt hơn để làm điều này!

{-1{" "sv raze@'string(0N 4#0b vs x),x}@'1+til x;}

Giải trình

                                         1+til x     / counting
   {                                  }@'            / lambda each
                      (0N 4#0b vs x),x               / convert to binary and join with input
    " "sv raze@'string                               / convert to string, concatenate each string and join with space
{-1                                             ;}   / print and surpress output in lambda

Kiểm tra

q){-1{" "sv raze@'string(0N 4#0b vs x),x}@'1+til x;}5
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0101 5

Lisp thường gặp, 96,0

Ghi bàn: (* 150 .8 .8)

(lambda(y)(flet((p(n &aux(x(format()"~39,'0b ~:*~d"n)))(dolist(p'(4 9 14 19 24 29 34))(setf(aref x p)#\ ))(princ x)(terpri)))(dotimes(i y)(p(1+ i)))))

Thí dụ

Gọi hàm bằng 10:

0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0101 5
0000 0000 0000 0000 0000 0000 0000 0110 6
0000 0000 0000 0000 0000 0000 0000 0111 7
0000 0000 0000 0000 0000 0000 0000 1000 8
0000 0000 0000 0000 0000 0000 0000 1001 9
0000 0000 0000 0000 0000 0000 0000 1010 10

Giải trình

(format()"~39,'0b ~:*~d" #b101010101010) cho:

"000000000000000000000000000101010101010 2730"

Chuỗi trung gian (một mảng) được sửa đổi để đặt một ký tự khoảng trắng ở các chỉ số dựa trên zero sau: 4 9 14 19 24 29 34. Sau đó, nó được in.

Lưu ý rằng (format t"~39,'0,' ,4:b ~:*~d" #b101010101010)định dạng rõ ràng đơn giản không làm những gì chúng ta muốn. Nó in:

00000000000000000000000001010 1010 1010 2730

(phần đệm không được nhóm theo 4)

Ruby, 28 (35 * 0,8)

?1.upto(*$*){|x|puts"%.32b #{x}"%x}

C, 97 * 0,8 * 0,8 = 62,08

a,x;main(b){for(scanf("%u",&b);a++<b;printf("%d\n",a))for(x=32;x--;)printf("%*d",x%-4-2,a>>x&1);}

Ví dụ đầu ra cho đầu vào "5":

0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0101 5
0000 0000 0000 0000 0000 0000 0000 0110 6
0000 0000 0000 0000 0000 0000 0000 0111 7
0000 0000 0000 0000 0000 0000 0000 1000 8
0000 0000 0000 0000 0000 0000 0000 1001 9

Tôi có thể thêm một ký tự khoảng trắng để tách các số thập phân khỏi các số nhị phân, nhưng về mặt kỹ thuật, vấn đề không yêu cầu nó, tôi nghĩ vậy? EDIT: Cảm ơn, CL!

Octave, 23 ký tự

dec2bin(1:input(""),32)

Ví dụ đầu ra cho đầu vào 5:

ans =
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101

MatLab, 19 byte

@(x)dec2bin(1:x,32)

Không quá nhiều với cái này, MatLab đã tích hợp sẵn bộ chuyển đổi thập phân sang nhị phân và tự động in kết quả.

Julia, 42 byte

Đây là một chút ngắn hơn mà không có tiền thưởng.

n->for i=1:n println(lpad(bin(i),64,0))end

Điều này tạo ra một hàm không tên lấy một số nguyên và in biểu diễn nhị phân của mỗi số từ 1 đến n , mỗi hàm được đệm bằng 0 đến 64 ký tự.

Với tiền thưởng, 78 byte * 0,8 * 0,8 = 49,92

n->for i=1:n for j=1:4:64 print(lpad(bin(i),64,0)[j:j+3]*" ")end;println(i)end

Điều này tạo ra một hàm không tên lấy một số nguyên và in biểu diễn nhị phân như trước, lần này chia thành các nhóm 4 với số ở cơ sở 10 ở cuối.

Lisp thường gặp, điểm: 64.0

100 byte * 0,8 * 0,8

Tôi khá hài lòng với điểm số của mình, nhưng tôi vẫn cảm thấy nên có khả năng đơn giản hóa mã của mình một chút.

Đầu ra

0000 0000 0000 0000 0000 0000 0000 0001  1
0000 0000 0000 0000 0000 0000 0000 0010  2
0000 0000 0000 0000 0000 0000 0000 0011  3
0000 0000 0000 0000 0000 0000 0000 0100  4
0000 0000 0000 0000 0000 0000 0000 0101  5
0000 0000 0000 0000 0000 0000 0000 0110  6
0000 0000 0000 0000 0000 0000 0000 0111  7
0000 0000 0000 0000 0000 0000 0000 1000  8
0000 0000 0000 0000 0000 0000 0000 1001  9
0000 0000 0000 0000 0000 0000 0000 1010  10

Mã

(defun r(n)(dotimes(i n)(format t"~{~a~a~a~a ~}~a~%"(coerce(format()"~32,'0B"(1+ i))'list)(1+ i))))

Giải trình

Như được mô tả trong câu trả lời của coredump , chuỗi định dạng

"~32,'0B"

không xuất ra số cơ sở 2 nhưng dường như không có khả năng để nhóm đúng. Do đó tôi ép buộc chuỗi thành một danh sách và lặp lại nó bằng cách chọn ra các nhóm 4 với chuỗi định dạng này:

"~ {~ a ~ a ~ a ~ a ~} ~ a ~%"

Sau mỗi nhóm 4 có một khoảng trống và sau nhóm cuối cùng, số cơ sở10 được in.

Không có nhóm (60x0.8 => 48.0)

(defun r(n)(dotimes(i n)(format t"~32,'0B ~:*~a~%"(1+ i))))

Điều này sử dụng ~: * để xử lý lại đối số định dạng (đơn).

PHP, 51,84 (81 × .8 × .8)

Phiên bản 32 bit, vì PHP chỉ giới hạn ở 32 bit trên Windows bất kể HĐH là 64 bit.

Đưa ra một đối số dòng lệnh.

for($i=0;$i++<$argv[1];)echo chunk_split(str_pad(decbin($i),32,0,0),4," ")."$i\n";

CoffeeScript, 60.8 (76 × .8)

Phiên bản 32 bit vì các lý do đã đề cập ở trên , vì CoffeeScript biên dịch thành JavaScript.

f=(x)->console.log(("0".repeat(32)+i.toString 2).slice(-32),i)for i in[1..x]

Với việc nhóm nó trở nên dài hơn một chút: 64,64 (101 × .8 × .8)

f=(x)->console.log(("0".repeat(32)+i.toString 2).slice(-32).match(/.{4}/g).join(" "),i)for i in[1..x]

Haskell, 56 byte

f n=putStr$unlines$take n$tail$sequence$replicate 32"01"

Sử dụng:

*Main> f 5 
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101

Đối với 64 bit, thay thế 32bằng 64. Tất cả các số khác hoạt động, quá.

J, 20 byte

(32#2)#:>:i.".1!:1<1

Mẫu đầu vào và đầu ra:

3
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 0 1
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
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 1

Swift: 98,56 (154 * 0,8 * 0,8)

for x in 1...Int(Process.arguments[1].toInt()!){var p=String(x,radix:2)
let q=count(p)
for i in 0..<32-q{p=(((q+i)%4==0) ?"0 ":"0")+p}
println("\(p) \(x)")}

Ruby, 64 bit

70 * 0,8 * 0,8 = 44,8 byte (tách, thập phân)

1.upto(gets.to_i){|i|puts ("%064d"%i.to_s 2).scan(/.{4}/)*?\s+" #{i}"}

51 * 0,8 = 40,8 byte (thập phân)

1.upto(gets.to_i){|i|puts "%064d"%i.to_s(2)+" #{i}"}

67 * 0,8 = 53,6 byte (tách)

1.upto(gets.to_i){|i|puts "%064d"%i.to_s(2).scan/.{4}/}

44 byte (không có tiền thưởng)

1.upto(gets.to_i){|i|puts "%064d"%i.to_s(2)}

05AB1E , 13 11 byte

Lb32jsäð0:»

-2 byte nhờ @ Mr.Xcoder .

Các đầu ra không có dấu phân cách không gian cũng như số thứ tự.

Hãy thử trực tuyến.

Giải trình:

L              # List of range [1,input]
               #  i.e. 5 → [1,2,3,4,5]
 b             # Convert each to a binary string
               #  i.e. [1,2,3,4,5] → ['1','10','11','100','101']
  32j          # Join everything together with a minimum length per item of 32,
               # which basically prepends spaces to make it length 32
               #  i.e. ['1','10','11','100','101'] → '                               1                              10                              11                             100                             101'
     sä        # Split it into the input amount of parts
               #  i.e. 5 → ['                               1','                              10','                              11','                             100','                             101']
       ð0:     # Replace every space with a 0
               #  i.e. '                             101' → '00000000000000000000000000000101'
          »    # Join everything together by newlines (and output implicitly)