Wygeneruj mi układ QFP!

Z piaskownicy!

QFP jest rodzajem kształtu elementu elektrycznego, w którym piny wychodzą z boków układu. Oto zdjęcie typowego komponentu QFP:

^{widać, że ogólna formuła ma mieć 4 boki równej liczby pinów.}

Wyzwanie polega na utworzeniu programu, który przyjmuje liczbę całkowitą, która reprezentuje liczbę pinów po jednej stronie i tworzy komponent ASCII QFP z numerowanymi pinami.

Wkład:

pojedyncza liczba całkowita reprezentująca liczbę pinów po jednej stronie

Wydajność:

Układ ASCII QFP z odpowiednim pinoutem.

Przykład:

wejście: 1

  4
 ┌┴┐
1┤ ├3
 └┬┘
  2)

wejście: 2

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

wkład: 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

Zasady:

• wszystkie czipy QFP muszą być zamknięte i zapieczętowane, podobnie jak ascii. odstępy mają ogromne znaczenie. Pył wewnątrz mikroprocesora to złe rzeczy!
• numeracja pinów musi być wykonana jak w przykładach (Czytaj od lewej do prawej, od góry do dołu, numerowane przeciwnie do ruchu wskazówek zegara)
• Możesz zacząć numerowanie od 0, ale nie może to wpływać na układ (wejście 12 nadal wymaga 12 pinów na stronę)
• Jedynymi poprawnymi znakami w twoich wynikach są 1,2,3,4,5,6,7,8,9,0,┌,┴,┐,├,┘,┬,└,┤spacje i znaki nowej linii.
• wszystkie kodowania dla języków są dozwolone, ale Twój wynik MUSI być zgodny z powyższymi regułami.

To jest kodegolf i jako taki wygrywa kod z najmniejszą liczbą bajtów! Powodzenia!

Mathematica, 271 bajtów

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

Funkcja anonimowa. Pobiera liczbę jako dane wejściowe i zwraca ciąg znaków jako dane wyjściowe. Unikodowy rysunek Unicode to U + F3C7 (do użytku prywatnego) \[Transpose].

Kotlin , 397 393 bajtów

Nienazwana lambda.

Możesz spróbować tutaj , ale musisz wkleić źródło w sobie, ponieważ edytor nie wydaje się zapisywać programów w kodowaniu UTF-8. Wersja bez golfa jest pełnym programem, więc powinieneś móc z niego korzystać w całości.

Grał w golfa

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

(W pewnym sensie) 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)
}

Zaoszczędził sporo bajtów, przeciążając %operatora i używając go do drukowania. Prawdopodobnie wrócę do tego później - myślę, że mogę zaoszczędzić sporo bajtów, jeśli użyję modlub innego operatora jako funkcji konkatenacji. Więcej interpolacji i mniej połączeń drukowania.

Python 2, 352 343 331 bajtów

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

Wypróbuj tutaj. Uwaga: plik musi rozpoczynać się od BOM UTF-8, \xef\xbb\xbfaby literały Unicode działały w standardowym interpreterze CPython. Te 3 bajty są tutaj liczone w stosunku do rozmiaru. repl.itużywa już Unicode, więc link ma tylko pokazany kod.

Dzięki @tuskiomi za pomysł na kodowanie, który został zapisany 9 21 bajtów.

Częściowo niestrzeżony:

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 bajtów (268 znaków), niekonkurujący

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

Ten kod nie obsługuje numerów pinów powyżej 99 i dlatego prawdopodobnie nie kwalifikuje się jako w pełni poprawny wpis. Dlatego na razie oceniam to jako niekonkurujące.

Można go łatwo zmodyfikować, aby obsługiwał dowolną dużą liczbę pinów, używając szerszych marginesów statycznych wokół układu. Może to jednak również naruszać zasady (nie jestem tego pewien). W pełni dynamiczne marże kosztowałyby znacznie więcej bajtów.

Próbny

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 bajtów

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 bajtów dzięki @ceilingcat .

Wyjaśnienie:

Wypróbuj online.

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