Le défi consiste à générer une règle de comptage de caractères ASCII au format suivant:

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

La longueur de la règle doit être évolutive à n'importe quel multiple de 10.

Règles:

• La règle doit être horizontale.
• Disons, pour simplifier les choses, que la règle doit fonctionner jusqu'à la marque 1000, tous les nombres alignés à gauche, un espace après le nombre final .
• Demander une règle de longueur nulle devrait afficher NaR
• Les nombres négatifs doivent imprimer une règle inversée (-90, -80, -70, ...) avec des nombres alignés à droite, dans le même format exact que celui ci-dessus sinon

Et, juste imprimer sur la console est très bien

Prêt, prêt, golf!

Python - 227 232

Prise en charge de toutes les spécifications

edit: expression du générateur améliorée.

La prise en charge des nombres négatifs alignés à droite ajoute une quantité surprenante de code.

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]

Exemples de sorties:

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

Je ne vais pas battre les langues dynamiques aujourd'hui, mais de toute façon ...

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

J'ai pris la liberté d'échanger les caractères ASCII réels avec des caractères de dessin de boîte Unicode plus beaux.

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

Python 2.7, 342 266 260 caractères

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

renvoie un tuple de chaque chaîne de ligne , que vous pouvez ensuite imprimer ou enregistrer dans un fichier (je préfère ce dernier pour des longueurs supérieures à 70 car la console le fera sembler foiré avec un habillage)

Suppose yêtre une chaîne (raw_input () n python ou sys.argv [1] si vous souhaitez invoquer via cmd) un entier (par exemple avec input () dans 2.x ou int (input ()) dans 3.x )

J'en ai fait une fonction pour être plus flexible

édition: réduit à 266 caractères. ne renvoie plus un tuple, mais une chaîne à la place. Prend maintenant un entier au lieu d'une chaîne comme argument

edit2: réduit à 260 caractères, fonction de ligne unique

note: gère les nombres négatifs, mais ne justifie pas correctement (je ne pense pas vraiment que la justification soit trop importante de toute façon

PowerShell , 256 253 233 225 222 octets

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]

Essayez-le en ligne!

Moins 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, 291 241 caractères

Une approche assez simple. Je suis sûr que cela peut être beaucoup amélioré.
J'ai essayé de suivre les directives dans les commentaires, mais je ne supporte pas les nombres négatifs (c'était une blague, j'espère).
Ceci est un programme, imprime la règle sur la sortie standard. Si votre écran est suffisamment large, il devrait prendre en charge des règles assez longues.

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

Ceci est programmé à l'aide de la console Windows, donc j'ai juste choisi une taille de règle maximale de 70, ça va juste planter pour quelque chose de plus grand. Les nombres négatifs (jusqu'à -70) et 0 sont traités correctement.

#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

(ne prend pas en charge les nombres négatifs alignés à droite)

 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"

Je pense que mon truc préféré était de générer des chaînes bien plus longues que nécessaire, puis de les tronquer, par exemple:

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

Je souhaite juste qu'il y ait une option de formatage de chaîne plus concise pour l'alignement à gauche (sauf s'il y en a une que je ne connais pas)

Perl 5.14, 198 224 caractères

Peut probablement être raccourci beaucoup plus loin, mais voici une première seconde tentative (avec des sauts de ligne insérés pour plus de lisibilité):

$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: édité pour mourir avec "NaR" lorsque l'entrée est 0et pour prendre en charge la plage négative.

EDIT2: Je n'ai pas eu l'occasion de travailler davantage sur ce sujet, et je viens de remarquer la règle alignée à droite pour les nombres négatifs, que mon code ne prend pas en charge, donc je pense qu'une autre solution devrait être marquée comme réponse si le la date limite a été atteinte.