Generiere mir einen QFP-Chip!

Aus dem Sandkasten!

QFP ist eine Art Formfaktor für eine elektrische Komponente, bei der Stifte aus den Seiten eines Chips herausragen. Hier ist ein Bild einer typischen QFP-Komponente:

^{Sie können sehen, dass die allgemeine Formel darin besteht, 4 Seiten mit der gleichen Anzahl von Stiften zu haben.}

Ihre Herausforderung besteht darin, ein Programm zu erstellen, das eine Ganzzahl aufnimmt, die die Anzahl der Pins auf einer Seite darstellt, und eine ASCII-QFP-Komponente mit nummerierten Pins erstellt.

Eingang:

Eine einzelne Ganzzahl, die die Anzahl der Pins auf einer Seite darstellt

Ausgabe:

Ein ASCII-QFP-Chip mit einer entsprechenden Pinbelegung.

Beispiel:

Eingabe: 1

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

Eingabe: 2

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

Eingabe: 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

Regeln:

• Alle QFP-Chips müssen eingeschlossen und versiegelt sein. Abstand ist von größter Bedeutung. Staub in einem Mikroprozessor ist schlechtes Zeug!
• Die Pin-Nummerierung muss wie in den Beispielen erfolgen (von links nach rechts, von oben nach unten, gegen den Uhrzeigersinn nummeriert).
• Sie können mit der Nummerierung bei 0 beginnen, dies darf jedoch keine Auswirkungen auf den Chip haben (ein Eingang von 12 benötigt immer noch 12 Pins pro Seite).
• Die einzigen gültigen Zeichen in Ihrer Ausgabe sind 1,2,3,4,5,6,7,8,9,0,┌,┴,┐,├,┘,┬,└,┤Leerzeichen und Zeilenumbrüche.
• Alle Kodierungen für Sprachen sind erlaubt, aber Ihre Ausgabe MUSS mit den obigen Regeln übereinstimmen.

Dies ist ein Codegolf, und als solches gewinnt der Code mit der geringsten Anzahl von Bytes! Viel Glück!

Mathematica, 271 Bytes

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

Anonyme Funktion. Nimmt eine Zahl als Eingabe und gibt eine Zeichenfolge als Ausgabe zurück. Das Nicht-Box-Zeichnungs-Unicode-Zeichen ist U + F3C7 (private Verwendung) für \[Transpose].

Kotlin , 397 393 Bytes

Unbenanntes Lambda.

Sie können es hier versuchen , aber Sie müssen die Quelle in sich selbst einfügen, da der Editor keine Programme in UTF-8-Codierung zu speichern scheint. Die ungolfed-Version ist ein vollständiges Programm. Sie sollten das also in vollem Umfang nutzen können.

Golf gespielt

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

(Art von) 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)
}

Sparte eine Menge Bytes, indem der %Operator überlastet und zum Drucken verwendet wurde. Ich werde das wahrscheinlich später noch einmal wiederholen - ich denke, ich kann einige Bytes einsparen, wenn ich modeinen anderen Operator als Verkettungsfunktion verwende. Mehr Interpolation und weniger Druckaufrufe.

Python 2, 352 343 331 Bytes

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

Probieren Sie es hier aus.Beachten Sie, dass die Datei mit der UTF-8-Stückliste beginnen muss, \xef\xbb\xbfdamit die Unicode-Literale im Standard-CPython-Interpreter funktionieren. Diese 3 Bytes werden hier gegen die Größe gezählt. repl.itverwendet bereits Unicode, daher enthält der Link nur den hier gezeigten Code.

Vielen Dank an @tuskiomi für die Kodierungsidee, die gespeichert wurde 9 21 Bytes.

Teilweise ungolfed:

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 Zeichen), nicht konkurrierend

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

Dieser Code unterstützt keine PIN-Nummern über 99 und qualifiziert sich daher möglicherweise nicht als vollständig gültiger Eintrag. Aus diesem Grund stelle ich fest, dass es derzeit keine Wettbewerbe gibt.

Es könnte leicht modifiziert werden, um eine beliebige große Anzahl von Stiften zu unterstützen, indem breitere statische Ränder um den Chip verwendet werden. Dies kann jedoch auch gegen die Regeln verstoßen (da bin ich mir nicht sicher). Voll dynamische Ränder würden deutlich mehr Bytes kosten.

Demo

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 Bytes

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 Bytes dank @ceilingcat .

Erläuterung:

Probieren Sie es online aus.

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