Zorluk şu biçimde bir ASCII karakter sayısı cetveli oluşturmaktır:

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

Cetvelin uzunluğu 10'un katlarıyla ölçeklenebilir olmalıdır.

Kurallar:

• Cetvel yatay olmalıdır.
• Diyelim ki, işleri daha basit tutmak için, cetvel 1000 numarasına kadar, tüm numaralar sola hizalanmış, son numaradan bir boşluk sonra çalışmalıdır .
• Sıfır uzunlukta bir cetvel istemek NaR yazmalıdır
• Negatif sayılar, sağa hizalanmış sayılarla ters çevrilmiş bir cetvel (-90, -80, -70, ...), aksi takdirde yukarıdakiyle aynı biçimde yazdırmalıdır.

Ve sadece konsola yazdırmak iyi

Hazır, hazır, golf!

Python - 227 232

Tüm özellikleri destekler

edit: geliştirilmiş jeneratör ifadesi.

Sağa hizalanmış negatif sayıları desteklemek şaşırtıcı miktarda kod ekler.

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]

Örnek çıktılar:

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

Bugün dinamik dilleri yenmeyecek, ama yine de ...

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

Gerçek ASCII karakterlerini daha iyi görünen unicode kutu çizim karakterleriyle değiştirme özgürlüğünü aldım.

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

Python 2.7, 342266 260 karakter

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

daha sonra bir dosyaya yazdırabileceğiniz veya kaydedebileceğiniz her satır dizesinin bir demetini döndürür (Konsolun sarma ile karışmasını sağlamak için 70'ten daha uzun uzunluklar için ikincisini tercih ederim)

Devraldı y olmak bir dize (raw_input () n piton veya sys.argv [1] çağırmak yoluyla cmd isterseniz) 3.x bir tamsayı (örn 2.x veya int girdi () ile (giriş ()) )

Bunu daha esnek bir işlev haline getirdim

düzenleme: 266 karaktere düşürüldü. artık bir demet değil, bunun yerine bir dize döndürür. Şimdi bağımsız değişken olarak dize yerine bir tam sayı alır

edit2: 260 karaktere düşürüldü, tek satır işlevi

not: negatif sayıları ele alır, ancak haklı değil

PowerShell , 256 253 233 225 222 bayt

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]

Çevrimiçi deneyin!

Daha az golf:

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]

Python, 291241 karakter

Oldukça basit bir yaklaşım. Eminim oldukça geliştirilebilir.
Yorumlardaki yönergeleri izlemeye çalıştım, ancak negatif sayıları desteklemiyorum (umarım bir şakaydı).
Bu bir programdır, cetveli standart çıktıya yazdırır. Ekranınız yeterince genişse, oldukça uzun cetvelleri desteklemelidir.

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

Bu, Windows konsolu kullanılarak programlanmıştır, bu yüzden sadece maksimum cetvel boyutunu 70 olarak seçtim, sadece daha büyük bir şey için çökecek. Negatif sayılar (-70'e kadar) ve 0 doğru şekilde işlenir.

#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]);}

Python - 208

(sağa hizalanmış negatif sayıları desteklemez)

 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"

Benim en sevdiğim hile gereğinden çok daha uzun dizeler oluşturmak ve sonra onları kısaltmak olduğunu düşünüyorum, örneğin:

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

Sadece sola hizalama için daha özlü bir dize biçimlendirme seçeneği olsaydı (sadece bilmediğim bir tane yoksa)

Perl 5.14, 198 224 karakter

Muhtemelen çok daha kısaltılabilir, ancak burada ilk bir deneme (okunabilirlik için satır kesmeleri eklenmiş olarak):

$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: Giriş olduğunda "NaR" ile ölmek 0ve negatif aralığı desteklemek için düzenlenmiştir.

EDIT2: Bu konuda daha fazla çalışma şansı olmadı ve sadece şimdi kodumu desteklemeyen negatif sayılar kuralı için doğru hizalanmış fark ettim, bu yüzden eğer başka bir çözüm cevap olarak işaretlenmelidir. son teslim tarihine ulaşıldı.