QFP 칩을 생성하십시오!

샌드 박스에서!

QFP는 핀이 칩 측면에서 나오는 전기 부품의 폼 팩터 유형입니다. 다음은 일반적인 QFP 구성 요소의 사진입니다.

^{당신은 일반적인 공식이 같은 수의 핀의 4면을 가지고 있음을 알 수 있습니다.}

문제는 정수를 사용하는 프로그램을 작성하고, thich는 한쪽의 핀 수를 나타내며, 번호가 매겨진 핀으로 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이므로 바이트 수가 가장 적은 코드가 승리합니다! 행운을 빕니다!

수학, 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].

코 틀린 , 397 393 바이트

이름이없는 람다.

여기 에서 시도해 볼 수 있지만 편집기는 UTF-8 인코딩으로 프로그램을 저장하지 않는 것이므로 소스를 직접 붙여 넣어야합니다. ungolfed 버전은 전체 프로그램이므로 전체를 사용할 수 있습니다.

골프

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

여기에서 시도하십시오. \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
  ])

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

자바 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;}

@ceilingcat 덕분에 -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