Générez-moi une puce QFP!

Du bac à sable!

QFP est un type de facteur de forme pour un composant électrique où les broches sortent des côtés d'une puce. Voici une image d'un composant QFP typique:

^{vous pouvez voir que la formule générale est d'avoir 4 côtés d'un nombre égal de broches.}

Votre défi est de créer un programme qui accepte un nombre entier, qui représente le nombre de broches d'un côté, et crée un composant ASCII QFP avec des broches numérotées.

Contribution:

un seul entier qui représente le nombre de broches d'un côté

Sortie:

Une puce ASCII QFP avec un brochage approprié.

Exemple:

entrée: 1

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

entrée: 2

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

entrée: 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

Règles:

• toutes les puces QFP doivent être enfermées et scellées ainsi que ascii fournit. l'espacement est de la plus haute importance. La poussière à l'intérieur d'un microprocesseur est une mauvaise chose!
• la numérotation des broches doit être effectuée comme dans les exemples (lire de gauche à droite, de haut en bas, numéroté dans le sens antihoraire)
• Vous pouvez commencer la numérotation à 0, mais cela ne doit pas affecter la puce (une entrée de 12 a encore besoin de 12 broches par côté)
• Les seuls caractères valides dans votre sortie sont les 1,2,3,4,5,6,7,8,9,0,┌,┴,┐,├,┘,┬,└,┤espaces et les retours à la ligne.
• tous les encodages pour les langues sont autorisés, mais votre sortie DOIT être conforme aux règles ci-dessus.

Il s'agit d'un codegolf, et en tant que tel, le code avec le moins d'octets gagne! Bonne chance!

Mathematica, 271 octets

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

Fonction anonyme. Prend un nombre en entrée et renvoie une chaîne en sortie. Le caractère Unicode sans dessin de boîte est U + F3C7 (usage privé) pour \[Transpose].

Kotlin , 397 393 octets

Lambda sans nom.

Vous pouvez l'essayer ici , mais vous devrez coller la source en vous-même car l'éditeur ne semble pas enregistrer les programmes en encodage UTF-8. La version non golfée est un programme complet, vous devriez donc pouvoir l'utiliser dans son intégralité.

Golfé

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

(Sorte de) Non golfée

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

Enregistré un tas d'octets en surchargeant l' %opérateur et en l'utilisant pour imprimer. J'y reviendrai probablement plus tard - je pense que je peux économiser pas mal d'octets si j'utilise modou un autre opérateur comme fonction de concaténation. Plus d'interpolation et moins d'appels imprimés.

Python 2, 352 343 331 octets

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

Essayez-le ici. Notez que le fichier doit commencer par la nomenclature UTF-8\xef\xbb\xbf pour que les littéraux unicode fonctionnent dans l'interpréteur CPython standard. Ces 3 octets sont comptés ici par rapport à la taille. repl.itutilise déjà unicode donc le lien a juste le code affiché ici.

Merci @tuskiomi pour l'idée d'encodage qui a sauvé 9 21 octets.

Partiellement non golfé:

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 octets (268 caractères), non concurrent

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

Ce code ne prend pas en charge les numéros de broches supérieurs à 99 et ne peut donc probablement pas être considéré comme une entrée entièrement valide. C'est pourquoi je le marque comme non compétitif pour l'instant.

Il pourrait être facilement modifié pour prendre en charge un nombre arbitraire de broches en utilisant des marges statiques plus larges autour de la puce. Cependant, cela peut également enfreindre les règles (je n'en suis pas sûr). Des marges entièrement dynamiques coûteraient beaucoup plus d'octets.

Démo

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 octets

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 octets grâce à @ceilingcat .

Explication:

Essayez-le en ligne.

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