Thách thức là tạo ra một thước đo đếm ký tự ASCII theo định dạng sau:

+-------------------------------------------------------------------------+
||    |    |    |    |    |    |    |    |    |    |    |    |    |    |  |
|0         10        20        30        40        50        60        70 |
|                                                                         |
+-------------------------------------------------------------------------+

Độ dài của thước nên có thể mở rộng theo bất kỳ bội số nào của 10.

Quy tắc:

• Thước phải nằm ngang.
• Giả sử, để đơn giản hơn, thước đo phải hoạt động cho đến 1000 điểm, tất cả các số được căn trái, một khoảng trắng sau số cuối cùng .
• Yêu cầu thước có độ dài bằng 0 nên in NaR
• Các số âm nên in một thước kẻ đảo ngược (-90, -80, -70, ...) với các số được căn phải, theo định dạng chính xác như ở trên

Và, chỉ cần in ra bàn điều khiển là ổn

Sẵn sàng, thiết lập, golf!

Con trăn - 227 232

Hỗ trợ toàn bộ đặc điểm kỹ thuật

chỉnh sửa: cải thiện biểu thức máy phát điện.

Hỗ trợ các số âm được căn chỉnh đúng sẽ thêm một lượng mã đáng ngạc nhiên.

b,p,d,w,='|+- '
g=input
s=''.join(('%'+d[:i>0]+'10s')%i+['',9*w][i==0] for i in range(g(),g()+1,10)).strip()+w
m,n=s[0]==d and s.find(w)-1,len(s)
t=p+n*d+p
print['\n'.join([t,b+(w*m+'|    '*n)[:n]+b,b+s+b,b+n*w+b,t]),'NaR'][n<9]

Đầu ra mẫu:

-30 30

+-----------------------------------------------------------------+
|  |    |    |    |    |    |    |    |    |    |    |    |    |  |
|-30       -20       -10         0         10        20        30 |
|                                                                 |
+-----------------------------------------------------------------+

-30 -30

NaR

100 150

+------------------------------------------------------+
||    |    |    |    |    |    |    |    |    |    |   |
|100       110       120       130       140       150 |
|                                                      |
+------------------------------------------------------+

-1000 -950

+--------------------------------------------------------+
|    |    |    |    |    |    |    |    |    |    |    | |
|-1000      -990      -980      -970      -960      -950 |
|                                                        |
+--------------------------------------------------------+

Sẽ không đánh bại các ngôn ngữ năng động ngày hôm nay, nhưng dù sao ...

Haskell, 341

import Data.List
main=interact$unlines.m.map read.words
m[l,r]|r>l=ᴛ.("┌│││└":).(++["┬   ─","┐│││┘"]).ʀ.t.ʀ.t.takeWhile((>4).length).ᴛ$[c"┬",c"│    ",[l,l+10..r]>>=h.show,c" ",c"─"]|True=["NaR"]
h s=p s$length s;p s@('-':_)l=r(6-l)ꜱ++s++r 4ꜱ;p s l=r 5ꜱ++s++r(5-l)ꜱ
ᴛ=transpose;ʀ=reverse;r=replicate;c=cycle
ꜱ=' ';t l@(c:o)|c!!2==ꜱ=t o|True=l

Tôi đã tự do trao đổi các ký tự ASCII thực tế với các ký tự vẽ hộp unicode trông đẹp hơn.

$ echo "-50 30" | runhaskell  def0.hs
┌┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┐
│  │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │  │
│-50       -40       -30       -20       -10         0         10        20        30 │
│                                                                                     │
└─────────────────────────────────────────────────────────────────────────────────────┘

Python 2.7, 342 266 260 ký tự

a,b,c,d,m='+|- \n'
def f(y):x=map(str,(range(0,y+1,10)if y>0 else range(y,1,10)));h,g=len(x[-1])+1,len(x)-1;u=a+(c*10)*g+c*h+a;return'NaR'if y==0 else u+m+b+(b+d*4)*2*g+b+d*(h-1)+b+m+b+''.join(i.ljust(10)for i in x[:-1])+x[-1].ljust(h)+b+m+b+(d*10)*g+d*h+b+m+u

trả về một tuple của mỗi chuỗi dòng , sau đó bạn có thể in hoặc lưu vào một tệp (tôi thích cái sau dài hơn 70 bởi vì giao diện điều khiển sẽ làm cho nó trông rối tung khi gói)

Giả sử ylà một chuỗi (raw_input () n python hoặc sys.argv [1] nếu bạn muốn gọi qua cmd) một số nguyên (ví dụ: với input () trong 2.x hoặc int (input ()) trong 3.x )

Tôi đã thực hiện điều này một chức năng để linh hoạt hơn

chỉnh sửa: giảm xuống còn 266 ký tự. không còn trả về một tuple, mà thay vào đó là một chuỗi. Bây giờ lấy một số nguyên thay vì một chuỗi làm đối số

chỉnh sửa2: giảm xuống 260 ký tự, chức năng dòng đơn

lưu ý: không xử lý số âm, nhưng không chính đáng (tôi thực sự không hiểu rằng biện minh là quá quan trọng

PowerShell , 256 253 233 225 222 byte

param($a,$b)('NaR',$($d=@{}
$a..$b|%{$d.$_=' ';0..($l=($s="$($_-$_%10)").Length-1)|%{$d[$_+$s-$l*(0-gt$s)]=$s[$_]}}
$d.Keys|sort|%{$e+='-';$p+='|    '[$_%5];$r+=$d.$_;$w+=' '}
@"
+$e-+
|$p |
|$r |
|$w |
+$e-+
"@))[$a-lt$b]

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

Ít chơi gôn hơn:

param($a,$b)
(
    'NaR',
    $(
        # {key, value} := {position, digit|minus|space}
        $d=@{}
        $a..$b|%{
            $d.$_=' '

            # draw a nearest left number
            $n=$_-$_%10
            $s="$n"
            $l=$s.Length-1
            0..$l|%{
                $d[$_+$s-$l*(0-gt$s)]=$s[$_]
            }
        }

        # edge, points, ruler, whitespaces
        $d.Keys|sort|%{
            $e+='-'
            $p+='|    '[$_%5]
            $r+=$d.$_
            $w+=' '
        }

        # output the multiline string
@"
+$e-+
|$p |
|$r |
|$w |
+$e-+
"@
    )
)[$a-lt$b]

Con trăn, 291 241 ký tự

Một cách tiếp cận khá đơn giản. Tôi chắc chắn rằng nó có thể được cải thiện khá nhiều.
Tôi đã cố gắng làm theo các hướng dẫn trong các bình luận, nhưng tôi không ủng hộ các số âm (đó là một trò đùa, tôi hy vọng).
Đây là một chương trình, in thước đo thành đầu ra tiêu chuẩn. Nếu màn hình của bạn đủ rộng, nó sẽ hỗ trợ các thước kẻ khá dài.

import sys
def p(b,a="|"):print a+b+a
j="".join
l=int(sys.argv[1])//10*10
if l:
    d=j(["%-10d"%n for n in range(0,l,10)])+"%d "%l
    L=len(d)
    h="-"*L
    p(h,"+")
    p(j(["|    "[n%5] for n in range(L)]))
    p(d)
    p(" "*L)
    p(h,"+")
else: print "NaR"

C ++, 392

Điều này được lập trình bằng bảng điều khiển windows, do đó tôi chỉ chọn kích thước thước tối đa là 70, nó sẽ bị sập cho bất cứ thứ gì lớn hơn. Số âm (tối đa -70) và 0 được xử lý chính xác.

#include<ios>
#define q s[2][i
#define v ,memset(&s
char g,o,i,n,s[5][80];int main(int a,char**b){a=atoi(b[1])v,32,400);n=0<a;for(a=abs(a)v[0][1],45,a+3)v[4][1],45,a+3);i<a+4;++i)o=i-n,!(o%5)?s[1][n?i:i+3]='|',(o%2-1?(n?q]=i/10+48,i>9?q+1]=48:0:((a-i)>9?q+2]=(a-i)/10+48,q+1]=45:0,q+3]=48)):0):0;for(;g-5;g++)for(s[g][a+4]=s[g][i=0]=g&g-4?'|':43;i-80;i++)printf(a?"%c":g+i?"":"NaR",s[g][i]);}

Con trăn - 208

(không hỗ trợ các số âm được căn phải)

 l,u=map(int,raw_input().split())
 n=u-l
 q="+%s+\n"
 q=q+"|%s|\n"*3+q
 print q%('-'*n,(''.join("|    "for i in range(n)))[:n],(''.join("{:<10d}".format(i)for i in range(l,u,10)))[:n],' '*n,'-'*n)if n>0 else"NaR"

Tôi nghĩ thủ thuật yêu thích của tôi là tạo ra các chuỗi dài hơn mức cần thiết và sau đó cắt ngắn chúng, ví dụ:

 ''.join("|    "for i in range(n)))[:n]

Tôi chỉ muốn có một tùy chọn định dạng chuỗi ngắn gọn hơn cho căn lề trái (trừ khi có một tùy chọn mà tôi không biết)

Perl 5.14, 198 224 ký tự

Có thể rút ngắn hơn nữa, nhưng đây là lần thử thứ hai đầu tiên (có ngắt dòng được chèn để dễ đọc):

$l=shift||die"NaR\n";
@n=grep!($_%10),$l>0?0..$l:$l..0;
$l=9-length$n[$#n];
@f=('-'x10,'|    'x2,'@'.'<'x9,' 'x10);
@f=map$_ x@n,@f;
map$_=~s/.{$l}$//,@f;
eval"format=\n+$f[0]+\n|$f[1]|\n|$f[2]|\n\@n\n|$f[3]|\n+$f[0]+\n.\n";
write

EDIT: Được chỉnh sửa để chết với "NaR" khi đầu vào là 0và để hỗ trợ phạm vi âm.

EDIT2: Tôi chưa có cơ hội làm việc nhiều hơn về vấn đề này và tôi chỉ mới nhận thấy đúng quy tắc số âm, mà mã của tôi không hỗ trợ, vì vậy tôi nghĩ một giải pháp khác nên được đánh dấu là câu trả lời nếu thời hạn đã đạt được.