Vous travaillez en tant que stagiaire pour un mathématicien qui déteste vraiment TeX, LaTeX, etc. À tel point qu'il a décidé d'abandonner toute composition et de vous faire faire tout le formatage en ASCII. Vous en avez eu assez après un certain temps et avez décidé de commencer à automatiser certaines parties, en commençant par les racines carrées.

Voici comment une racine carrée est faite:

###  this is the input
###
###

_____  put a row of underscores stretching one character off either side on top
 ### 
 ### 
 ### 

   _____  put a diagonal of slashes in front going the height of the input
  / ### 
 /  ### 
/   ### 

      _____ put a diagonal of backslashes in front of that, going up half of the input's height rounded up
     / ###
 \  /  ###
  \/   ###

Et c'est tout!

Règles

Vous devez créer un programme ou une fonction qui prend une chaîne, une liste de chaînes (c'est-à-dire des lignes) ou un tableau de caractères, et génère l'entrée transformée conformément à la description ci-dessus (pas nécessairement selon le même ordre ou processus)

Vous pouvez supposer que l'entrée est rectangulaire si vous préférez. L'espace de fuite n'est ni requis ni interdit.

Il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte.

Exemples:

Input:
40
Output:
  ____
\/ 40

Input:
  ____
\/ 40
Output:
   ________
  /   ____
\/  \/ 40 

Input:
/| 
 | 
 | 
_|_
Output:
      _____
     / /|
    /   |
\  /    |
 \/    _|_

Input:
#  # 
#  # 
#####
   # 
   # 
Output:
        _______
       / #  #  
      /  #  #  
\    /   ##### 
 \  /       #  
  \/        #  

Python 2 , 196 octets

x=Q=input()
l=len(x)
k=(l+1)/2
q=l+k
x=[[' ']*(q+1)+list(y)for y in x]
for i in range(k):x[i+l/2][i]='\\'
for j in range(l):x[j][q-j-1]='/'
print'\n'.join([' '*q+'_'*(2+len(Q[0]))]+map(''.join,x))

Essayez-le en ligne!

-2 octets grâce à Step Hen

-13 octets grâce à Jonathan Allan

SOGL V0.12 , 27 octets

1w⁄2+╔*00žl»╚;lH╚@Κ№↕h┼№↕;┼

Essayez-le ici! ( →ajouté pour la facilité d'utilisation; le programme attend l'entrée sur la pile)

Fusain , 32 octets

ＷＳ⊞υιＰ⪫υ¶↖Ｐ×_⁺²⌈ＥυＬι↙↙Ｌυ↑↖÷⁺¹Ｌυ²

Essayez-le en ligne! Le lien est vers la version détaillée du code. Version 29 octets qui suppose une entrée rectangulaire:

ＷＳ⊞υιＰ⪫υ¶↖Ｐ×_⁺²Ｌθ↙↙Ｌυ↑↖÷⁺¹Ｌυ²

Python 3 , 138 147 octets

def f(l):h=len(l);w=len(l[0]);c=int(h/2);print('\n'.join([(h*2-c)*' '+w*'_']+[(i*' '+'\\'+(h-i-1)*2*' '+'/'+i*' ')[c:]+s for(i,s)in enumerate(l)]))

La variable 'l' est une liste de chaînes, chaque chaîne une ligne. Version lisible:

def f(l):
  height = len(l)
  width = len(l[0])
  half_height_floor = int(height / 2)

  print((height * 2 - half_height_floor) * ' ' + width * '_')

  for (index, line) in enumerate(l):
    #build a V based on the location of the line
    #surrounding V whitespace
    outer_space = index * ' '

    #inner V whitespace
    inner_space = (height - index - 1) * 2 * ' ' #inner v space

    #complete V
    v = outer_space + '\\' + inner_space + '/' + outer_space

    #left half_height_floor chars removed
    v_chopped = v[half_height_floor:]

    print(v_chopped + line)

Forme un symbole de racine carrée avec un V complet, puis rase la gauche en conséquence.

Essayez-le en ligne!

Python 2 ,  131  130 octets

x=input()
n=len(x)
s=" "
for v in[s*2*n+"_"*(2+len(x[0]))]+[s*i+"\\"+s*2*(n+~i)+"/"+s*-~i+r for i,r in enumerate(x)]:print v[n/2:]

Un programme complet prenant une liste de lignes en entrée avec l'allocation rectangulaire uniquement (en fait, la première ligne est l'une des plus longues).

Essayez-le en ligne!

Java 8, 244 octets

Une solution très longue, mais probablement proche de la plus courte pour Java. Ce lambda prend les lignes d'entrée en tant que a String[]et renvoie a String. Toutes les lignes doivent avoir la même longueur.

Sur la base des exemples de sorties, j'ai supposé qu'il n'était pas nécessaire d'ajouter un espace à chaque ligne de l'entrée, donc le programme ne le fait pas.

Merci à Jonathan Allan de m'avoir rappelé l' ~opérateur.

l->{int h=l.length,w=l[0].length(),a=h/2,i=w+3,x=h+a+h%2;String s="",t=s;for(;--i>0;)t+="_";for(;i++<x;)s+=" ";t=s+t;for(i=0;i<h;)t+="\n"+s.substring(0,i<a?x+~i:i-a)+(i<a?"":"\\"+s.substring(0,(h+~i)*2))+"/"+s.substring(0,i+1)+l[i++];return t;}

Essayez-le en ligne

Non golfé

l -> {
    int
        h = l.length,
        w = l[0].length(),
        a = h / 2,
        i = w + 3,
        x = h + a + h % 2
    ;
    String
        s = "",
        t = s
    ;
    for (; --i > 0; )
        t += "_";
    for (; i++ < x; )
        s += " ";
    t = s + t;
    for (i = 0; i < h; )
        t +=
            "\n"
            + s.substring(0, i < a ? x + ~i : i - a)
            + (i < a ? "" : "\\" + s.substring(0, (h + ~i) * 2))
            + "/"
            + s.substring(0, i + 1)
            + l[i++]
        ;
    return t;
}

Remerciements

• -2 octets grâce à Kevin Cruijssen

Japt , 46 octets

l *2
£Vç hY'\ h~Y'/ +S+XÃuVç +'_p2+Ug l¹msV/4

La nouvelle ligne de tête fait partie du programme. L'entrée et la sortie sont un tableau de chaînes représentant des lignes.

Essayez-le en ligne! en utilisant l' -Rindicateur pour joindre le tableau résultant avec des retours à la ligne.

JavaScript (ES6), 140 octets

Prend l'entrée comme un tableau de chaînes / renvoie un tableau de chaînes.

a=>[a[0].replace(/./g,'_'),...a].map((r,y)=>[...a,...a].map((_,x)=>x-y+1|y-.5<l/2?l*2-x-y?' ':'/':'\\',c=y?' ':'_').join``+c+r+c,l=a.length)

Cas de test

let f =

a=>[a[0].replace(/./g,'_'),...a].map((r,y)=>[...a,...a].map((_,x)=>x-y+1|y-.5<l/2?l*2-x-y?' ':'/':'\\',c=y?' ':'_').join``+c+r+c,l=a.length)

console.log(
  f([
    '40'
  ]).join`\n`
)

console.log(
  f([
    '  ____',
    '\\/ 40 '
  ]).join`\n`
)

console.log(
  f([
    '/| ',
    ' | ',
    ' | ',
    '_|_'
  ]).join`\n`
)

console.log(
  f([
    '#  # ',
    '#  # ',
    '#####',
    '   # ',
    '   # '
  ]).join`\n`
)

Perl 5 , 177 185 160 160 octets

$s=$f=int((@t=<>)*1.5+.5);print" "x$f;print"_"x length$t[0];print"_
";$b=-int(@t/2);for(0..$#t){--$s;print$_==$s?"/":$_==$b?"\\":" " for 0..$f;print$t[$_];++$b}

Essayez-le en ligne!

Journal des modifications:

• besoin de plus d'octets pour corriger un bogue (il supposait d'abord une entrée carrée )
• correction d'un autre bug et utilisation de quelques conseils de commentaires (merci Dada!)

C ++, 291 octets

La fonction suppose que toutes les chaînes du vecteur passées en paramètre ont la même longueur

#include<vector>
#include<string>
#define S std::string
#define T size()
void f(std::vector<S>&c){c.insert(c.begin(),S(c[0].T+1,'_'));int i,j=0;for(i=1;i<c.T;++i){c[i]='/'+S(i,' ')+c[i];if(i>=c.T/2)c[i]='\\'+S((c.T-i-1)*2,' ')+c[i];}for(auto&a:c)j=j>a.T?j:a.T;for(auto&a:c)a=S(j-a.T,' ')+a;}

Dyalog APL, 95 octets

{((' '/⍨y+x),'_'/⍨2+⊃⌽⍴⍵)⍪⍉(x-y)↓⍉(⊖(x(-x)↑⌽y y⍴'\',' '\⍨y←⌈x÷2),x x⍴'/',' '\⍨x←⊃⍴⍵),' ',⍵,' '}

Essayez-le en ligne!

C, 485 octets

Ce programme prend jusqu'à 999 caractères de l'entrée standard et les lit dans un tableau. Il les imprime 1 à la fois en sortie standard avec les modifications indiquées par votre défi. Il suppose que l'entrée est rectangulaire.

#include<stdio.h>
#define p(a)putc(a,stdout);
#define P j+j/2+1
a[999],i,j,k,l,m,n,q;char c;pad(a){m=P;if(a&&!k){m-=1;}for(n=0;n!=m;n++){q=32;if((!a||k)&&n==c){c--;q=47;}else if((P-c+1)>j/2+1&&(P)/2-n==c-2){q=92;}p(q);}}int main(){k=i=j=0;x:if(read(0,&c,1)){if('\n'==(a[i++]=c)){if(!j){l=i;}j++;}goto x;}i--;if('\n'==a[i-1]){i--;}else{j++;}c=P-2;for(;k!=i;k++){if(!k||a[k]==10){if(a[k]==10){p(10);}pad(1);if(!k){l++;while(l-->0){p(95);}p(10);pad(0);}if(a[k]==10){continue;}}p(a[k]);}}

Perl 5 , 159 octets

@a=map{$m=(y///c)>$m?y///c:$m;$_}<>;$_=$"x($l=@a/2-.5).'\\/'.$"x@a;for$i(1..@a){$a[-$i]=$_.$a[-$i];s| \\|\\ |;s|/ | /|;$i>$l&&y/\\/ /}chop;say$_.'_'x++$m,$/,@a

Essayez-le en ligne!