Il existe plusieurs façons de créer des en-têtes sur des publications sur le réseau Stack Exchange. Le format qui est le plus souvent ¹ utilisé sur PPCG semble être:

# Level one header
## Level two header
### Level three header

Notez l'espace après les marques de hachage. Notez également que les marques de hachage de fin ne sont pas incluses.

Défi:

Prenez une chaîne (éventuellement multiligne) en entrée et sortez la chaîne au format suivant:

• Si l'en-tête est de niveau 1, sortez chaque lettre 4 x 4 fois
• Si l'en-tête est de niveau 2, sortez chaque lettre 3 x 3 fois
• Si l'en-tête est de niveau 3, sortez chaque lettre 2 fois par 2
• Si une ligne n'est pas un en-tête, affichez-la telle quelle.

Pour illustrer:

--- Level 1 ---
# Hello
--- Output---
HHHHeeeelllllllloooo    
HHHHeeeelllllllloooo
HHHHeeeelllllllloooo
HHHHeeeelllllllloooo

--- Level 2 ---
## A B C def
--- Output ---
AAA   BBB   CCC   dddeeefff
AAA   BBB   CCC   dddeeefff
AAA   BBB   CCC   dddeeefff

--- Level 3 ---
### PPCG!
--- Output---
PPPPCCGG!!
PPPPCCGG!!

Aussi simple que cela!

Règles:

• Vous devez prendre en charge la saisie sur plusieurs lignes. L'utilisation de \netc. pour les sauts de ligne est OK.
  • Il n'y aura pas de lignes contenant seulement un #suivi d'un seul espace
• La sortie doit être présentée sur plusieurs lignes. Vous ne pouvez pas sortir à la \nplace de nouvelles lignes littérales.
  • Les espaces de fin et les nouvelles lignes sont OK.

Cas de test:

L'entrée et la sortie sont séparées par une ligne de ....

# This is a text
with two different
### headers!
........................................................    
TTTThhhhiiiissss    iiiissss    aaaa    tttteeeexxxxtttt
TTTThhhhiiiissss    iiiissss    aaaa    tttteeeexxxxtttt
TTTThhhhiiiissss    iiiissss    aaaa    tttteeeexxxxtttt
TTTThhhhiiiissss    iiiissss    aaaa    tttteeeexxxxtttt
with two different
hheeaaddeerrss!!
hheeaaddeerrss!!

This input has
## trailing hash marks ##
#and a hash mark without a space after it.
........................................................    
This input has
tttrrraaaiiillliiinnnggg   hhhaaassshhh   mmmaaarrrkkksss   ######
tttrrraaaiiillliiinnnggg   hhhaaassshhh   mmmaaarrrkkksss   ######
tttrrraaaiiillliiinnnggg   hhhaaassshhh   mmmaaarrrkkksss   ######
#and hash marks without a space after it.

# This ## is ### strange
#### ###
........................................................
TTTThhhhiiiissss    ########    iiiissss    ############    ssssttttrrrraaaannnnggggeeee
TTTThhhhiiiissss    ########    iiiissss    ############    ssssttttrrrraaaannnnggggeeee
TTTThhhhiiiissss    ########    iiiissss    ############    ssssttttrrrraaaannnnggggeeee
TTTThhhhiiiissss    ########    iiiissss    ############    ssssttttrrrraaaannnnggggeeee
#### ###

Multiple


### newlines! # 
:)
........................................................    
Multiple


nneewwlliinneess!!  ##
nneewwlliinneess!!  ##
:)

Line with only a hash mark:
#
### ^ Like that!
........................................................    
Line with only a hash mark:
#
^^  LLiikkee  tthhaatt!!
^^  LLiikkee  tthhaatt!!

^{1: Je n'ai pas vraiment vérifié, mais je pense que c'est vrai.}

Empilé , 51 50 octets

1 octet enregistré grâce à @RickHitchcock - regex golfé

['^(##?#?) (.+)'[\#'5\-@k CS k*k rep LF#`]3/mrepl]

Essayez-le en ligne!

Fonction anonyme qui prend l'entrée de la pile et la laisse sur la pile.

Explication

['^(##?#?) (.+)'[\#'5\-@k CS k*k rep LF#`]3/mrepl]
[                                            mrepl]   perform multiline replacement
 '^(##?#?) (.+)'                                     regex matching headers
                [                        ]3/         on each match:
                 \#'                                   count number of hashes
                    5\-                                5 - (^)
                       @k                              set k to number of repetitions
                          CS                           convert the header to a char string
                             k*                        repeat each char `k` times
                               k rep                   repeat said string `k` times
                                     LF#`              join by linefeeds

JavaScript (ES6), 111 105 octets

6 octets enregistrés grâce à @Shaggy

s=>s.replace(/^(##?#?) (.+)/gm,(_,a,b)=>`
${b.replace(/./g,e=>e.repeat(l=5-a.length))}`.repeat(l).trim())

Correspond à 1 à 3 hachages au début de la chaîne ou précédé d'une nouvelle ligne, puis répète chaque caractère de la correspondance avec la correspondance elle-même, en fonction de la longueur des hachages.

Cas de test:

let f=

s=>s.replace(/^(##?#?) (.+)/gm,(_,a,b)=>`
${b.replace(/./g,e=>e.repeat(l=5-a.length))}`.repeat(l).trim())

console.log(f('# This is a text\nwith two different\n### headers!'));
console.log('______________________________________________');
console.log(f('This input has\n## trailing hash marks ##\n#and a hash mark without a space after it.'));
console.log('______________________________________________');
console.log(f('# This ## is ### strange\n#### ###'));
console.log('______________________________________________');
console.log(f('Multiple\n\n\n### newlines! # \n:)'));
console.log('______________________________________________');
console.log(f('Line with only a hash mark:\n#\n### ^ Like that!'));

Retina , 125 104 octets

m(`(?<=^# .*).
$0$0$0$0
(?<=^## .*).
$0$0$0
(?<=^### .*).
$0$0
^# 
$%'¶$%'¶$%'¶
^## 
$%'¶$%'¶
^### 
$%'¶

Essayez-le en ligne

Enregistré 21 octets grâce à Neil.

MATL , 43 42 40 octets

1 octet supprimé grâce à Rick Hitchcock !

`j[]y'^##?#? 'XXgn:(2M4:QP&mt~+t&Y"0YcDT

Cela génère un espace de fin dans chaque ligne (autorisé par le défi) et se termine avec une erreur (autorisé par défaut) après avoir produit la sortie.

Essayez-le en ligne!

Explication

`            % Do...while loop
  j          %   Input a line as unevaluated string
  []         %   Push empty array
  y          %   Duplicate from below: push input line again
  '^##?#? '  %   Push string for regexp pattern
  XX         %   Regexp. Returns cell array with the matched substrings
  g          %   Get cell array contents: a string, possibly empty
  n          %   Length, say k. This is the title level plus 1, or 0 if no title
  :(         %   Assign the empty array to the first k entries in the input line
             %   This removing those entries from the input
  2M         %   Push k again
  4:QP       %   [1 2 3 4], add 1 , flip: pushes [5 4 3 2]
  &m         %   Push index of k in that array, or 0 if not present. This gives
             %   4 for k=2 (title level 1), 3 for k=3 (tile level 2), 2 for k=2
             %   (title level 1), and 0 for k=0 (no title). The entry 5 in the
             %   array is only used as placeholder to get the desired result.
  t~+        %   Duplicate, negate, add. This transforms 0 into 1
  t&Y"       %   Repeat each character that many times in the two dimensions
  0Yc        %   Postpend a column of char 0 (displayed as space). This is 
             %   needed in case the input line was empty, as MATL doesn't
             %   display empty lines
  D          %   Display now. This is needed because the program will end with
             %   an error, and so implicit display won't apply
  T          %   True. This is used as loop condition, to make the loop infinite
             % End (implicit)

Perl 5, 47 +1 (-p) octets

s/^##?#? //;$.=6-("@+"||5);$_=s/./$&x$./ger x$.

essayez-le en ligne

Fusain , 46 octets

ＦＮ«Ｓι≔⊕⌕Ｅ³…⁺×#κι⁴### θＦ⎇θ✂ι⁻⁵θＬι¹ι«Ｇ↓→↑⊕θκ→»Ｄ⎚

Essayez-le en ligne! Le lien est vers la version détaillée du code. Le charbon de bois ne fait pas vraiment d'entrée de tableau de chaînes, j'ai donc dû ajouter la longueur du tableau en entrée. Explication:

ＦＮ«Ｓι

Faites une boucle sur le nombre approprié de chaînes d'entrée.

≔⊕⌕Ｅ³…⁺×#κι⁴### θ

Créez un tableau de chaînes en prenant l'entrée et en préfixant jusqu'à 2 #, puis en tronquant à la longueur 4, puis essayez de trouver ###dans le tableau, puis convertissez en 1-indexation. Il en résulte un nombre inférieur de un au zoom de la lettre.

Ｆ⎇θ✂ι⁻⁵θＬι¹ι«

Si le zoom de la lettre est 1, faites une boucle sur toute la chaîne, sinon bouclez sur le suffixe approprié (qui est excessivement difficile à extraire dans Charcoal).

Ｇ↓→↑⊕θκ→

Dessinez un polygone rempli de la lettre se terminant dans le coin supérieur droit, puis déplacez-vous vers la droite, prêt pour la lettre suivante.

»Ｄ⎚

Imprimer la sortie et réinitialiser prêt pour la chaîne d'entrée suivante.

SOGL V0.12 , 31 28 octets

¶Θ{■^##?#? øβlF⁄κ6κ5%:GI*∑∙P

Essayez-le ici! - du code supplémentaire a été ajouté car le code est une fonction et prend des entrées sur la pile (SOGL ne peut pas prendre des entrées multilignes autrement: /) - inputs.value”- pousse cette chaîne, →- évalue comme JS, F- appelle cette fonction

Explication:

¶Θ                            split on newlines
  {                           for each item
   ■^##?#?                      push "^##?#? "
           øβ                   replace that as regex with nothing
             l                  get the new strings length
              F⁄                get the original strings length
                κ               and subtract from the original length the new strings length
                 6κ             from 6 subtract that
                   5%           and modulo that by 5 - `6κ5%` together transforms 0;2;3;4 - the match length to 1;4;3;2 - the size
                     :          duplicate that number
                      G         and get the modified string ontop
                       I        rotate it clockwise - e.g. "hello" -> [["h"],["e"],["l"],["l"],["o"]]
                        *       multiply horizontally by one copy of the size numbers - e.g. 2: [["hh"],["ee"],["ll"],["ll"],["oo"]]
                         ∑      join that array together - "hheelllloo"
                          ∙     and multiply vertiaclly by the other copy of the size number: ["hheelllloo","hheelllloo"]
                           P    print, implicitly joining by newlines

Proton , 130 octets

x=>for l:x.split("\n"){L=l.find(" ")print(L>3or L+len(l.lstrip("\#"))-len(l)?l:"\n".join(["".join(c*(5-L)for c:l[L+1to])]*(5-L)))}

Essayez-le en ligne!

Python 3 , 147 octets

def f(x):
	for l in x.split("\n"):L=l.find(" ");print(L>3or L+len(l.lstrip("#"))-len(l)and l or"\n".join(["".join(c*(5-L)for c in l[L+1:])]*(5-L)))

Essayez-le en ligne!

-1 octet merci à M. Xcoder

C # (.NET Core) , 268 + 18 octets

n=>{var r="";for(int l=0,c;l<n.Length;l++){var m=n[l];var s=m.Split(' ');var y=s[0];if(!y.All(x=>x==35)|y.Length>3|s.Length<2)r+=m+'\n';else for(int i=0,k=y.Length;i<5-k;i++){for(c=1;c<m.Length-k;)r+=new string(m.Substring(k,m.Length-k)[c++],5-k);r+='\n';}}return r;};

Essayez-le en ligne!

Python 3 , 131 octets

from re import*
print(sub("^(#+) (.*?)$",lambda x:((sub('(.)',r'\1'*(5-len(x[1])),x[2])+'\n')*(5-len(x[1])))[:-1],input(),flags=M))

Essayez-le en ligne!

J'ai utilisé Python 3 pour l'utiliser []avec regex.

PHP, 122 + 1 octets

for($y=$z=" "==$s[$i=strspn($s=$argn,"#")]&&$i?5-$i++:1+$i=0;$y--;print"
")for($k=$i;~$c=$s[$k++];)echo str_pad($c,$z,$c);

Exécuter en tant que pipe avec -nR(fonctionnera sur une ligne d'entrée après l'autre) ou essayez-le en ligne .

J , 55 octets

([:{:@,'^##?#? 'rxmatch])((1 1 4 3 2{~[)([:|:[$"0#)}.)]

Je ne sais pas comment faire fonctionner TIO avec J regex, donc je ne peux pas fournir de lien de travail.

Voici comment le tester dans l'interpréteur J (testé avec J804)

   f=.([:{:@,'^##?#? 'rxmatch])((1 1 4 3 2{~[)([:|:[$"0#)}.)]
   txt=.'# Hello'; '## A B C def'; '### PPCG!'; '#and a hash mark without a space after it.'; '##### ###'
   ; f each txt

HHHHeeeelllllllloooo                      
HHHHeeeelllllllloooo                      
HHHHeeeelllllllloooo                      
HHHHeeeelllllllloooo                      
AAA   BBB   CCC   dddeeefff               
AAA   BBB   CCC   dddeeefff               
AAA   BBB   CCC   dddeeefff               
PPPPCCGG!!                                
PPPPCCGG!!                                
#and a hash mark without a space after it.
##### ###

Je simule une chaîne multiligne à travers une liste de chaînes encadrées.

Python 2 , 126 124 117 117 octets

while 1:l=raw_input();i=l.find(' ');v=5-i*(l[:i]in'###');exec"print[l,''.join(c*v for c in l[i+1:])][v<5];"*(v>4or v)

Essayez-le en ligne!

ou

while 1:l=raw_input();i=l.find(' ');t=''<l[:i]in'###';exec"print[l,''.join(c*(5-i)for c in l[i+1:])][t];"*(t<1or 5-i)

Essayez-le en ligne!

JavaScript, 112 octets

x=>x.replace(/^(##?#?) (.*)/mg,(_,n,w)=>(t=>Array(t).fill(w.replace(/./g,c=>c.repeat(t))).join`
`)(5-n.length))

f=

x=>x.replace(/^(##?#?) (.*)/mg,(_,n,w)=>(t=>Array(t).fill(w.replace(/./g,c=>c.repeat(t))).join`
`)(5-n.length))

<textarea id=i style=display:block oninput=o.value=f(i.value)></textarea>
<output id=o style=display:block;white-space:pre></output>

C # 4,5 158 octets

Où i est l'entrée sous la forme d'une chaîne.

int l,m,t,s=0;while(i[s]=='#'){s++;};t=s>0?4-s+1:1;for(l=0;l<t;l++){foreach(char c in i.Skip(s>0?s+1:0))for(m=0;m<t;m++)Console.Write(c);Console.WriteLine();}