मुझे एक QFP चिप उत्पन्न करें!

Question

मुझे एक QFP चिप उत्पन्न करें!

सैंडबॉक्स से!

क्यूएफपी एक विद्युत घटक के लिए एक प्रकार का कारक है जहां पिंस एक चिप के किनारों से निकलते हैं। यहाँ एक ठेठ QFP घटक की एक तस्वीर है:

^{आप देख सकते हैं कि सामान्य सूत्र में समान संख्या में पिन के 4 पक्ष हैं।}

आपकी चुनौती एक पूर्णांक में होने वाले प्रोग्राम को बनाना है, जो कि एक तरफ पिन की संख्या का प्रतिनिधित्व करता है, और गिने पिन के साथ एक ASCII QFP घटक बनाता है।

इनपुट:

एक पूर्णांक जो एक तरफ पिन की संख्या का प्रतिनिधित्व करता है

आउटपुट:

एक उपयुक्त पिनआउट के साथ एक ASCII QFP चिप।

उदाहरण:

इनपुट: 1

  4
 ┌┴┐
1। ├3
 └┬┘
  2

इनपुट: 2

  87
 ┌┴┴┐
1। ├6
2 ├5
 └┬┬┘
  34

इनपुट: 12

   444444444333
   876543210987
  ┌┴┴┴┴┴┴┴┴┴┴┴┴┐
 1। ├36
 2 ├35
 3 ├34
 4 ├33
 5 ├32
 6 ├31
 7 ├30
 8 ├29
 9 ├28
10 ├27
11 ├26
12 ├25
  └┬┬┬┬┬┬┬┬┬┬┬┬┘
   111111122222
   345678901234

नियम:

• सभी QFP चिप्स संलग्न किए जाने चाहिए और साथ ही साथ एएससीआई प्रदान करना चाहिए। रिक्ति का अत्यधिक महत्व है। माइक्रोप्रोसेसर के अंदर धूल खराब सामान है!
• पिन नंबरिंग को उदाहरणों के रूप में किया जाना चाहिए (पढ़ें बाएं से दाएं, ऊपर से नीचे, गिने काउंटर पर दक्षिणावर्त)
• आप 0 पर नंबर देना शुरू कर सकते हैं, लेकिन यह चिप को प्रभावित नहीं करना चाहिए (12 के इनपुट को अभी भी 12 पिन प्रति साइड चाहिए)
• आपके आउटपुट में एकमात्र मान्य वर्ण हैं 1,2,3,4,5,6,7,8,9,0,┌,┴,┐,├,┘,┬,└,┤, रिक्त स्थान, और newlines।
• भाषाओं के लिए सभी एन्कोडिंग की अनुमति है, लेकिन आपका आउटपुट उपरोक्त नियमों के अनुरूप होना चाहिए।

यह एक कोडगॉल्फ है, और इस तरह, बाइट्स की कम से कम संख्या के साथ कोड जीतता है! शुभ लाभ!

Comments

क्या शून्य को संभालने की आवश्यकता है।

— मैजिक ऑक्टोपस Urn

नहीं तुम नहीं।

— tuskiomi

इनपुट पर कोई ऊपरी सीमा?

— अरनौलड

@ अरनल्ड में केवल सीमाएं अधिक होनी चाहिए और भाषा-आधारित सीमाएं

— tuskiomi

"सभी QFP चिप्स को संलग्न किया जाना चाहिए और साथ ही साथ एससीआई प्रदान करना चाहिए।" दिए गए वर्णों में से आधे ASCII नहीं हैं।

— जॉर्डन

Answer 1

गणितज्ञ, 271 बाइट्स

c=Table;d=StringPadLeft[#<>"\n",(b=IntegerLength[4a])+a+2]&/@(#)&;d@Reverse@#4<>{e=" "~c~b,"┌"<>"┴"~c~a,"┐
",({#,"┤"," "~c~a,"├",#2,"
"}&)~MapThread~{#,Reverse@#3},e,"└","┬"~c~a,"┘
",d@#2}&@@Partition[Characters@StringPadLeft[ToString/@Range[4#]],a=#]&

अनाम फ़ंक्शन। इनपुट के रूप में एक संख्या लेता है और आउटपुट के रूप में एक स्ट्रिंग लौटाता है। गैर-बॉक्स-ड्राइंग यूनिकोड चरित्र U + F3C7 (निजी उपयोग) के लिए है \[Transpose]।

Answer 2

Kotlin , 397 393 बाइट्स

लंबोदर।

आप इसे आज़मा सकते हैं यहाँ हैं , लेकिन आपको अपने आप में स्रोत को पेस्ट करना होगा क्योंकि संपादक UTF-8 एन्कोडिंग में प्रोग्राम को सहेजता नहीं दिखता है। अनगोल्डेड संस्करण एक पूर्ण कार्यक्रम है, इसलिए आपको इसका पूरी तरह से उपयोग करने में सक्षम होना चाहिए।

golfed

{n:Int->operator fun String.mod(x:Int){(1..x).map{print(this)}};val l={s:String->s.padStart(n/10+2)};var s=(1..n).map{"${n*4+1-it}".reversed()};val z={i:Int->l(" ")%1;s.map{print(it.getOrElse(i,{' '}))};"\n"%1};(s[0].length-1 downTo 0).map(z);l("┌")%1;"┴"%n;"┐\n"%1;(1..n).map{l("$it┤")%1;" "%n;"├${n*3+1-it}\n"%1};l("└")%1;"┬"%n;"┘\n"%1;s=(1..n).map{"${n+it}"};(0..s.last().length-1).map(z)}

(छाँटकर) अनगढ़

fun main(args: Array<String>) {
    var q = { n: Int ->
        operator fun String.mod(x: Int) {
            (1..x).map { print(this) }
        }

        val l = { s: String ->
            s.padStart(n / 10 + 2)
        }

        var s = (1..n).map { "${n * 4 + 1 - it}".reversed() }

        val z = { i: Int ->
            l(" ")%1
            s.map { print(it.getOrElse(i, { ' ' })) }
            "\n"%1
        }

        (s[0].length - 1 downTo 0).map(z)

        l("┌")%1
        "┴"%n
        "┐\n"%1

        (1..n).map { l("$it┤") % 1;" " % n;"├${n * 3 + 1 - it}\n" % 1 }

        l("└")%1
        "┬"%n
        "┘\n"%1

        s = (1..n).map { "${n + it}" }
        (0..s.last().length - 1).map(z)
    }

    q(30)
}

%ऑपरेटर को ओवरलोड करके और प्रिंट करने के लिए इसका उपयोग करके बाइट्स का एक गुच्छा बचाया । मैं शायद बाद में इस पर फिर से विचार करूंगा - मुझे लगता है कि यदि मैं उपयोग करता हूं modया किसी अन्य ऑपरेटर को कॉन्सेटेशन फ़ंक्शन के रूप में मैं काफी कुछ बाइट्स बचा सकता हूं । अधिक प्रक्षेप और कम प्रिंट कॉल।

Comments

ज़रूर, मुझे एक पूरा कार्यक्रम शामिल करने दें।

— टायलर मैकडोनेल

@tuskiomi आप अपनी संपूर्णता में अब अनगुल्ड संस्करण का उपयोग करने में सक्षम होना चाहिए।

— टायलर MacDonell

एक उत्कृष्ट समाधान!

— tuskiomi 15

Answer 3

अजगर 2, 352 343 331 बाइट्स

def q(n,j=''.join,k='\n'.join,m=map):a,b,c,d=zip(*[iter(m(str,range(n*4)))]*n);l=len(`n-1`);r=lambda x:k(m(lambda s:' '*(l+1)+j(s),m(j,[m(lambda t:t or' ',v)for v in m(None,*x)])));return k([r(d[::-1]),' '*l+u'┌'+u'┴'*n+u'┐',k(x.rjust(l)+u'┤'+' '*n+u'├'+y for x,y in zip(a,c[::-1])),' '*l+u'└'+u'┬'*n+u'┘',r(b)])

इसे यहाँ आज़माएँ। ध्यान दें कि फ़ाइल को \xef\xbb\xbfमानक CPython दुभाषिया में काम करने के लिए यूनिकोड शाब्दिकों के लिए UTF-8 BOM से शुरू होना चाहिए । ये 3 बाइट्स यहां आकार के खिलाफ गिने जाते हैं। repl.itपहले से ही यूनिकोड का उपयोग कर रहा है, इसलिए लिंक में केवल यहां दिखाया गया कोड है।

धन्यवाद एन्कोडिंग विचार के लिए @tuskiomi ने बचाया 9 21 बाइट्स।

आंशिक रूप से अपराजित:

def q(n):
  a,b,c,d = zip(*[iter(map(str,range(n*4)))]*n) # get numbers for sides
  l = len(`n-1`) # left padding
  r = lambda x: '\n'.join(
    map(lambda s: ' '*(l+1) + ''.join(s), # padding and row of digits
      map(''.join,
        [map(lambda t: t or ' ', v)  # rows of digits with spaces where missing
          for v in map(None, *x)]))
  )
  return '\n'.join([
    r(d[::-1]), # top row in reverse order
    ' '*l+u'\u250c'+u'\u2534'*n+u'\u2510', # top border
    # 1st, 3rd (reversed) side numbers
    '\n'.join(x.rjust(l) + u'\u2524'+ ' '*n + u'\u251c' + y for x,y in zip(a,c[::-1])),
     ' '*l+u'\u2514'+u'\u252c'*n+u'\u2518', # bottom border
    r(b) # bottom numbers
  ])

Comments

संगत, और तेज। आश्चर्यजनक!

— tuskiomi

अजीब। ऑनलाइन, यह पूरी तरह से प्रिंट करता है। हालाँकि, मेरे कंप्यूटर की आईडीएलई पर, यह कोड बिंदुओं के बजाय शाब्दिक रूप से प्रिंट करता है। अभी भी एक मान्य उत्तर है, लेकिन आप कोडपॉइंट्स के बजाय वास्तविक वर्णों का उपयोग करके इसे और नीचे ले जाने में सक्षम हो सकते हैं!

— tuskiomi

मैंने सोचा # -*- coding: utf-8 -*-कि दुभाषिया को स्वीकार करने के लिए मुझे शीर्ष पर एक नई रेखा की आवश्यकता होगी । उन वर्णों में से प्रत्येक का UTF-8 एन्कोडिंग 3 बाइट्स है, इसलिए एन्कोडिंग निर्देश की लागत के लिए भुगतान करना पर्याप्त नहीं था। मैंने अभी PEP 263 की जाँच की है और मैं बस #coding=utf-8और एक नई लाइन के साथ भाग सकता हूँ इसलिए यह कुछ बाइट्स को बचाएगा।

— जेक कोब

तीन-बाइट UTF-8 BOM जाहिरा तौर पर भी काम करता है।

— जेक कोब

Answer 4

जावास्क्रिप्ट (ईएस 6), 295 284 बाइट्स (268 चार्ट), गैर-प्रतिस्पर्धात्मक

n=>(a=[...(' '[r='repeat'](W=n+6)+`
`)[r](W++)],a.map((_,i)=>i<n*2&&([p,s,L,R,C]=i<n?[(i+3)*W-1,1,i+1,n*3-i,0]:[i-n+3-W,W,n*5-i,i+1,1],[...(' '+L).slice(-2)+'┤┴'[C]+' '[r](n)+'├┬'[C]+R].map(c=>a[p+=s]=c))),[2,3,W-4,W-3].map((p,i)=>a[W*p+2-6*(i&1)]='┌┐└┘'[i]),a.join``)

यह कोड 99 से ऊपर के पिन नंबरों का समर्थन नहीं करता है और इसलिए संभवतः पूरी तरह से वैध प्रविष्टि के रूप में योग्य नहीं है। इसलिए मैं इसे अब के लिए गैर-प्रतिस्पर्धा के रूप में चिह्नित करता हूं।

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

डेमो

let f =

n=>(a=[...(' '[r='repeat'](W=n+6)+`
`)[r](W++)],a.map((_,i)=>i<n*2&&([p,s,L,R,C]=i<n?[(i+3)*W-1,1,i+1,n*3-i,0]:[i-n+3-W,W,n*5-i,i+1,1],[...(' '+L).slice(-2)+'┤┴'[C]+' '[r](n)+'├┬'[C]+R].map(c=>a[p+=s]=c))),[2,3,W-4,W-3].map((p,i)=>a[W*p+2-6*(i&1)]='┌┐└┘'[i]),a.join``)

console.log(f(2))
console.log(f(4))
console.log(f(12))

Answer 5

जावा 11, 451 425 393 बाइट्स

n->{int d=(n+"").length(),i,j=-1,l=(int)Math.log10(n*4);String p=" ".repeat(d),P=p+" ",r=P;for(;j++<l;r+="\n"+(j<l?P:p))for(i=n*4;i>n*3;)r+=(i--+"").charAt(j);r+="┌"+"┴".repeat(n)+"┐\n";for(i=0;i<n;r+="├"+(n*3-i+++1)+"\n")r+=p.substring((i+"").length())+i+"┤"+" ".repeat(n);r+=p+"└"+"┬".repeat(i)+"┘\n"+P;for(j=-1;j++<l;r+="\n"+P)for(i=n;i<n*2;)r+=(++i+"").charAt(j);return r;}

-26 बाइट्स @ceilingcat की बदौलत ।

स्पष्टीकरण:

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

n->{                      // Method with integer parameter and String return-type
  int d=(n+"").length(),  //  The amount of digits of the input
      i,j=-1,             //  Index integers
      l=(int)Math.log10(n*4);
                          //  Amount of digits of 4x the input, minus 1
  String p=" ".repeat(d), //  Padding String for the corners, set to `d` amount of spaces
         P=x+" ",         //  Padding String for the numbers, set to one additional space
         r=P;             //  Result-String, starting at `P` to pad the number
  for(;j++<l;             //  Loop `j` in the range (-1, l]:
      ;                   //    After every iteration:
       r+="\n"            //     Append a new-line, and padding spaces:
       +(j<l?P:p))        //      `p` if it's the last iteration; `P` otherwise
    for(i=n*4;i>n*3;      //   Inner loop `i` in the range [4n, 3n):
      r+=(i--+"")         //    Convert the current number to a String,
         .charAt(j));     //    and append the `j`'th digit to the result-String
  r+="┌"                  //  Append the top-left corner of the chip
     +"┴".repeat(n)       //  Append the top row of the chip
     +"┐\n";              //  Append the top-right corner of the chip, plus a new-line
  for(i=0;i<n             //  Loop `i` in the range [0, n):
      ;                   //    After every iteration:
       r+="├"             //     Append the right border of the chip
          +(n*3-i+++1)    //     Append the number
          +"\n")          //     And a trailing newline
    r+=p.substring((i+"").length())
                          //   Append padding spaces in front of the left number
       +i                 //   Append the current number
       +"┤"               //   Append the left border of the chip
       +" ".repeat(n);    //   Append the inner spaces
  r+=p                    //  Append padding spaces in front of the corner
     +"└"                 //  Append the bottom-left corner of the chip
     +"┬".repeat(i)       //  Append the bottom part of the chip
     +"┘\n"               //  Append the bottom-right corner of the chip, plus a new-line
     +P;                  //  Append padding spaces in front of the bottom number
  for(j=-1;j++<l;         //  Loop `j` in the range (-1, l]:
      ;                   //    After every iteration:
       r+="\n"            //     Append a new-line
          +P)             //     Append padding spaces for the number
    for(i=n;i<n*2;        //   Inner loop `i` in the range [n, 2n):
      r+=(++i+"")         //    Convert the current number to a String,
         .charAt(j));     //    and append the `j`'th digit to the result-String
  return r;}              //  Return the result-String