আমাকে একটি কিউএফপি চিপ তৈরি করুন!

Question

আমাকে একটি কিউএফপি চিপ তৈরি করুন!

স্যান্ডবক্স থেকে!

কিউএফপি হ'ল বৈদ্যুতিক উপাদানগুলির জন্য এক ধরণের ফর্ম ফ্যাক্টর যেখানে পিনগুলি একটি চিপের পাশ থেকে বেরিয়ে আসে। এখানে একটি সাধারণ কিউএফপি উপাদানটির চিত্র দেওয়া হল:

^{আপনি দেখতে পাচ্ছেন যে সাধারণ সূত্রে পিনের সমান সংখ্যার 4 টি দিক থাকতে হবে।}

আপনার চ্যালেঞ্জটি হ'ল এমন একটি প্রোগ্রাম তৈরি করা যা কোনও পূর্ণসংখ্যার মধ্যে নিয়ে যায় এবং এটি একদিকে পিনের সংখ্যা উপস্থাপন করে এবং সংখ্যাযুক্ত পিন সহ একটি 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

নিয়মাবলী:

• সমস্ত কিউএফপি চিপগুলি অবশ্যই জড়িত এবং সিল করা উচিত পাশাপাশি এসসিআই সরবরাহ করে। ব্যবধানের সর্বাধিক গুরুত্ব রয়েছে। একটি মাইক্রোপ্রসেসরের ভিতরে ধুলা খারাপ জিনিস!
• পিন নম্বরগুলি উদাহরণ হিসাবে করা আবশ্যক (বাম থেকে ডানে, নীচে থেকে নীচে, সংখ্যাযুক্ত ঘড়ির কাঁটার দিকে পড়ুন)
• আপনি 0 এ নাম্বারিং শুরু করতে পারেন, তবে এটি চিপকে প্রভাবিত করবে না (12 এর ইনপুটটির জন্য এখনও প্রতি 12 টি পিন প্রয়োজন)
• আপনার আউটপুটে কেবলমাত্র বৈধ পাঠকরা হ'ল 1,2,3,4,5,6,7,8,9,0,┌,┴,┐,├,┘,┬,└,┤ফাঁকা স্থান এবং নিউলাইন।
• ভাষার জন্য সমস্ত এনকোডিং অনুমোদিত, তবে আপনার আউটপুট উপরের নিয়মের সাথে সামঞ্জস্যপূর্ণ হওয়া আবশ্যক।

এটি একটি কোডগল্ফ এবং এর মতো, সর্বনিম্ন বাইটের কোড সহ কোডটি জয়! শুভকামনা!

Comments

শূন্য হ্যান্ডেল করা প্রয়োজন।

— ম্যাজিক অক্টোপাস n

না, তুমি কর না.

— tuskiomi

ইনপুট উপর কোন উচ্চতর সীমা?

— আর্নল্ড

@ আরনাউল্ডের সীমা কেবল ওভারফ্লো এবং ভাষাভিত্তিক সীমা হওয়া উচিত

— তুস্কিওমি

"সমস্ত কিউএফপি চিপগুলি অবশ্যই জড়িত এবং সিল করা উচিত পাশাপাশি এসকিআই সরবরাহ করে" " প্রদত্ত চরিত্রগুলির অর্ধেকটি 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=#]&

বেনামে ফাংশন। ইনপুট হিসাবে একটি সংখ্যা নেয় এবং আউটপুট হিসাবে একটি স্ট্রিং প্রদান করে। নন-বাক্স-অঙ্কন ইউনিকোড অক্ষরটি ইউ + এফ 3 সি 7 (ব্যক্তিগত ব্যবহার) এর জন্য \[Transpose]।

Answer 2

কোটলিন , 397 393 বাইট

নামহীন ল্যাম্বদা

আপনি এটি এখানে চেষ্টা করতে পারেন তবে আপনাকে উত্সটি নিজের মধ্যে আটকে দিতে হবে কারণ সম্পাদক ইউটিএফ -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

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যে ইউনিকোড লিটারালগুলিকে স্ট্যান্ডার্ড সিপিথন ইন্টারপ্রেটারে কাজ করার জন্য ফাইলটি অবশ্যই ইউটিএফ -8 বিওএম দিয়ে শুরু করা উচিত । এই 3 বাইট এখানে আকারের বিপরীতে গণনা করা হয়। repl.itইতিমধ্যে ইউনিকোড ব্যবহার করছে তাই লিঙ্কটি এখানে কোড দেখানো হয়েছে।

এনকোডিং ধারণাটি সংরক্ষিত হয়েছে বলে @ টসকিওমি ধন্যবাদ 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 -*-দোভাষী এটি গ্রহণ করার জন্য আমার শীর্ষে একটি নতুন লাইনের প্রয়োজন হবে। এই অক্ষরের প্রত্যেকটির ইউটিএফ -8 এনকোডিং 3 বাইট, সুতরাং এনকোডিং নির্দেশিকার জন্য মূল্য দিতে যথেষ্ট ছিল না। আমি যদিও পিইপি 263 টি পরীক্ষা করেছি এবং আমি ঠিক #coding=utf-8এবং একটি নতুন লাইন দিয়ে পালাতে পারি যাতে এটি কিছু বাইট সংরক্ষণ করতে পারে।

— জেক কোব

থ্রি-বাইট ইউটিএফ -8 বিওএম দৃশ্যত কাজ করে।

— জেক কোব

Answer 4

জাভাস্ক্রিপ্ট (ES6), 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 এর উপরে পিন সংখ্যাগুলি সমর্থন করে না এবং তাই সম্ভবত সম্পূর্ণ বৈধ এন্ট্রি হিসাবে যোগ্যতা অর্জন করে না। সে কারণেই আমি এটিকে আপাতত প্রতিযোগিতামূলক হিসাবে চিহ্নিত করি mark

এটি সহজেই চিপের চারপাশে আরও বিস্তৃত স্ট্যাটিক মার্জিন ব্যবহার করে একটি সালিশী বৃহত সংখ্যক পিনকে সমর্থন করার জন্য পরিবর্তন করা যেতে পারে। তবে এটি নিয়মকেও লঙ্ঘন করতে পারে (এটি সম্পর্কে নিশ্চিত নয়)। সম্পূর্ণ গতিশীল মার্জিনের জন্য উল্লেখযোগ্যভাবে আরও বাইট খরচ হবে।

ডেমো

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 বাইটস @ সিলিংক্যাটকে ধন্যবাদ জানায় ।

ব্যাখ্যা:

এটি অনলাইনে চেষ্টা করুন।

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