Défi

Étant donné un opérateur ASCII dans la liste ci-dessous et un nombre n, tracez une représentation ASCII de l'opérateur en utilisant cet opérateur comme caractère avec les segments de ligne de l'opérateur de longueur n .

Contribution

Un caractère ASCII de la liste = + - x /et un entier noù n >= 1. (J'utilise à la xplace de *et /au lieu de ÷, mais vous pouvez utiliser l'un ou l'autre, selon ce qui est plus facile). Pour +et x, vous n'avez qu'à gérer les nombres impairs pour éviter les problèmes d'alignement.

Sortie

Un dessin ASCII de l'opérateur composé du caractère avec des segments de longueur n. Les portions horizontales doivent avoir des espaces entre les caractères pour compenser les différences de distance verticale / horizontale.

Règles

C'est le code-golf , donc le code le plus court en octets gagne. Les failles standard sont interdites.

Exemples

Contribution: + 3

  +
+ + +
  +

Contribution: = 4

= = = =
= = = =

Contribution: = 10

= = = = = = = = = =
= = = = = = = = = =

Contribution: - 2

- -

Contribution: / 10

         /
        /
       /
      /
     /
    /
   /
  /
 /
/

Contribution: x 7

x     x
 x   x
  x x
   x
  x x
 x   x
x     x

Pip , 62 59 56 octets

55 octets de code, +1 pour l' -Sindicateur.

[sXbRA_AEv-_aM,b(Y^aWR_Xb/2s)MyRVsX,b.aYaXbJsxyRL2x]@Aa

Notez que cette solution fonctionne avec l'entrée de ÷pour la division et *pour la multiplication, bien qu'elle utilise ces caractères pour dessiner l'art ASCII /et x, respectivement. OP a clarifié que cela allait. Essayez-le en ligne!

Comment?

Voici une version partiellement espacée et commentée . Notez que aet bsont les arguments de la ligne de commande, c'est-à-dire l'opérateur et la taille respectivement. L' -Sindicateur contrôle la façon dont les listes sont sorties: il rejoint d'abord les sauts de ligne, mais joint toutes les listes imbriquées sur les espaces.

[                 Build a list of all possible figures:
 sXbRA_AEv-_aM,b   0 - Multiplication
 (Y^aWR_Xb/2s)My   1 - Addition
 RVsX,b.a          2 - Division
 YaXbJs            3 - Subtraction
 x                 4 - Empty
 yRL2              5 - Equals
 x                 6 - Empty
] @ Aa            Index, mod 7, with ASCII value of a

Et voici les sections individuelles:

Multiplication

Pour chaque ligne de la figure, nous générons une chaîne d'espaces, puis remplaçons deux d'entre eux par le caractère d'entrée. Pour la ligne i, nous voulons remplacer les espaces à l'index iet b-1-i; mais notez que ce dernier peut utiliser l'indice négatif -1-i. (Il est encore plus court car la variable vest préinitialisée à negati v e 1.)

sXbRA_AEv-_aM,b
            M,b  Map this function to range(b):
sXb                Space, repeated b times
     _             Function arg
      AE           (Implicitly) convert to list and append element...
        v-_        -1 minus function arg
   RA              Replace the characters at those indices...
           a       ... with input character
                 The resulting list is output with one item per line

Une addition

En utilisant la stratégie de mon Dessinez un carré creux réponse, on définit une fonction qui enveloppe un +dans des b/2copies de son argument et renvoie le résultat sous la forme d' une liste de caractères. (La division entière //n'est pas nécessaire car l'opérateur de répétition de chaînes Xtronque automatiquement en entier.) Premièrement, nous appelons cette fonction sur un espace, donnant [" ";" ";"+";" ";" "]; ensuite, nous mappons la même fonction à ce résultat, donnant [" ";" ";"+";" ";" "]sur la plupart des lignes mais ["+";"+";"+";"+";"+"]sur la ligne centrale. Cette liste imbriquée est ensuite sortie, en raison de l' -Sindicateur, avec des espaces entre tous les caractères d'une ligne et des sauts de ligne entre les lignes.

(Y^aWR_Xb/2s)My
                 Anonymous function:
      _Xb/2        Function arg, repeated b/2 times (implicitly rounded down)
   aWR             Wrap a in two copies of the above
  ^                Split resulting string into list of chars
 Y               Yank that function into y
(          s)    Apply function y to space
             My  Map y to that result

Division

Chaque ligne a entre b-1et des 0espaces, suivis du caractère saisi a.

RVsX,b.a
    ,b    Range(b)
  sX      Space, repeated that many times (works itemwise)
      .a  Concatenate a (itemwise)
RV        Reverse (puts the larger number of spaces at the beginning)
          Outputs newline-separated

Soustraction

Créez une ligne séparée par des espaces du caractère saisi. Enregistrez une copie pour plus tard.

YaXbJs
 aXb    b copies of a
    Js  Join on space
Y       Yank into y (overwrites the function from earlier, but we're done using it anyway)
        This is a string, so it just gets output

Équivaut à

L'étape de soustraction a stocké la moitié de ce dont nous avons besoin - yjuste le doubler.

yRL2  (Implicitly) convert y to list and repeat it twice
      Outputs newline-separated

Les xvaleurs fictives sont là pour remplir la liste principale afin que l'indexation modulaire donne un index unique pour chaque caractère d'entrée dans +-*÷=.

V , 78, 72, 71, 68, 65, 63, 62 , 61 octets

Ç=ü-/Àé X
ç^Ó/é Àä$
ç+/ÀÄM|ÀR+ 
ç=/Ä
ç¯/lòhYpX
çx/rxòl3Äjxlrx

Essayez-le en ligne!

Comme toujours, la bataille au coude à coude avec 05AB1E est vraiment amusante!

Puisqu'il contient des caractères non ASCII, voici un hexdump:

0000000: c73d fc2d 2fc0 e920 580a e75e d32f e920  .=.-/.. X..^./. 
0000010: c0e4 240a e72b 2fc0 c44d 7cc0 522b 200a  ..$..+/..M|.R+ .
0000020: e73d 2fc4 0ae7 af2f 6cf2 6859 7058 0ae7  .=/..../l.hYpX..
0000030: 782f 7278 f26c 33c4 6a78 6c72 78         x/rx.l3.jxlrx

Cela crée des espaces de tête dans la sortie pour =et -, mais cela semble être autorisé . Si cela n'est pas autorisé, n'hésitez pas à commenter et je vais le restaurer.

Explication

La "commande globale" (par exemple ç) applique un certain ensemble de commandes à chaque ligne qui correspond à une certaine expression régulière. La syntaxe est

ç<compressed regex>/<commands>

C'est le moyen le plus simple de simuler une instruction conditionnelle / switch. Dans ma réponse d'origine, j'ai simplement créé l'intégralité de l'art ASCII sur le côté droit pour chaque personnage différent que nous devons rechercher. Cependant, beaucoup de ces sorties nécessitent des commandes similaires. Je les ai donc combinés. La première commande ('Ç') est en fait l'inverse de la commande globale, elle applique la commande à chaque ligne ne correspondant pas à l'expression régulière. La première commande est donc:

Ç=ü-        " On every line not containing an '=' or an '-' (e.g. inputs '/', '+', and 'x'):
    /Àé     "   Insert *n* spaces
        X   "   Delete one of them

La commande suivante concerne les entrées '=' et '-'. Ces deux sont commodément faciles et similaires. Après cette commande, nous n'avons plus besoin de traitement -.

ç^Ó         " On every line that starts with non-whitespace (e.g. every line not affected by our previous command):
   /é       "   Insert one space
            "   Move back a character
      À     "   Make *n* copies
       ä$   "   Of every character on this line

De là, nous faisons juste quelques commandes supplémentaires pour chaque entrée individuelle possible. Pour +:

ç+/         " On every line containing a '+':
   ÀÄ       "   Make *n* copies of this line
     M|     "   Move to the first character of the middle line
       À    "   *n* times:
        R+  "   Replace the next two characters with '+ '

La commande pour égal est très simple. Nous le reproduisons simplement avec Ä. Pour /:

ç¯          " On every line containing a '/':
  /l        "   Move one character to the right
    ò       "   Recursively:
     h      "     Move one character to the left
      Yp    "     Make a copy of this line
        X   "     Delete one character
         ò  "   End loop (implicit)

Le dernier est le plus compliqué. C'est essentiellement un portage de cette réponse .

çx              " On every line containing a 'x':
  /rx           "   Replace the first character with an 'x'
     ò          "   Recursively:
      l         "     Move one char to the right
       3Ä       "     Make 3 copies of this line
         j      "     Move down one line
          x     "     Delete one char
           l    "     Move one char to the right
            rx  "     Replace this char with an 'x'

05AB1E , 81 76 74 73 70 69 68 65 64 62 60 59 57 56 octets

À l' heure actuelle dans la guerre avec la réponse V . Je viens pour vous Dr McMoylex: p.

Toujours en guerre avec la réponse de Pip . Je vous surveillerai M. DLosc.

Code:

Ç6&"¹s<ú.s.Bívy¹'xQiÂðñ}, ¹×S)»¹'=Qƒ= ;ƒ¹})D¦»»Rû.c"#è.V

Ou sous une forme plus lisible:

  Ç6&
"¹s<ú.s.Bívy¹'xQiÂðñ},
 ¹×S)»¹'=Qƒ=
 ;ƒ¹})D¦»»Rû.c"
#è.V

Utilise l' encodage CP-1252 . Essayez-le en ligne!

Python 3, 304 283 278 octets

Assez simple, crée simplement une matrice de caractères et applique les différentes opérations en fonction de celle-ci. Le =et -ont des espaces de fin si ce n'est pas trop mal.

EDIT: Merci à @Shebang et @Rod pour leurs suggestions qui ont fini par économiser 21 octets!

EDIT2: Merci à @Artyer pour avoir économisé 5 octets!

t,s=input().split()
s=int(s)
r=range(s)
b=[[' ']*s for x in r]
exec(['for x in r:b[s//2][x]=b[x][s//2]=t','b=[t*s]'+'*2'*(t=='='),'for x in r:b[x][s-x-1]='+'b[x][x]='*(t=='x')+'t'][(t>'+')+(t in'x/')])
if t in'-=+':b=[[x+' 'for x in l]for l in b]
print(*map(''.join,b),sep='\n')

JavaScript (ES6), 238 225 215 215 202 196 octets

(c,n)=>[...Array(i=n*(c=="="?4:c+1-1?2:c<"-"?n+n:n+1))].map(_=>--i%(n+(c=='/'|c>'w'||n))?c>'w'?i%n&&~-i%(n+2)?" ":c:c<'-'?i%(n*2)-n&&(~i&1|(n/2^i/n/2))?" ":c:c=="/"?i%n?" ":c:i%2?c:" ":`
`).join``

Pourrait probablement être joué au golf, mais c'est un début.

Scala, 275 octets

(i,c)=>if(c<44){val b=(" "*(i-1)+"+\n")*((i-1)/2)
b+"+ "*i+"\n"+b}else
if(c<46)"- "*i else
if(c<48)i-1 to(0,-1)map(" "*_+"/\n")mkString else
if(c<62)"= "*i+"\n"+"= "*i
else{val a=0 to i/2-1 map(x=>" "*x+"x"+" "*((i/2-x)*2-1)+"x"+" "*x+"\n")mkString;a+" "*(i/2)+"x"+a.reverse}

Usage:

val f:((Int,Char)=>String)=...
print(f(10, '/'))

Explication:

Le code teste la valeur ascii du caractère pour choisir la bonne façon de générer l'image. Les valeurs ascii des opérateurs en question sont: ('+' -> 43), ('-' ->45), ('/' -> 47), ('=' -> 61), ('x' -> 120)

(i,c)=>                              //define a function
  if(c<44){                            //if c is a plus
    val b=(" "*(i-1)+"+\n")*((i-1)/2)    //define the top/bottom part b as (i-1)/2 times (i-1) spaces, a plus sign and a newlineine
    b+"+ "*i+"\n"+b                      //return b, i times a plus and a space, a newline and b
  }else if(c<46)                       //if c is a '-'
    "- "*i                               //return "- " repeated i times
  else if(c<48)                        //if c is a '/'
    i-1 to(0,-1)                         //create a range from i-1 to 0 in steps of -1
    map(" "*_+"/\n")                     //map each number to that number of spaces plus a "/" and a newline
    mkString                             //join them together
  else if(c<62)                        //if c is '='
    "= "*i+"\n"+"= "*i                   //return "= " repeated i times, a newline and "= " repeated i times again
  else{                                //if c if 'x'
    val a=                               //define a, which will be the top part, as...
      0 to i/2-1                         //a range from 0 to i/2-1
      map(n=>                            //map each number n to
        " "*n                              //n spaces
        +"x"                               //plus an "x"
        +" "*((i/2-n)*2-1)                 //plus ((i/2)-n)*2-1 spaces
        +"x"                               //plus an "x"
        +" "*n                             //plus n spaces
        +"\n"                              //and a newline
      )mkString;                         //join them
    a+" "*(i/2)+"x"+a.reverse          //return a, i/2 spaces, "x" and the reverse of a 
  }

JavaScript (ES6), 156 octets

(c,n)=>[...Array(n--)].map((_,i,a)=>a.map((_,j)=>({'/':a=i+j-n,x:a&&i-j,'-':a=i+i-n,'+':a&&j+j-n,'=':a+2&&a-2}[c]?' ':c)).join(c=='='|c<'/'?' ':'')).join`\n`

Où \nreprésente le caractère de nouvelle ligne littéral.

Dyalog APL , 91 86 octets

Besoins ⎕IO←0, qui est par défaut sur de nombreux systèmes. Prend n comme argument de gauche et l'un de + - × ÷ = comme argument de droite.

{s←⌈⍎⍕3⍵2
t←' '⍵
d←⌽∘.=⍨⍺
s∊2 6:t[d∨⌽d∧6=s]
5=s:t[↑,/2↑¨∨/¨(⌊⍺÷2)=⍳⍺ ⍺]
(2-s)(2×⍺)⍴t}

Explication

{
    s ← ⌈ ⍎ ⍕ 3 ⍵ 2             ⍝ calculate ceil(3 f 2), where f is the given symbol
    t ← ' '⍵                    ⍝ create a string with a space before the symbol
    d ← ⌽ ∘.=⍨ ⍺                ⍝ Boolean \ diagonal
    s ∊ 2 6: t[d ∨ ⌽ d ∧ 6 = s] ⍝ if ÷ or × index t with one or both diagonals
⍝ find coordinates that are in the middle of at least one dimension
⍝ pad with zeros for spacing
⍝ use that to index into t
    5 = s: t[ ↑ ,/ 2↑¨ ∨/¨ (⌊ ⍺ ÷ 2) = ⍳ ⍺ ⍺]
⍝ - or =:
    (2 - s) (2 × ⍺) ⍴ t       ⍝ one or two rows of double-spaced symbols
}

Mathematica, 191 octets

e=#~Mod~2==1&;StringRiffle[Normal@SparseArray[{a_,b_}/;(a+b==d+1||a==b)[e@b&&a<3,,e@b&&(a==⌈d/2⌉||b==d),,e@b&&a<2,,a+b==d+1][[Last@ToCharacterCode@#~Mod~10]]:>#,{d=#2,2d-1}," "],"
"," "]&

Fonction anonyme. Prend une chaîne et un nombre en entrée et renvoie une chaîne en sortie. Pas le plus court de loin, mais toujours amusant à écrire.

C, 396 octets

#define p(x) printf(x);
i,j,k,m;f(char s,int n){i=k=0;if(s==45)for(;i<n;++i)p("- ")m=n/2;if(s==43)for(;i<n;++i)for(j=0;j<=m;++j)if(i-m)p(j-m?"  ":"+\n")else{for(;k<n;++k)p("+ ")p("\n")j+=m;}if(s==61)for(;i<2;++i){for(k=0;k<n;++k)p("= ")p("\n")}j=n;if(s==47)for(;i<n;++i){--j;for(k=0;k<j;++k)p(" ")p("/\n")}if(s==120)for(;i<n;++i){k=m-abs(m-i);for(j=0;j<n-k;++j)p(j-k?" ":"x")p(i-m?"\bx\n":"\n")}}

Appeler avec:

int main()
{
   f('x', 5);
   return 0;
}

SOML , 104 100 octets (non concurrent)

    Cd³³b»E +=?ce*d+e{t}bd*Oe{t}} ==?b*tt} -=?b*t} /=?bc*b{j:d+p}} x=?"”cb*e{jj⁴⁴d;d+++tGG;c+;}XOdoe{O

C'est un peu concurrentiel car je suis presque sûr que tout ce que j'ai utilisé ici a des documents sur github avant cette date de publication des questions, mais l'analyseur n'a pas de support pour certaines fonctions que j'ai utilisées si idk.

PHP, 306 292 281 282 281 275 270 octets

$r=str_pad("",2*$n=$argv[2],($c=$argv[1])." ")."\n";if(",">$c)$r=($m=str_repeat(str_pad($c,$n," ",0)."\n",$n/2))."$r$m";if(9<$c)$r.=$r;if(w<$c)for($r=$c;$i<$n;$r[$i*(2+$n)]=$r[++$i*$n-1]=x)$r[$i*$n+$i+$n]="\n";if("/"==$c)for($r=$s="";$i++<$n;$s.=" ")$r="$s/\n$r";echo$r;

Ooh, c'est encombrant ... a besoin de golf.
Je pourrais économiser 4 octets avec des sauts de ligne physiques ou un octet en mettant "\ n" dans une variable.

C #, 744 octets

C'est comme 1 million de caractères, je pense, mais je m'en fiche, je suis tellement heureux d'avoir résolu ça ...

Golfé:

string A(string s,int n){string O="";Func<string,int,string>R=(a,b)=>{return string.Join("",Enumerable.Repeat(a,b))+"\r\n";};switch(s){case"+":for(int i=0;i<n;i++){if(i==n/2){O+=R("+",n);}else{O+="+".PadLeft(n-n/2,' ').PadRight(n-n/2,' ')+"\r\n";}}return O;case"=":return R("=",n)+R("=",n);case "-":return R("-",n);case "/":for(int i=n;i>0;i--){O+="/".PadLeft(i)+"\r\n";}return O;case "x":int x=0;string[]r=new string[n];for(int i=n;i>0;i--){if(n-x-x<0){O+="x".PadLeft(x+1)+"\r\n";break;}string row=string.Join("",Enumerable.Repeat(" ",x))+"x"+string.Join("",Enumerable.Repeat(" ",n-x-x))+"x"+"\r\n";O+=row;x++;r[x]=row;if(i==n/2)break;}for(int i=r.Length-1;i>0;i--){if(string.IsNullOrEmpty(r[i]))continue;O+=r[i];}return O;default:return "";}}

Non golfé:

public string A(string s, int n)
{
  string O = "";

  Func<string, int, string> R = (a, b) =>
  {
    return string.Join("", Enumerable.Repeat(a, b)) + "\r\n";
  };

  switch (s)
  {
    case "+":
      for (int i = 0; i < n; i++)
      {
        if (i == n / 2)
        {
          O += R("+", n);
        }
        else
        {
          O += "+".PadLeft(n - n / 2, ' ').PadRight(n - n / 2, ' ') + "\r\n";
        }
      }
      return O;
    case "=":
      return R("=", n) + R("=", n);
    case "-":
      return R("-", n);
    case "/":
      for (int i = n; i > 0; i--)
      {
        O += "/".PadLeft(i) + "\r\n";
      }
      return O;
    case "x":
      int x = 0;
      string[] r = new string[n];
      for (int i = n; i > 0; i--)
      {
        if (n - x - x < 0)
        {
          O += "x".PadLeft(x + 1) + "\r\n";
          break;
        }
        string row = string.Join("", Enumerable.Repeat(" ", x))
          + "x"
          + string.Join("", Enumerable.Repeat(" ", n - x - x)) + "x" + "\r\n";
        O += row;
        x++;
        r[x] = row;
        if (i == n / 2)
          break;
      }
      for (int i = r.Length - 1; i > 0; i--)
      {
        if (string.IsNullOrEmpty(r[i]))
          continue;
        O += r[i];
      }
      return O;
    default:
      return "";
  }
}

Essai:

+: 3, 5, 7, 9, 11
/: 7, 8, 9, 10
-: 3, 4, 5, 6
=: 3, 4, 5, 6, 7
x: 5, 7, 9, 11

Trop de choses à coller et formater ici, j'ai créé une boîte à pâte:

Pastebin

C, 331 octets

i,j;f(o,n){if(47==o)for(i=n;i;puts("")){for(j=i--;j--;putchar(j?32:o)){}}
if(43==o)for(i=n;i--;puts("")){for(j=n;j--;printf(i==n/2||!j?"+ ":" ")){}}
if(45==o)for(i=n;i--;putchar(o)){}
if(61==o)for(i=3;i--;puts("")){for(j=n;j--;putchar(i&1?32:o)){}}
if(120==o)for(i=n;i;puts("")){for(j=0;j++<n;putchar(j==i||j==n-i+1?o:32)){}i--;}}

L'opérateur est transmis sous forme de code ASCII oet le nombre de caractères dans n. J'ai seulement ajouté des espaces entre les caractères consécutifs horizontalement dans le signe plus, car c'était le seul où la sortie aurait été déformée si je ne l'avais pas fait et dans la tâche, il a seulement dit "devrait". J'utilise deux boucles imbriquées pour le compte à rebours (sauf -lorsque je n'ai besoin que d'une seule ligne).

= Trois lignes, l'une d'entre elles vide, simple

+en utilisant à printfcause des espaces

- simple

/ avoir l'impression de la boucle intérieure à zéro et commencer au compteur de la boucle extérieure

x avoir l'impression de la boucle intérieure au compteur de la boucle extérieure et son "inverse" n-i . Encore faut-il voir pourquoi je suis hors-jeu ici.

Exemple d'appel:

#include <stdio.h>
/*  =       61
    +       43
    -       45
    /       47
    Space   32
    x       120
*/
int main(int argc, char **argv){
    printf("%s\n%s\n",argv[1], argv[2]);
    f(*argv[1],strtol(argv[2],NULL,10));
}

Lua, 402 344 312 octets

312:

r,p,b,x=string.rep,print,' ','x'function d(s,n)h,l=(n+1)/2,s..b;e=r(l,n)if s=='-'then p(e)elseif s=='='then p(e)p(e)else for f=1,n do p(s=='/'and(r(b,n-f)..s)or s=='+'and(f~=h and r(' ',n-1)..'+'or r('+ ',n))or f<h and r(b,f-1)..x..r(b,n-2*f)..x or f>h and r(b,n-f)..x..r(b,2*f-2-n)..x or r(b,f-1)..x)end end end

344:

r,p,b,x=string.rep,print,' ','x'function d(s,n)h,l=(n+1)/2,s..b;e=r(l,n)if s=='-'then p(e)elseif s=='='then p(e)p(e)else for f=1,n do if s=='/'then p(r(b,n-f)..s)elseif s=='+'then p(f~=h and r(' ',n-1)..'+'or r('+ ',n))elseif s=='x'then p(f<h and r(b,f-1)..x..r(b,n-2*f)..x or f>h and r(b,n-f)..x..r(b,2*f-2-n)..x or r(b,f-1)..x)end end end end

402:

r,p,b,x=string.rep,print,' ','x'function d(s,n)h=(n+1)/2;if s=='-'then p(r(s..b,n))end;if s=='='then p(r(s..b,n))p(r(s..b,n))end;if s=='/'then for i=1,n do p(r(b,n-i)..s)end end;if s=='+'then for i=1,n do p(i~=h and r(' ',n-1)..'+'or r('+ ',n))end end;if s=='x'then for i=1,n do if i<h then p(r(b,i-1)..x..r(b,n-2*i)..x)elseif i>h then p(r(b,n-i)..x..r(b,-n+2*i-2)..x)else p(r(b,i-1)..x)end end end end

90 caractères réduits et il est maintenant difficile de regarder même lorsqu'il est développé. : |