Tạo cho tôi một con chip QFP!

Từ hộp cát!

QFP là một loại yếu tố hình thức cho một thành phần điện trong đó các chân đi ra các cạnh của chip. Dưới đây là hình ảnh của một thành phần QFP điển hình:

^{bạn có thể thấy rằng công thức chung là có 4 cạnh của số chân bằng nhau.}

Thách thức của bạn là tạo ra một chương trình lấy một số nguyên, chúng đại diện cho số lượng chân ở một bên và tạo ra một thành phần QFP ASCII với các chân được đánh số.

Đầu vào:

một số nguyên duy nhất đại diện cho số lượng chân ở một bên

Đầu ra:

Một chip QFP ASCII với sơ đồ chân phù hợp.

Thí dụ:

đầu vào: 1

  4
 ┌┴┐
1┤ 3
 └┬┘
  2

đầu vào: 2

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

đầu vào: 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

Quy tắc:

• tất cả các chip QFP phải được bao quanh và niêm phong cũng như ascii cung cấp. khoảng cách là vô cùng quan trọng. Bụi bên trong một bộ vi xử lý là thứ xấu!
• Việc đánh số pin phải được thực hiện như trong các ví dụ (Đọc từ trái sang phải, từ trên xuống dưới, đánh số theo chiều kim đồng hồ)
• Bạn có thể bắt đầu đánh số 0, nhưng điều này không được ảnh hưởng đến chip (đầu vào 12 vẫn cần 12 chân mỗi bên)
• Các characers hợp lệ duy nhất trong đầu ra của bạn là 1,2,3,4,5,6,7,8,9,0,┌,┴,┐,├,┘,┬,└,┤, khoảng trắng và dòng mới.
• tất cả các mã hóa cho các ngôn ngữ đều được cho phép, nhưng đầu ra của bạn PHẢI phù hợp với các quy tắc ở trên.

Đây là một codegolf và như vậy, Mã có số byte ít nhất sẽ thắng! Chúc may mắn!

Toán học, 271 byte

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=#]&

Chức năng ẩn danh. Lấy một số làm đầu vào và trả về một chuỗi làm đầu ra. Ký tự Unicode không vẽ hộp là U + F3C7 (sử dụng riêng) cho \[Transpose].

Kotlin , 397 393 byte

Lambda không tên.

Bạn có thể thử nó ở đây , nhưng bạn sẽ phải tự dán nguồn vì trình soạn thảo dường như không lưu các chương trình trong mã hóa UTF-8. Phiên bản không có bản quyền là một chương trình đầy đủ, vì vậy bạn có thể sử dụng toàn bộ phiên bản đó.

Chơi gôn

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

(Sắp xếp) 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)
}

Đã lưu một loạt byte bằng cách nạp chồng %toán tử và sử dụng nó để in. Có lẽ tôi sẽ xem lại điều này sau - Tôi nghĩ rằng tôi có thể tiết kiệm được một vài byte nếu tôi sử dụng modhoặc một số toán tử khác làm hàm nối. Nội suy nhiều hơn và các cuộc gọi in ít hơn.

Con trăn 2 352 343 331 byte

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

Hãy thử nó ở đây. Lưu ý tệp phải bắt đầu bằng BOM UTF-8 \xef\xbb\xbfđể các ký tự unicode hoạt động trong trình thông dịch CPython tiêu chuẩn. 3 byte này được tính theo kích thước ở đây. repl.itđã sử dụng unicode nên liên kết chỉ có mã được hiển thị ở đây.

Cảm ơn @tuskiomi vì ý tưởng mã hóa đã lưu 9 21 byte.

Một phần vô dụng:

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 byte (268 ký tự), không cạnh tranh

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

Mã này không hỗ trợ số pin trên 99 và do đó có thể không đủ điều kiện là mục nhập hoàn toàn hợp lệ. Đó là lý do tại sao tôi đánh dấu nó là không cạnh tranh cho đến bây giờ.

Có thể dễ dàng sửa đổi để hỗ trợ một số lượng lớn chân tùy ý bằng cách sử dụng lề tĩnh rộng hơn xung quanh chip. Tuy nhiên, điều đó cũng có thể vi phạm các quy tắc (không chắc chắn về điều đó). Lợi nhuận hoàn toàn động sẽ tốn nhiều byte hơn đáng kể.

Bản giới thiệu

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 byte

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 byte nhờ @ceilingcat .

Giải trình:

Hãy thử trực tuyến.

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