Vẽ một bàn tính Suanpan

32

Viết chương trình ngắn nhất lấy một số nguyên làm đầu vào và in ra bàn tính Suanpan

Tủ thử

Đầu vào:

314159

Đầu ra:

|\======================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
||  (__)  (__)  (__)  (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)  (__)  ||
|<======================================>|
||  (__)  (__)  (__)  (__)   ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||   ||    ||   (__)   ||    ||   (__)  ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/======================================\|

Đầu vào:

6302715408

Đầu ra:

|\==============================================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
||   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  (__)   ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||  (__)   ||    ||    ||   (__)   ||   (__)   ||    ||   (__)  ||
|<==============================================================>|
||  (__)  (__)   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  ||
||   ||   (__)   ||   (__)  (__)   ||    ||   (__)   ||   (__)  ||
||   ||   (__)   ||    ||    ||    ||    ||   (__)   ||   (__)  ||
||   ||    ||    ||    ||    ||    ||    ||   (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||   ||    ||   (__)   ||    ||    ||   (__)   ||   (__)   ||   ||
||  (__)   ||   (__)   ||    ||   (__)  (__)   ||   (__)   ||   ||
||  (__)   ||   (__)  (__)  (__)  (__)  (__)   ||   (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)   ||   (__)  (__)  ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/==============================================================\|
code-golf  ascii-art 
— gặm nhấm
nguồn
Số có thể được đưa ra trên dòng lệnh?
— Joey
Bất kỳ hạn chế về chiều dài đầu vào?
— Joey
Tương tự như golf.shinh.org/p.rb?Soroban+Fixed nếu có ai cần một số ý tưởng về cách chơi gôn nhiều hơn.
— Nabb
1
Vậy hàng trên cùng và hàng dưới luôn được lấp đầy hoàn toàn? Tại sao họ phát minh ra một bàn tính dư thừa như vậy? :)
— Timwi
@Timwi, bàn tính tương tự có thể được sử dụng cho thập lục phân. Khi được sử dụng cho số thập phân, các hàng thừa hầu hết được sử dụng khi thực hiện phép nhân và chia
— gnibbler

Câu trả lời:

14

J, 126 124 121 119 116 115 113 105 116 115 112 ký tự

'|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1[(s=:[,.~,.)9!:7'\=/<=>/=\|='

Lấy đầu vào từ bàn phím. Thí dụ:

   '|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1[(s=:[,.~,.)9!:7'\=/<=>/=\|='
6302715408
|\==============================================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
||   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  (__)   ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||  (__)   ||    ||    ||   (__)   ||   (__)   ||    ||   (__)  ||
|<==============================================================>|
||  (__)  (__)   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  ||
||   ||   (__)   ||   (__)  (__)   ||    ||   (__)   ||   (__)  ||
||   ||   (__)   ||    ||    ||    ||    ||   (__)   ||   (__)  ||
||   ||    ||    ||    ||    ||    ||    ||   (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||   ||    ||   (__)   ||    ||    ||   (__)   ||   (__)   ||   ||
||  (__)   ||   (__)   ||    ||   (__)  (__)   ||   (__)   ||   ||
||  (__)   ||   (__)  (__)  (__)  (__)  (__)   ||   (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)   ||   (__)  (__)  ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/==============================================================\|

Thủ thuật chính ở đây là lạm dụng quyền anh của J bằng cách xác định lại các nhân vật mà nó sử dụng. Nó sử dụng một tham số toàn cầu - 9!:7- để làm điều này. Có thể có chỗ để chơi gôn hơn nữa, nhưng thành thật mà nói, tôi rất vui khi nhận được một cái gì đó hoạt động sẽ bù đắp cho nỗ lực cuối cùng của tôi trong câu hỏi này .

Phù hợp trong một tweet với đủ ký tự còn lại để nói 'Gaz đã thực hiện điều này' :-).

Chỉnh sửa: 3 ký tự tiết kiệm là do vay mượn 2 6$' || (__)'từ Jesse Millikan câu trả lời.

Chỉnh sửa thêm: Mất 11 ký tự thêm khoảng trắng ở hai bên mà tôi không nhận thấy không có mặt.

Giải trình:

Mã này có ba phần chính:

1) Thiết lập

[(s=:[,.~,.)9!:7'\=/<=>/=\|='

Điều này là chính nó trong hai phần.
9!:7'\=/<=>/=\|='xác định lại các ký tự mà J sẽ sử dụng để hiển thị các hộp. Quyền anh của J thường trông như thế này:

   2 2$<"0[1 2 3 4
┌─┬─┐
│1│2│
├─┼─┤
│3│4│
└─┴─┘

nhưng sau khi xác định lại nó trông như thế này:

   2 2$<"0[1 2 3 4
\===/
|1|2|
<===>
|3|4|
/===\

(s=:[,.~,.)định nghĩa một động từ tôi sẽ sử dụng một vài lần sau đó. Đây hóa ra là nơi tốt nhất để tuyên bố nó. Nó lấy một ký tự bên trái và một mảng các ký tự bên phải và kẹp mảng giữa các ký tự. Ví dụ:

   3 5$'abcdefghijklmno'
abcde
fghij
klmno

   '-' s 3 5$'abcdefghijklmno'
-abcde-
-fghij-
-klmno-

Trận chung kết [ chỉ phục vụ để tách các thiết lập từ phần tiếp theo.

2) Đầu vào và đại diện

,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1

".,.1!:1[1 lấy đầu vào từ bàn phím và tách nó thành các chữ số riêng lẻ:

   ".,.1!:1[1
314159
3 1 4 1 5 9

((i.5)</5|]) tạo ra một số không và đại diện cho phần dưới cùng của bàn tính:

   ((i.5)</5|]) 3 1 4 1 5 9
1 1 1 1 0 1
1 0 1 0 0 1
1 0 1 0 0 1
0 0 1 0 0 1
0 0 0 0 0 0

|:@(1,.<&5) tạo ra một số không và đại diện cho phần trên cùng của bàn tính:

   |:@(1,.<&5) 3 1 4 1 5 9
1 1 1 1 1 1
1 1 1 1 0 0

Hai phần này được đóng hộp với nhau bằng cách sử dụng ; :

   (|:@(1,.<&5);((i.5)</5|])) 3 1 4 1 5 9
\=======================/
|1 1 1 1 1 1|1 1 1 1 0 1|
|1 1 1 1 0 0|1 0 1 0 0 1|
|           |1 0 1 0 0 1|
|           |0 0 1 0 0 1|
|           |0 0 0 0 0 0|
/=======================\

Sau đó, các hộp được đặt chồng lên nhau để tạo cơ sở cho bàn tính, đưa ra:

   ,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
\===========/
|1 1 1 1 1 1|
|1 1 1 1 0 0|
<===========>
|1 1 1 1 0 1|
|1 0 1 0 0 1|
|1 0 1 0 0 1|
|0 0 1 0 0 1|
|0 0 0 0 0 0|
/===========\

3) Đầu ra

'|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>

&.>có nghĩa là những gì tiếp theo sẽ lần lượt hoạt động trên cả hai hộp.
(,-.)đây là một cái móc sẽ phủ nhận đầu vào và sau đó thêm nó vào cuối của bản gốc:

   2 5$1 0 1 0 1
1 0 1 0 1
1 0 1 0 1

   (,-.) 2 5$1 0 1 0 1
1 0 1 0 1
1 0 1 0 1
0 1 0 1 0
0 1 0 1 0

Đây thực sự là một phần của đại diện, nhưng đối với mục đích chơi gôn, tốt hơn là có nó trong phần này. Áp dụng cho đầu vào trước:

   (,-.)&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
\===========/
|1 1 1 1 1 1|
|1 1 1 1 0 0|
|0 0 0 0 0 0|
|0 0 0 0 1 1|
<===========>
|1 1 1 1 0 1|
|1 0 1 0 0 1|
|1 0 1 0 0 1|
|0 0 1 0 0 1|
|0 0 0 0 0 0|
|0 0 0 0 1 0|
|0 1 0 1 1 0|
|0 1 0 1 1 0|
|1 1 0 1 1 0|
|1 1 1 1 1 1|
/===========\

[:,.(_6[\' || (__)'){~ Các số 0 và số hiện được sử dụng để chọn một chuỗi để biểu thị chuỗi hạt hoặc không có chuỗi:

   ([:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
\====================================/
| (__)  (__)  (__)  (__)  (__)  (__) |
| (__)  (__)  (__)  (__)   ||    ||  |
|  ||    ||    ||    ||    ||    ||  |
|  ||    ||    ||    ||   (__)  (__) |
<====================================>
| (__)  (__)  (__)  (__)   ||   (__) |
| (__)   ||   (__)   ||    ||   (__) |
| (__)   ||   (__)   ||    ||   (__) |
|  ||    ||   (__)   ||    ||   (__) |
|  ||    ||    ||    ||    ||    ||  |
|  ||    ||    ||    ||   (__)   ||  |
|  ||   (__)   ||   (__)  (__)   ||  |
|  ||   (__)   ||   (__)  (__)   ||  |
| (__)  (__)   ||   (__)  (__)   ||  |
| (__)  (__)  (__)  (__)  (__)  (__) |
/====================================\

Nhưng bây giờ, như Howard chỉ ra cho tôi, có một khoảng trống ở hai bên của chuỗi hạt. Vì vậy, chúng tôi sử dụng sđộng từ được xác định trước để kẹp nội dung của mỗi hộp giữa hai cột khoảng trắng:

   (' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
\======================================/
|  (__)  (__)  (__)  (__)  (__)  (__)  |
|  (__)  (__)  (__)  (__)   ||    ||   |
|   ||    ||    ||    ||    ||    ||   |
|   ||    ||    ||    ||   (__)  (__)  |
<======================================>
|  (__)  (__)  (__)  (__)   ||   (__)  |
|  (__)   ||   (__)   ||    ||   (__)  |
|  (__)   ||   (__)   ||    ||   (__)  |
|   ||    ||   (__)   ||    ||   (__)  |
|   ||    ||    ||    ||    ||    ||   |
|   ||    ||    ||    ||   (__)   ||   |
|   ||   (__)   ||   (__)  (__)   ||   |
|   ||   (__)   ||   (__)  (__)   ||   |
|  (__)  (__)   ||   (__)  (__)   ||   |
|  (__)  (__)  (__)  (__)  (__)  (__)  |
/======================================\

Đã làm điều đó, tất cả những gì còn lại là chuyển đổi chuỗi này thành một chuỗi bằng cách sử dụng ":để chúng ta có thể kẹp nó giữa hai cột |:

   '|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
|\======================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
||  (__)  (__)  (__)  (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)  (__)  ||
|<======================================>|
||  (__)  (__)  (__)  (__)   ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||   ||    ||   (__)   ||    ||   (__)  ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/======================================\|
— Gareth
nguồn
Tôi cảm thấy có gì đó "sai" với đầu ra của bạn nhưng tôi phải mất một thời gian để nhận ra: bạn bỏ qua một cột trống ở bên trái và bên phải của màn hình (cột ascii thứ ba và thứ ba).
— Howard
@Howard Woah, điểm tốt. Tôi đã không nhận thấy điều đó. Tôi sẽ xem xét việc sửa nó.
— Gareth
@Howard Đã sửa với chi phí 11 ký tự. Thật xấu hổ, tôi nghĩ rằng tôi có thể có cơ hội nhận được dưới 100. :-(
— Gareth
Công việc tốt đẹp. Có vẻ như @Howard có rất nhiều việc phải làm để bắt kịp
— gnibbler
Bounty còn 3 ngày nữa. Tôi đã đánh dấu cái này là chấp nhận cho thời gian trung bình.
— gnibbler
14

Ruby 1.9, 154 ký tự

puts'|\%s/|'%$r=?=*(2+6*gets.size),(0..14).map{|a|a==4?"|<#$r>|":"|| #{$_.gsub(/./){(5*a+n=$&.hex)/10!=1&&(a-n%5)/5!=1?' (__) ':'  ||  '}} ||"},"|/#$r\\|"

Giả sử đầu vào là không bị chấm dứt bởi một dòng mới.

Sự thật thú vị: Do cách tôi biến các chữ số đầu vào thành số ( $&.hexngắn hơn một byte $&.to_i), bàn tính này thực sự hoạt động với các chữ số hex lên đến e:

$ echo -n "0123456789abcdef" | ruby suanpan.rb
|\==================================================================================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)   ||    ||    ||    ||    ||    ||   ||
||  (__)  (__)  (__)  (__)  (__)   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   (__)  ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   (__)  (__)  (__)  (__)  (__)  (__)  ||
||   ||    ||    ||    ||    ||   (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|<==================================================================================================>|
||   ||   (__)  (__)  (__)  (__)   ||   (__)  (__)  (__)  (__)   ||   (__)  (__)  (__)  (__)   ||   ||
||   ||    ||   (__)  (__)  (__)   ||    ||   (__)  (__)  (__)   ||    ||   (__)  (__)  (__)   ||   ||
||   ||    ||    ||   (__)  (__)   ||    ||    ||   (__)  (__)   ||    ||    ||   (__)  (__)   ||   ||
||   ||    ||    ||    ||   (__)   ||    ||    ||    ||   (__)   ||    ||    ||    ||   (__)   ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||  (__)   ||    ||    ||    ||   (__)   ||    ||    ||    ||   (__)   ||    ||    ||    ||   (__)  ||
||  (__)  (__)   ||    ||    ||   (__)  (__)   ||    ||    ||   (__)  (__)   ||    ||    ||   (__)  ||
||  (__)  (__)  (__)   ||    ||   (__)  (__)  (__)   ||    ||   (__)  (__)  (__)   ||    ||   (__)  ||
||  (__)  (__)  (__)  (__)   ||   (__)  (__)  (__)  (__)   ||   (__)  (__)  (__)  (__)   ||   (__)  ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/==================================================================================================\|

Dành cho 0xf , một hạt thứ ba kỳ diệu xuất hiện ở nửa trên.

Khi cho phép các cờ bổ sung trong khi gọi tập lệnh, điều này có thể được rút ngắn xuống 152 byte (mã 149 byte + 3 cờ gọi bổ sung 3 byte):

puts'|\%s/|'%$r=?=*(2+6*~/$/),(0..14).map{|a|a==4?"|<#$r>|":"|| #{$_.gsub(/./){(5*a+n=$&.hex)/10!=1&&(a-n%5)/5!=1?' (__) ':'  ||  '}} ||"},"|/#$r\\|"

Chạy với ruby -n suanpan.rb.

— Ventero
nguồn
12

Perl (151 ký tự)

( 168 163 158 157 156 154 )

$i=<>;$c.=$_-4?"
||  $i||":"
|<$m>|",$m='==',$c=~s!\d!$m.='='x6;($_-$&%5)/5%2|(5*$_+$&)/10%7==1?' ||   ':'(__)  '!eg for 0..14;print"|\\$m/|$c
|/$m\\|"

Giải trình

# Read the number from STDIN.
$i = <>;

# for statement starts here...

    # Append to $c a line containing either the horizontal dividing bar (in row #4)
    # or the current abacus row with the digits in place of the pegs.
    # This relies on the fact that $m will have been computed after at least one iteration.
    $c .= $_-4 ? "\n||  $i||" : "\n|<$m>|",

    # Notice that $m is redundantly recomputed from scratch in each iteration.
    $m = '==',

    # Substitute the correct pegs for the digit characters.
    $c =~ s!\d!
        $m .= '=' x 6;

        # Weird expression for the abacus function.
        # I have to use “% 7” because otherwise the division is floating-point...
        # Notice that $_ is the row and $& is the digit.
        ($_ - $& % 5)/5 % 2 | (5*$_ + $&)/10 % 7 == 1
        ? ' ||   '
        : '(__)  '
    !eg
for 0..14;

# Could shorten further by using “say” if you don’t mind excluding the “-E” from the count...
print "|\\$m/|$c\n|/$m\\|"

Chỉnh sửa

  • (154 → 151) Thay đổi ba \ns thành ký tự dòng mới thực tế. Không thể tin rằng tôi đã không nghĩ về điều đó sớm hơn!
— Timwi
nguồn
1
Đây chỉ là ... Tuyệt vời!
— German_guy
8

Windows PowerShell, 191

$y='='*(2+6*($i=[char[]]"$input").Count)
filter f($v){"|| $((' (__)','  || ')[($i|%{iex $_%$v})])  ||"}"|\$y/|"
f 1
f 10-ge5
f 1+1
f 10-lt5
"|<$y>|"
1..5|%{f 5-lt$_}
1..5|%{f 5-ge$_}
"|/$y\|"

Lịch sử:

  • 2011/03/11 23:54 (340) Nỗ lực ban đầu.
  • 2011/03/12 00:21 (323) Sử dụng phép nội suy chuỗi trong toàn bộ mã.
  • 2011/03/12 00:21 (321) inlined$l .
  • 2011/03/12 01:07 (299) Đã sử dụng một hàm cho các phần lặp lại nhiều hơn cũng như một chuỗi định dạng.
  • 2011/03/12 01:19 (284) Thay đổi các đối số thành hàm một chút. Hoan hô cho chế độ phân tích cú pháp lệnh.
  • 2011/03/12 01:22 (266) Thêm biến cho biểu thức định kỳ.
  • 2011/03/12 01:28 (246) Bây giờ mỗi hàng được tạo bởi hàm.
  • 2011/03/12 01:34 (236) Vì tôi chỉ sử dụng ký tự trong nội suy chuỗi nên tôi có thể bỏ qua các %số tạo ra từ các chữ số một cách an toàn .
  • 2011/03/12 01:34 (234) Tối ưu hóa một chút việc tạo chỉ mục mảng trong hàm.
  • 2011/03/12 01:42 (215) Tôi không còn cần $rvà$b . Và $acũng đã lỗi thời. Như là $l.
  • 2011/03/12 01:46 (207) Không cần thiết lập $OFSnếu tôi chỉ cần một lần.
  • 2011/03/12 01:49 (202) inlined $f.
  • 2011/03/12 01:57 (200) Không cần chuỗi định dạng nữa. Nội suy chuỗi hoạt động tốt.
  • 2011/03/12 02:00 (198) Tối ưu hóa một chút khi tạo các hàng riêng lẻ (sắp xếp lại chỉ số đường ống và mảng).
  • 2011/03/12 02:09 (192) Không cần -joinvì chúng ta thực sự có thể sử dụng không gian bổ sung để có hiệu quả tốt.
— Joey
nguồn
5

Haskell, 243 ký tự

z x|x=" (__) ";z _="  ||  "
h[a,b]d f w='|':a:replicate(2+6*length d)'='++b:"|\n"++q z++q(z.not)
 where q b=w>>=(\v->"|| "++(d>>=b.(>v).f)++" ||\n")
s d=h"\\/"d(5-)[-9,0]++h"><"d(`mod`5)[0..4]++h"/\\"d id[]
main=interact$s.map(read.(:[])).init

Không đặc biệt thông minh. Tôi chắc chắn rằng nó có thể được rút ngắn bằng cách nào đó ...

  • Chỉnh sửa: (246 -> 243) lấy gợi ý của @ FUZxxl để sử dụng tương tác
— MtnViewMark
nguồn
Cách sử dụnginteract
— FUZxxl
Dòng đầu tiên có thể được rút ngắn z x|x=" (__) "|0<1=" || ".
— FUZxxl
Dòng đầu tiên thay thế của bạn chỉ ngắn hơn vì bạn đã bỏ hai khoảng trống bắt buộc!
— MtnViewMark
Rất tiếc! Tất nhiên là bạn đúng.
— FUZxxl
4

Delphi, 348

Phiên bản này xây dựng một chuỗi để viết chỉ một lần; Các chữ số được xử lý bởi một hàm riêng biệt hoạt động thông qua một digit modulo m >= valuecấu trúc (phủ định nếu giá trị <0).

var d,s,o,p:string;c:Char;i:Int8;function g(m,v:Int8):string;begin p:='|| ';for c in d do p:=p+Copy('  ||   (__) ',1+6*Ord(((Ord(c)+2)mod m>=Abs(v))=(v>0)),6);g:=p+' ||'^J;end;begin ReadLn(d);s:=StringOfChar('=',2+6*Length(d));for i:=1to 5do o:=g(5,6-i)+o+g(5,-i);Write('|\'+s+'/|'^J+g(1,-1)+g(10,-5)+g(1,1)+g(10,5)+'|<'+s+'>|'^J+o+'|/'+s+'\|')end.

Delphi, 565

Nỗ lực đầu tiên: 

var _:array[0..6]of string=('  ||  ',' (  ) ','======','|\==/|','||  ||','|/==\|','|<==>|');m:array[0..186]of Byte;o:array[0..16]of string;i,j,c,f,l:Word;begin for i:=0to 9do begin f:=i*17;m[f+1]:=1;m[f+2]:=Ord(i<5);m[f+3]:=0;m[f+4]:=Ord(i>4);for j:=6to 10do m[f+j]:=Ord(i mod 5>j-6);for j:=11to 15do m[f+j]:=Ord(i mod 5<=j-11);m[f]:=2;m[5+f]:=2;m[16+f]:=2;end;f:=170;m[f]:=3;for i:=1to 15do m[f+i]:=4;m[f+5]:=6;m[f+16]:=5;repeat for i:=0to 16do Insert(_[m[f+i]],o[i],l);Read(PChar(@c)^);c:=c-48;f:=c*17;l:=Length(o[0])-2;until c>9;for i:=0to 16do WriteLn(o[i])end.

Điều này sử dụng 3 mảng; một cho 7 chuỗi có thể được phân biệt, một cho các dòng đầu ra và một để ánh xạ 7 chuỗi thành 11 cột (10 chữ số và 1 cột ban đầu).

— PatrickvL
nguồn
3

GolfScript, 139 ký tự

0+17'|':Q*:R'\<||'4Q**'/'+@{48-.5<)[1]*2,2*$+4<\5%[1]*2,5*$+10<+`{{1$=}%+2>'=='1/*5/('='+\+}+'     (|_|_ )'2//}/;;;;'/>||'4Q**'\\'+R]zip n*

Chưa chơi gôn nhiều, nhưng nó phù hợp với một tweet (chỉ với ASCII). Hãy thử nó ở đây .

— Howard
nguồn
2

J, 225

Vượt qua hai bài kiểm tra được đưa ra, nên hoạt động tối thiểu vài trăm chữ số.

c=:2 6$'   ||   (__)'
f=:(2{.[),('='#~2+6*#@]),2}.[
d=:'||',"1'  ||',~"1,"2&(c{~|:)
g=:('|\/|'&f,d&(1,.-.,.0,.])&(4&<),'|<>|'&f,d&(5($!.0"1)0,~"(1)1#~"0|~&5),|.&d&(5($!.0"1)1#~"0(5-5|])),'|/\|'&f)
4(1!:2)~LF,"1 g"."0}:(1!:1)3

Trước hết: Có, có, nghiêm trọng. Thứ hai: Điều đó thật dài. Ồ tốt Tôi vẫn chưa quyết định nên đánh golf thêm hay cuộn tròn trong tư thế của thai nhi và khóc. (Hoặc cả hai!)

Đây là một chút giải thích thay cho một chương trình ngắn hơn:

  • c là bảng 2x6 của ô trống, ô hạt để kết xuất.
  • f biểu diễn một hàng '=' với bốn ký tự bên ngoài làm đối số bên trái.
  • d kết xuất một hàng bàn tính bằng cách dịch các ma trận 0/1 thành các ô hạt được đệm bằng | |
  • g lấy các chữ số và biên dịch theo chiều dọc các hàng ký tự bằng cách sử dụng f cho các hàng 'định dạng' và d cho các hàng bàn tính.
  • Hàng cuối cùng được nhập, chia thành các ký tự và chuyển đổi chúng thành số, nguồn cấp dữ liệu thành g và sau đó in.
— Jesse Millikan
nguồn
2

C, 277 274 ký tự

Bạn biết đấy, dường như với tôi rằng chúng ta không có đủ giải pháp ở đây mà thực sự tận dụng lợi thế của bộ tiền xử lý C. Một phần là bởi vì những cái đó #definethực sự chiếm một chút không gian. Nhưng vẫn còn rất nhiều tiềm năng. Tôi cảm thấy cần phải giải quyết sự thiếu hụt này.

#define L(x,z)for(printf("|"x),p=b;*p||puts(#z)<0;++p)printf(
#define F(x,y,z)L(#x,==z|)"======",y);
#define T(y)L("|  ",||)*p-47 y?"(__)  ":" ||   ");
i;char*p,b[99];main(j){gets(b);F(\\,0,/)T()T(<6)T(<1)T(>5)F(<,*p>52?*p-=5:0,>)
for(;++i<6;)T(>i)for(;++j<7;)T(<j)F(/,0,\\)}

Cái đó tốt hơn.

— hộp bánh
nguồn
2

Toán học 281

w@n_:= Module[{t=Table,f,g},
 f@d_:=ReplacePart["O"~t~{7},{2-Quotient[d,5]-> "|",3+Mod[d,5]-> "|"}];
 g@k_:=IntegerDigits@n~PadLeft~10;
 Grid[Insert[Insert[(f/@g@n)T,"=="~t~{10},{{1},{3},{8}}]T,""~t~{10},{{1},{11}}]T]]

Thí dụ

w[6302715408]

bàn tính

— DavidC
nguồn
Chúc mừng 10k! :-D
— Doorknob
@Doorknob. Cảm ơn! Chúc mừng bạn!
— DavidC
1

C, 548

#define p(a) printf(a);
#define F(x,m) for(x=0;x<m;x++)
#define I(x) {p("||")F(j,l)if(b[l*(i+x)+j]){p("  (__)")}else{p("   || ")}p("  ||\n")}
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main(int a,char* c[]){int i,j,l,m,*b;l=strlen(c[1]);b=(int*)malloc(l*56);m=6*l;F(i,14*l)b[i]=0;
F(j,l){b[j]=1;if(c[1][j]<53){b[l+j]=1;}else{b[3*l+j]=1;c[1][j]-=5;}F(i,5){if(i<c[1][j]-'0'){
b[(i+5)*l+j]=1;}else{b[(i+9)*l+j]=1;}}}p("|\\=")F(i,m)p("=")p("=/|\n")F(i,4)I(0)p("|<=")F(i,m)
p("=")p("=>|\n")F(i,9)I(5)p("|/=")F(i,m)p("=")p("=\\|\n")}

Phiên bản đầu tiên, chỉ là một chút của golf cho đến nay.

— schnaader
nguồn
1

Scala (489 ký tự)

def a(i:String){val b=" (__) ";val n="  ||  ";1 to 17 map{l=>;{print(l match{case 1=>"|\\=";case 6=>"|<=";case 17=>"|/=";case _=>"|| "});print(l match{case 1|6|17=>"======"*i.size;case 2|16=>b*i.size;case 4|11=>n*i.size;case 3=>i flatMap{d=>{if(d.asDigit<5)b else n}};case 5=>i flatMap{d=>{if(d.asDigit>4)b else n}};case _=>i flatMap{d=>{if(l<11)if(d.asDigit%5<l-6)n else b else if(d.asDigit%5>l-12)n else b}}});;print(l match{case 1=>"=/|";case 6=>"=>|";case 17=>"=\\|";case _=>" ||"})}}}

Nỗ lực khá nhảm nhí thực sự.

— Gareth
nguồn
1

Sclipting , 77 ký tự

Tiền thưởng đề cập đến các tweet và Twitter đếm các ký tự (không phải byte). :)

꿓뤽꿓뤽①長復標독렽꿐②껷렊밃겠上❶가侔是丟돃렽꿐②꿧렊不돇렠글⓶①各❷❷걐剩減갰減갰分❸⓷걀大加增增감右與꺅뭟꺒갠⓵긇롼긂갠嗎⓶終丟돇렊終終돂묽꿐②뇇렊

Tôi thực sự đã viết cách đây nhiều năm (khi thử thách này được đăng), nhưng tôi chưa bao giờ đăng nó vì tôi đã phát minh ra Sclipting sau khi thử thách này được đăng lần đầu tiên. Nếu bạn cảm thấy rằng điều này làm cho nó không đủ điều kiện, tôi hiểu.

Giải trình

꿓뤽꿓뤽①長復 | let x = "======" times the length of the input string
標 | mark
독렽꿐②껷렊 | "|\\==" + x + "/|\n"
밃겠上 | for row in [-4 .. 10]
    ❶가侔是 | if row == 0
        丟돃렽꿐②꿧렊 | "|<==" + x + ">|\n"
    不 | else
        돇렠글 | "||  "
        ⓶①各 | foreach char c in input
            | ((r-(c%5)-3)/3 & ((r + (c>4?3:2)) >> 1)) ? "(__) " : " ||   "
            ❷❷걐剩減갰減갰分❸⓷걀大加增增감右與꺅뭟꺒갠⓵긇롼긂갠嗎⓶
        終丟
        돇렊 | "||\n"
    終
終
돂묽꿐②뇇렊 | "|/==" + x + "\\|\n"
— Timwi
nguồn
Cảm ơn câu trả lời thú vị của bạn. Tôi đồng ý rằng tốt nhất là tuân theo quy tắc rằng chỉ những ngôn ngữ được xuất bản trước câu hỏi được hỏi mới đủ điều kiện. Tôi không tin rằng bạn đã cố tình thiết kế ngôn ngữ của mình để chiến thắng thử thách này, nhưng đồng thời tôi không nghĩ nó công bằng với những người trả lời khác, và chúng tôi không muốn mở lũ cho những ngôn ngữ mới được phát minh trên cũ câu hỏi vì chúng tôi biết điều gì sẽ xảy ra ...
— gnibbler
@gnibbler: Chắc chắn, tôi ổn với điều đó. Tôi nghĩ rằng quy tắc này là một trong những quan trọng.
— Timwi
1

Con trăn 309 301 288 ký tự

Phiên bản nhỏ gọn:

q=p,b="  ||  "," (__) "
t="|| %s ||\n"
a=lambda h:t%"".join(q[i]for i in h)
n=[int(d)for d in str(input())]
c=len(n)
e="="*(c*6+2)
h="|\\"+e+"/|"
print h+"\n"+t%(b*c)+a(d<5 for d in n)+t%(p*c)+a(d>4 for d in n)+"|<"+e+">|\n"+"".join(a((d%5>i%5)^(i>4)for d in n)for i in range(10))+h[::-1]

Xóa phiên bản:

bead = " (__) "
pole = "  ||  "
template = "|| %s ||\n"
output = ""
def addline(hasbeads):
    global output
    output += template % "".join([bead if item else pole for item in hasbeads])

digits = [int(d) for d in str(input())]
count = len(digits)
equalsigns = "=" * (count * 6 + 2)
output = ""
header = "|\\" + equalsigns + "/|"
output += header + "\n"
output += template % (bead * count)
addline([d < 5 for d in digits])
output += template % (pole * count)
addline([d > 4 for d in digits])
output += "|<" + equalsigns + ">|\n"
for i in range(5):
    addline([d % 5 > i for d in digits])
for i in range(5):
    addline([d % 5 <= i for d in digits])
output += header[::-1]
print output

Lưu ý rằng để thu gọn, các biến được đổi tên thành một chữ cái và việc hiểu danh sách đã được thay đổi thành các trình tạo không yêu cầu thêm dấu ngoặc.

— Nayuki
nguồn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.