ASCII शासक पीढ़ी

Question

निम्नलिखित प्रारूप में ASCII वर्ण गणना शासक उत्पन्न करने की चुनौती है:

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

शासक की लंबाई 10 में से किसी भी एक से अधिक होनी चाहिए।

नियम:

• शासक क्षैतिज होना चाहिए।
• मान लीजिए, चीजों को सरल रखने के लिए, कि शासक को 1000 अंक तक काम करना होगा, सभी संख्याएं बाएं-गठबंधन, अंतिम संख्या के बाद एक स्थान ।
• शून्य लंबाई वाले शासक के लिए पूछने पर NaR प्रिंट करना चाहिए
• ऋणात्मक संख्याओं को एक उल्टे शासक (-90, -80, -70, ...) को दाएं-संरेखित संख्याओं के साथ प्रिंट करना चाहिए, ठीक उसी प्रारूप में, जैसा कि ऊपर दिए गए प्रारूप में है।

और, केवल कंसोल पर प्रिंटिंग ठीक है

तैयार, सेट, गोल्फ!

Comments

शासक को बनाने के लिए कार्यक्रम कब तक पता चलता है? क्या यह एसटीडीआईएन पर एक नंबर के रूप में प्रदान किया गया है?

— PhiNotPi

हाँ, हमेशा की तरह मुझे लगता है!

— user2398029

क्या शासक को क्षैतिज या ऊर्ध्वाधर होना पड़ता है? यदि यह क्षैतिज है, तो क्या हम अधिकतम 80 वर्ण मान सकते हैं, या क्या हम इसकी बजाय रैपिंग से बचने के लिए फ़ाइल में आउटपुट करते हैं? या क्या हमें stdout लिखते समय कंसोल / टर्मिनल का आकार बदलना होगा?

— ब्लेज़र

कोड-गोल्फ के मुख्य बिंदुओं में से एक यह है कि समस्या को 100% स्पष्ट रूप से निर्दिष्ट किया जाना चाहिए ( faq देखें )। वास्तविक आउटपुट में रचनात्मकता के लिए बहुत कम जगह है, क्योंकि रचनात्मकता कोड में ही है। भविष्य में, कृपया प्रश्न पोस्ट करने से पहले इन सभी संभावित मामलों के माध्यम से सोचने की कोशिश करें, लेकिन जब से आप नए हैं, हम आपकी मदद कर रहे हैं :)

— mellamokb

क्या आप टिप्पणियों में निर्दिष्ट नियमों को शामिल करने की चुनौती को संपादित कर सकते हैं?

— flesk

Answer 1

पायथन - 227 232

पूरे विनिर्देशन का समर्थन करता है

संपादित करें: बेहतर जनरेटर अभिव्यक्ति।

सही संरेखित ऋणात्मक संख्याओं का समर्थन करना कोड की एक आश्चर्यजनक राशि जोड़ता है।

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]

नमूना आउटपुट:

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

Answer 2

आज गतिशील भाषाओं को हरा नहीं है, लेकिन वैसे भी ...

हास्केल, 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

मैंने वास्तविक एएससीआईआई पात्रों को बेहतर दिखने वाले यूनिकोड बॉक्स ड्राइंग चार्ट के साथ आदान-प्रदान करने की स्वतंत्रता ली।

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

Comments

शासक बहुत अच्छा लग रहा है, बहुत अच्छा है।

— user2398029

Answer 3

पायथन 2.7, 342 266 260 चार्ट

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

प्रत्येक पंक्ति स्ट्रिंग का एक टपल देता है , जिसे आप तब फ़ाइल में प्रिंट या सेव कर सकते हैं (मैं 70 से अधिक समय तक उत्तरार्द्ध को प्राथमिकता देता हूं क्योंकि कंसोल जस्सट होगा जो इसे रैपिंग के साथ गड़बड़ कर देगा)

मान लिया गया yहो करने के लिए एक स्ट्रिंग (raw_input () n अजगर, या sys.argv [1] आप आह्वान के माध्यम से cmd करना चाहते हैं तो) एक पूर्णांक (जैसे इनपुट () 2.x या पूर्णांक में से (इनपुट ()) 3.x में )

मैंने इसे और अधिक लचीला बनाने के लिए एक समारोह बनाया

संपादित करें: 266 वर्णों तक घटाया गया। अब कोई टपल नहीं देता, बल्कि एक स्ट्रिंग देता है। अब तर्क के रूप में एक स्ट्रिंग के बजाय पूर्णांक लेता है

edit2: घटकर 260 वर्ण, एकल पंक्ति कार्य

ध्यान दें: नकारात्मक संख्याओं को संभालता है, लेकिन सही औचित्य नहीं करता है (मैं वास्तव में औचित्य का वर्णन नहीं करता हूं वैसे भी बहुत महत्वपूर्ण है

Comments

या बस एक गैर-लाइनब्रेकिंग कंसोल (जैसे टर्मिनेटर ) का उपयोग करें।

— चालू करना बंद कर दिया

@leftaroundabout मुझे यकीन नहीं था कि ऐसी चीज़ मौजूद है

— ब्लेज़र

इसकी परवाह किए बिना, एक शासक बनाने के लिए एक अलग प्लेटफ़ॉर्म स्थापित करने के लिए, निरर्थक प्रतीत होता है, जहाँ-जहाँ वापसी मूल्य का निर्माण होता है, जिसे कोई भी उपयोग कर सकता है (किसी फ़ाइल पर लिख सकता है, आदि) अधिक सार्वभौमिक है

— ब्लेज़र

@ ब्लेज़र, क्या आपके शेल में पाइप और रीडायरेक्ट नहीं हैं?

— पीटर टेलर

Answer 4

पॉवरशेल , 256 253 233 225 222 बाइट्स

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]

इसे ऑनलाइन आज़माएं!

कम गोल्फ वाला:

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]

Answer 5

पायथन, 291 241 वर्ण

एक बहुत ही सरल दृष्टिकोण। मुझे यकीन है कि इसमें काफी सुधार किया जा सकता है।
मैंने टिप्पणियों में दिशानिर्देशों का पालन करने की कोशिश की, लेकिन मैं नकारात्मक संख्याओं का समर्थन नहीं करता (यह एक मजाक था, मुझे उम्मीद है)।
यह एक कार्यक्रम है, शासक को मानक उत्पादन में प्रिंट करता है। यदि आपकी स्क्रीन पर्याप्त चौड़ी है, तो उसे बहुत लंबे शासकों का समर्थन करना चाहिए।

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"

Comments

आप यहां से कुछ और पात्रों को निकाल सकते हैं जिन्हें मैंने यहां 12 पात्रों

— गॉर्डन बैली

धन्यवाद @GordonBailey, लेकिन वैसे भी पहले से ही एक विजेता है, जो मेरे कोड से छोटा है और पूर्ण विनिर्देश का समर्थन करता है।

— बदसूरत

Answer 6

सी ++, 392

यह विंडोज़ कंसोल का उपयोग करके क्रमादेशित है, इसलिए मैंने सिर्फ एक अधिकतम शासक का आकार 70 चुना है, यह सिर्फ किसी भी बड़ी चीज के लिए दुर्घटनाग्रस्त हो जाएगा। नकारात्मक संख्या (-70 तक) और 0 को सही तरीके से संभाला जाता है।

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

Answer 7

अजगर - 208

(सही संरेखित ऋणात्मक संख्याओं का समर्थन नहीं करता है)

 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"

मुझे लगता है कि मेरी पसंदीदा तरकीब यह थी कि वे तार पैदा करें जो कि ज़रूरत से ज़्यादा लंबे हों और फिर उन्हें काटें, उदाहरण के लिए:

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

मेरी इच्छा है कि वाम-संरेखण के लिए एक अधिक संक्षिप्त स्ट्रिंग प्रारूपण विकल्प था (जब तक कि कोई ऐसा न हो जिसके बारे में मुझे जानकारी नहीं है)

Answer 8

पर्ल 5.14, 198 224 चार्ट

संभवत: इसे बहुत आगे बढ़ाया जा सकता है, लेकिन यहां पहला दूसरा प्रयास (पठनीयता के लिए लाइन ब्रेक के साथ डाला गया है):

$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

संपादित करें: जब इनपुट होता है 0और नकारात्मक सीमा का समर्थन करने के लिए "NaR" के साथ मरने का संपादन किया जाता है ।

EDIT2: मुझे इस पर और अधिक काम करने का मौका नहीं मिला है, और मैंने केवल अब नकारात्मक संख्या नियम के लिए सही संरेखित देखा है, जो मेरा कोड समर्थन नहीं करता है, इसलिए मुझे लगता है कि एक और समाधान को उत्तर के रूप में चिह्नित किया जाना चाहिए समय सीमा समाप्त हो गई है।

Comments

@ साहित्य: मेरा उत्तर सभी नियमों के अनुरूप नहीं है। यदि संभव हो तो एक और उत्तर चुना जाना चाहिए।

— flesk