El desafío es generar una regla de recuento de caracteres ASCII en el siguiente formato:

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

La longitud de la regla debe ser escalable a cualquier múltiplo de 10.

Reglas:

• La regla debe ser horizontal.
• Digamos, para simplificar las cosas, que la regla debe funcionar hasta la marca 1000, todos los números alineados a la izquierda, un espacio después del número final .
• Pedir una regla con longitud cero debería imprimir NaR
• Los números negativos deben imprimir una regla invertida (-90, -80, -70, ...) con números alineados a la derecha, exactamente en el mismo formato que el anterior, de lo contrario

Y, solo imprimir en la consola está bien

Listo, listo, golf!

Python - 227 232

Admite especificaciones completas

editar: expresión del generador mejorada.

La compatibilidad con números negativos alineados a la derecha agrega una sorprendente cantidad de código.

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]

Resultados de muestra:

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

No voy a vencer a los lenguajes dinámicos hoy, pero de todos modos ...

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

Me tomé la libertad de intercambiar los caracteres ASCII reales con caracteres de dibujo de caja Unicode más atractivos.

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

Python 2.7, 342 266 260 caracteres

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

devuelve una tupla de cada cadena de línea , que luego puede imprimir o guardar en un archivo (prefiero el último para longitudes superiores a 70 porque la consola solo hará que se vea desordenada con el ajuste)

Se supone yque es una cadena (raw_input () n python o sys.argv [1] si desea invocar a través de cmd) un número entero (por ejemplo, con input () en 2.xo int (input ()) en 3.x )

Hice de esto una función para ser más flexible

editar: reducido a 266 caracteres. ya no devuelve una tupla, sino una cadena. Ahora toma un entero en lugar de una cadena como argumento

edit2: reducido a 260 caracteres, función de línea única

nota: maneja números negativos, pero no justifica correctamente (realmente no creo que la justificación sea demasiado importante de todos modos

PowerShell , 256 253 233 225 222 bytes

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]

Pruébalo en línea!

Menos golfizado:

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 caracteres

Un enfoque bastante simple. Estoy seguro de que se puede mejorar bastante.
Traté de seguir las pautas en los comentarios, pero no apoyo los números negativos (espero que sea una broma).
Este es un programa, imprime la regla a la salida estándar. Si su pantalla es lo suficientemente ancha, debería admitir reglas bastante largas.

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

Esto se programa utilizando la consola de Windows, por lo tanto, solo elegí un tamaño de regla máximo de 70, simplemente se bloqueará por algo más grande. Los números negativos (hasta -70) y 0 se manejan correctamente.

#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

(no admite números negativos alineados a la derecha)

 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"

Creo que mi truco favorito era generar cadenas que son mucho más largas de lo necesario y luego truncarlas, por ejemplo:

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

Solo desearía que hubiera una opción de formato de cadena más concisa para la alineación a la izquierda (a menos que haya una que simplemente no conozca)

Perl 5.14, 198 224 caracteres

Probablemente se puede acortar mucho más, pero aquí hay un primer segundo intento (con saltos de línea insertados para facilitar la lectura):

$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

EDITAR: Editado para morir con "NaR" cuando la entrada es 0y para admitir el rango negativo.

EDIT2: No he tenido la oportunidad de trabajar más en esto, y solo ahora noté la regla alineada a la derecha para números negativos, que mi código no admite, por lo que creo que otra solución debería marcarse como la respuesta si el Se ha alcanzado la fecha límite.