Die Herausforderung besteht darin, ein ASCII-Lineal für die Zeichenanzahl im folgenden Format zu generieren:

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

Die Länge des Lineals sollte auf ein Vielfaches von 10 skalierbar sein.

Regeln:

• Das Lineal muss horizontal sein.
• Nehmen wir zur Vereinfachung an, dass das Lineal bis zur 1000-Marke arbeiten muss, alle Zahlen linksbündig, ein Leerzeichen nach der endgültigen Zahl .
• Wenn Sie nach einem Lineal mit der Länge Null fragen, sollte NaR gedruckt werden
• Negative Zahlen sollten ein umgekehrtes Lineal (-90, -80, -70, ...) mit rechtsbündigen Zahlen im exakt gleichen Format wie oben drucken

Und nur auf die Konsole zu drucken ist in Ordnung

Fertig, fertig, Golf!

Python - 227 232

Unterstützt die gesamte Spezifikation

edit: verbesserter Generatorausdruck.

Die Unterstützung von rechtsbündigen negativen Zahlen fügt eine überraschende Menge an Code hinzu.

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]

Beispielausgaben:

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

Ich werde die dynamischen Sprachen heute nicht schlagen, aber trotzdem ...

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

Ich habe mir erlaubt, die tatsächlichen ASCII-Zeichen gegen besser aussehende Zeichen für das Zeichnen von Unicode-Boxen auszutauschen.

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

Python 2.7, 342 266 260 Zeichen

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

Gibt ein Tupel jeder Zeilenzeichenfolge zurück, das Sie dann drucken oder in einer Datei speichern können (ich bevorzuge letzteres für Längen von mehr als 70, da die Konsole sie nur mit dem Umbruch durcheinander bringt).

Angenommen y, es handelt sich um eine Zeichenfolge (raw_input () n python oder sys.argv [1], wenn Sie über cmd aufrufen möchten), eine Ganzzahl (z. B. mit input () in 2.x oder int (input ()) in 3.x. )

Ich habe dies zu einer Funktion gemacht, um flexibler zu sein

Bearbeiten: auf 266 Zeichen reduziert. gibt nicht mehr ein Tupel zurück, sondern eine Zeichenfolge. Nimmt jetzt eine Ganzzahl anstelle einer Zeichenfolge als Argument

edit2: reduziert auf 260 Zeichen, einzeilige Funktion

Hinweis: Behandelt negative Zahlen, rechtfertigt sie aber nicht richtig (ich glaube nicht, dass die Rechtfertigung sowieso zu wichtig ist

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]

Probieren Sie es online aus!

Weniger 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 Zeichen

Ein ziemlich einfacher Ansatz. Ich bin sicher, dass es ziemlich viel verbessert werden kann.
Ich habe versucht, den Richtlinien in den Kommentaren zu folgen, aber ich unterstütze keine negativen Zahlen (es war ein Witz, hoffe ich).
Dies ist ein Programm, das das Lineal auf Standardausgabe druckt. Wenn Ihr Bildschirm breit genug ist, sollte er ziemlich lange Lineale unterstützen.

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

Dies wird über die Windows-Konsole programmiert, daher habe ich nur eine maximale Linealgröße von 70 gewählt. Es stürzt nur für etwas Größeres ab. Negative Zahlen (bis zu -70) und 0 werden korrekt behandelt.

#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

(unterstützt keine rechtsbündigen negativen Zahlen)

 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"

Ich denke, mein Lieblingstrick war es, Zeichenfolgen zu generieren, die viel länger als nötig sind, und sie dann abzuschneiden, zum Beispiel:

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

Ich wünschte nur, es gäbe eine präzisere Option zur Formatierung von Zeichenfolgen für die Linksausrichtung (es sei denn, es gibt eine, von der ich einfach nichts weiß).

Perl 5,14, 198 224 Zeichen

Kann wahrscheinlich noch viel weiter verkürzt werden, aber hier ist ein erster zweiter Versuch (mit Zeilenumbrüchen zur besseren Lesbarkeit):

$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

BEARBEITEN: Bearbeitet, um mit "NaR" zu sterben, wenn die Eingabe erfolgt, 0und um den negativen Bereich zu unterstützen.

EDIT2: Ich hatte noch keine Gelegenheit, mehr daran zu arbeiten, und ich habe gerade erst bemerkt, dass die Regel für rechtsgerichtete negative Zahlen ausgerichtet ist, die mein Code nicht unterstützt. Daher denke ich, dass eine andere Lösung als Antwort markiert werden sollte, wenn die Frist wurde erreicht.