Сгенери мне чип 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,┌,┴,┐,├,┘,┬,└,┤пробелы и переводы строк.
• все кодировки для языков разрешены, но ваш вывод ДОЛЖЕН соответствовать приведенным выше правилам.

Это Codegolf, и, как таковой, код с наименьшим количеством байтов выигрывает! Удачи!

Mathematica, 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. Развернутая версия - это полноценная программа, поэтому вы сможете использовать ее полностью.

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

(Вроде) Ungolfed

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

Python 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, \xef\xbb\xbfчтобы литералы Юникода работали в стандартном интерпретаторе 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