Створіть мені чіп QFP!

З пісочниці!

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 повинні бути укладені та запечатані так, як передбачено ascii. інтервал має надзвичайно важливе значення. Пил всередині мікропроцесора - це погана штука!
• нумерацію штифтів потрібно виконати, як у прикладах (читати зліва направо, зверху вниз, нумерувати проти годинникової стрілки)
• Ви можете почати нумерацію з 0, але це не повинно впливати на мікросхему (для введення 12 все одно потрібно 12 контактів на сторону)
• Єдиними дійсними характеристиками у вашому висновку є 1,2,3,4,5,6,7,8,9,0,┌,┴,┐,├,┘,┬,└,┤пробіли та нові рядки.
• всі кодування для мов дозволені, але ваш вихід ОБОВ'ЯЗКОВО повинен відповідати правилам, наведеним вище.

Це кодовий гольф, і як такий Код з найменшою кількістю байтів виграє! Щасти!

Математика, 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=#]&

Анонімна функція. Бере число як вхід і повертає рядок як вихід. Символом Unicode без малюнка є поле U + F3C7 (приватне використання) для \[Transpose].

Котлін , 397 393 байт

Безіменна лямбда.

Ви можете спробувати тут , але вам доведеться вставити джерело в себе, оскільки редактор, схоже, не зберігає програми в кодуванні UTF-8. Невикористана версія - це повноцінна програма, тому ви повинні мати можливість використовувати її в повному обсязі.

Гольф

{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 або якийсь інший оператор як функцію конкатенації. Більше інтерполяції та менше розмов для друку.

Пітон 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)])

Спробуйте тут. Зверніть увагу, що файл повинен починатися з UTF-8 BOM \xef\xbb\xbfдля того, щоб літерали Unicode працювали в стандартному інтерпретаторі CPython. Ці 3 байти зараховуються до розміру тут. repl.itвже використовує unicode, тому посилання просто містить код, показаний тут.

Дякуємо @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
  ])

JavaScript (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, тому, ймовірно, не кваліфікується як цілком допустимий запис. Тому я зараз відзначаю це як неконкурентне.

Це може бути легко модифіковано для підтримки довільної великої кількості штифтів, використовуючи більш широкі статичні поля навколо мікросхеми. Однак це може також порушити правила (не впевнені в цьому). Повністю динамічна маржа коштуватиме значно більше байтів.

Демо

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

Java 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