Sie arbeiten als Praktikant für einen Mathematiker, der TeX, LaTeX usw. wirklich hasst. So sehr, dass er beschlossen hat, alle Schriftsätze aufzugeben und Sie alle Formatierungen in ASCII vornehmen zu lassen. Nach einer Weile haben Sie es satt und beschlossen, Teile davon zu automatisieren, beginnend mit Quadratwurzeln.

So wird eine Quadratwurzel gebildet:

###  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
     / ###
 \  /  ###
  \/   ###

Und das ist es!

Regeln

Sie müssen ein Programm oder eine Funktion erstellen, die eine Zeichenfolge, eine Liste von Zeichenfolgen (dh Zeilen) oder ein Array von Zeichen aufnimmt und die gemäß der obigen Beschreibung transformierte Eingabe ausgibt (nicht unbedingt in genau derselben Reihenfolge oder demselben Prozess).

Bei Bedarf können Sie davon ausgehen, dass die Eingabe rechteckig ist. Nachgestellte Leerzeichen sind weder erforderlich noch unzulässig.

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

Beispiele:

Input:
40
Output:
  ____
\/ 40

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

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

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

Python 2 , 196 Bytes

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

Probieren Sie es online!

-2 Bytes dank Step Hen

-13 Bytes dank Jonathan Allan

SOGL V0.12 , 27 Bytes

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

Probieren Sie es hier aus! ( →zur Vereinfachung hinzugefügt; das Programm erwartet die Eingabe auf dem Stack)

Holzkohle , 32 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. 29-Byte-Version, die eine rechteckige Eingabe annimmt:

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

Python 3 , 138 147 Bytes

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

Die Variable 'l' ist eine Liste von Zeichenfolgen, wobei jede Zeichenfolge eine Zeile ist. Lesbare Version:

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)

Bildet ein Quadratwurzelsymbol mit einem vollständigen V und schneidet die linke Seite entsprechend ab.

Probieren Sie es online!

Python 2 ,  131  130 Bytes

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

Ein vollständiges Programm, das eine Liste von Zeilen als Eingabe verwendet, wobei nur ein Rechteck zulässig ist (tatsächlich ist die erste Zeile eine der längsten).

Probieren Sie es online!

Java 8, 244 Bytes

Eine sehr lange Lösung, aber für Java wahrscheinlich die kürzeste. Dieses Lambda nimmt Eingabezeilen als a String[]und gibt a zurückString . Alle Zeilen müssen gleich lang sein.

Anhand der Beispielausgaben ging ich davon aus, dass nicht an jede Zeile in der Eingabe ein Leerzeichen angehängt werden muss, das Programm also nicht.

Dank Jonathan Allan für mich daran erinnert , über den ~Betreiber.

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

Probieren Sie es online

Ungolfed

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

Danksagung

• -2 Bytes dank Kevin Cruijssen

Japt , 46 Bytes

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

Führende Newline ist Teil des Programms. Eingabe und Ausgabe ist ein Array von Zeichenfolgen, die Linien darstellen.

Probieren Sie es online! Verwenden Sie das -RFlag, um das resultierende Array mit Zeilenumbrüchen zu verbinden.

JavaScript (ES6), 140 Byte

Nimmt Eingaben als ein Array von Zeichenfolgen / gibt ein Array von Zeichenfolgen zurück.

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)

Testfälle

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 Bytes

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

Probieren Sie es online!

Änderungsprotokoll:

• brauchte mehr Bytes, um einen Fehler zu beheben (es wurde zuerst eine quadratische Eingabe angenommen )
• behebt einen weiteren Fehler und verwendet einige Tipps aus Kommentaren (Danke Dada!)

C ++, 291 Bytes

Die Funktion setzt voraus, dass alle Zeichenfolgen im als Parameter übergebenen Vektor dieselbe Länge haben

#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 Bytes

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

Probieren Sie es online!

C 485 Bytes

Dieses Programm nimmt bis zu 999 Zeichen aus der Standardeingabe auf und liest sie in ein Array. Es druckt sie jeweils 1 auf die Standardausgabe mit den von Ihnen angegebenen Änderungen. Es wird davon ausgegangen, dass die Eingabe rechteckig ist.

#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 Bytes

@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

Probieren Sie es online!