root of root of root of root

Question

This idea came to me when I saw my little brother playing with my calculator :D

The task

Taking a integer as an input, print that many graphical square roots under each other, like this:

n = 1

  ___
\/ 1


n = 3
    _______
   / _____
  / / ___
\/\/\/ 3


n = 5

      ___________
     / _________
    / / _______
   / / / _____
  / / / / ___
\/\/\/\/\/ 5


n = 10

           ______________________
          / ____________________
         / / __________________
        / / / ________________
       / / / / ______________
      / / / / / ____________
     / / / / / / __________
    / / / / / / / ________
   / / / / / / / / ______
  / / / / / / / / / ____
\/\/\/\/\/\/\/\/\/\/ 10

Each root consists of 4 parts, which I'm going to very scientifically name:

(s is the root size on the stack of roots, n is the input number, x is the number of digits)

1. The "tail", which is a single \
2. The "wall", which consists of / * s
3. The "roof", which consists of _ * 2 * s + x
4. And the number n under the smallest root, placed in the centre (leaving one empty space under the last _ in the smallest root)

Input

You must take input of the number n, no hardcoding the n

Output

The ascii roots your program made

This is a code-golf challenge, so lowest byte count for each language wins!

Answer 1

Python 2, 104 94 89 81 79 bytes

s=n=input()
while s:print' '*s,'/ '*(n-s)+'_'*(2*s+len(`n`));s-=1
print'\/'*n,n

Try it online!

Edit 1: Forgot I switched to python 2 lol

Edit 2: Thanks @ElPedro for the idea of switching to while loop!

Edit 3: Thanks @SurculoseSputum for saving 8 bytes!

Edit 4: Thanks @xnor for saving 2 bytes!

Answer 2

JavaScript (ES6),  104 102  99 bytes

A recursive function starting with the last line and using regular expressions to update each line above.

f=(n,s='\\/'.repeat(n)+(e=' ')+n)=>~n?f(n-1,e+s.replace(/\\/g,e).replace(/.(?!.*\/)/g,'_'))+`
`+s:e

Try it online!

How?

Initialization

We generate the bottom line with:

s = '\\/'.repeat(n) + (e = ' ') + n

For instance, this gives "\/\/\/\/ 4" for \$n=4\$.

Recursion

We get rid of the backslashes with:

s.replace(/\\/g, e)

We create the 'roof' or increase its size with:

.replace(/.(?!.*\/)/g, '_')

which means: replace with an underscore each character that doesn't have any slash on its right.

This leads to:

 _________
 / _______
 / / _____
 / / / ___
\/\/\/\/ 4

And with a leading space inserted at each iteration:

     _________ 
    / _______ 
   / / _____ 
  / / / ___ 
\/\/\/\/ 4 

Answer 3

Erlang (escript), 188 bytes

f(0,N)->string:copies("\\/",N)++" "++integer_to_list(N);f(X,N)->string:copies(" ",X+1)++string:copies("/ ",N-X)++string:copies("_",2*X+floor(math:log10(N)+1))++"
"++f(X-1,N).
f(N)->f(N,N).

Try it online!

Explanation

f(N)->f(N,N).   % Assign the counter to the input.
f(X,N)->        % While the counter isn't 0:
string:copies(" ",X+1)
                %     Repeat the space counter + 1 times

++string:copies("/ ",N-X)
                %     Repeat "/ " input - counter times

++string:copies("_",
                %     Repeat the "_" that many times:

2*X             %     The counter doubled
+floor(math:log10(N)+1)
                %     Plus the length of the digit(s) of the input
++"
"               %     Join the above, and append a newline
++f(X-1,N).     %     Decrement the counter by 1

f(0,N)->        % If the counter turns into 0:
string:copies("\\/",N)
                %     Repeat "\/" input times

++" "           %     Append a space
++integer_to_list(N);
                %     Append the number converted into a string
```

Answer 4

Mathematica (Notebook) 30 bytes

Only in Spirit ;-)

Nest[Defer@√#&,#,#]&@Input[]

produces the nested radicals

in the spirit but not the letter of the problem.

Explanation

Input[]              //take input

Nest[f,expr,n]       //apply f to expr n times i.e. f[f[f[f[f....[expr]]..]] with n fs
Nest[f,#,#]&         //define a lambda that applies f to arg #, # times
Nest[f,#,#]&@Input[] //apply the lambda Nest[f,#,#]& to the value of Input[]


√#&                  //define a lambda that puts arg # inside √
Defer@√#&            //define a lambda that puts arg # inside √ buts keeps the mathematical square root unevaluated

Nest[Defer@√#&,#,#]&@Input[]
                     //apply the lambda Defer@√#& to Input, Input no of times 

Answer 5

05AB1E, 30 bytes

-4 bytes thanks to Kevin Cruijssen.

Lε-„/ ×'_y·¹g+׫y>ú}R„\/¹×¹‚ª»

Try it online!

Answer 6

Pyth, 34 bytes

VQj*N"/ ",*hJ-QNd*+l`QyJ\_;jd,*"\/

Try it online!

VQ

Loop the variable N over 0 to Q (the input) minus 1

j*N"/ "

Join the following using N instances of "/ ":

,

The two element list of...

*hJ-QNd

... {Q - N + 1} space characters (d is the space character in Pyth). Store the value of Q minus N in the variable J so we can use it later.

*+l`QyJ\_

... {J times 2, plus the number of digits of Q} instances of the string "_"

;

End of loop

jd,*"\/

Join the following using a space:

• Q instances of the string "\/"

• Q casted to a string

Conveniently, the string literal is implicitly closed, and the two Qs are implicitly appended to the end of the program.

Answer 7

PowerShell, 88 84 bytes

param($n)1..$n|%{' '*($m=$n- --$_)+' /'*$_+' '+'_'*(2*$m+"$n".length)}
'\/'*$n+" $n"

Try it online!

Answer 8

Charcoal, 30 bytes

ＮηＧ↙η←⁺²Ｌθ↖η_Ｍη↘Ｐθ←←Ｆη«Ｐ↗⊕ι←/\

Try it online! Link is to verbose version of code. Explanation:

Ｎη

Input n as a number.

Ｇ↙η←⁺²Ｌθ↖η_

Print the "roof", ensuring that it is long enough to overhang n.

Ｍη↘Ｐθ←←

Print n as a string in the appropriate place.

Ｆη«

Loop n times.

Ｐ↗⊕ι

Print the next diagonal line of the "wall".

←/\

Print the next part of the "tail".

Answer 9

MATL, 43 bytes

:P"@QZ"47Oh1X@qX"95GVn@E+Y"hh]'\/'1GX"0GVhh

Try it online!

First time I have used X", Y", Z" in the same answer!

Answer 10

Jelly, 36 bytes

DLṭ1j+1,-,2×Ɱ$“ “/ “_”ẋ"ⱮṚṄ€ȧ⁾\/ẋ,⁸K

A full program which prints the result.

Try it online!

How?

DLṭ1j+1,-,2×Ɱ$“ “/ “_”ẋ"ⱮṚṄ€ȧ⁾\/ẋ,⁸K - Main Link: integer, n
D                                    - digits (n)
 L                                   - length
  ṭ1                                 - tack to one
    j                                - join with (n)
             $                       - last two links as a monad - f(n):
      1,-,2                          -   [1,-1,2]
            Ɱ                        -   map across [1..n] with:
           ×                         -     multiplication
     +                               - add (left to each of right, vectorised)
              “ “/ “_”               - [' ', '/ ', '_']
                        Ɱ            - map across (the list of list of numbers) with:
                       "             -   zipped:
                      ẋ              -     repetition
                         Ṛ           - reverse
                          Ṅ€         - print each with trailing newlines
                            ȧ        - logical AND (with n) -> n
                             ⁾\/     - ['\', '/']
                                ẋ    - repeat (n times)
                                 ,⁸  - pair with n
                                   K - join with a space
                                     - implicit print

Answer 11

MathGolf, 32 bytes

{kî-⌠ *_£(∞k£+'_*û/ ï*\n}û\/k* k

Try it online.

Explanation:

{             # Loop the (implicit) input amount of times:
 k            #  Push the input-integer
  î-          #  Subtract the 1-based loop-index
    ⌠         #  + 2
      *       #  And repeat that many spaces
 _            #  Duplicate this string
  £           #  Pop and push its length
   (          #  + 1
    ∞         #  * 2
     k        #  Push the input-integer again
      £       #  Pop and push its length
       +      #  Add those two integers together
        '_*  '#  And repeat that many "_"
 û/           #  Push the 2-char string "/ "
    ï*        #  And repeat it the 0-based loop-index amount of times
 \            #  Then swap the top two strings on the stack
 n            #  And push a newline character
}û\/k*        # After the loop: repeat 2-char string "\/" the input amount of times
              # Push a space
 k            # And push the input-integer
              # (after which the stack is joined together and output implicitly)

Answer 12

Wolfram Mathematica 120 bytes

a=StringRepeat;b=Print;Input[];
b[a[" ",#+1],a["/ ",%-#],a["_",2#+IntegerLength[%]]]&/@Range[%,1,-1];b[a["\/",%]," ",%];

Explanation

StringRepeat[str,n]         
                      //creates a string with str repeated n times

a=StringRepeat            
                      //alias for StringRepeat

Print[expr1,expr2,...]    
                      //prints expr1, expr2,... on a newline without separation

b=Print  
                      //alias for Print

Input[] 
                      //gets user input, 

;
                      //Hide implicit output

%   
                      //last output

IntegerLength[n]
                      //no of digits in n in base 10

a[" ",#+1]            
                     //Make a lamba StringRepeat with arg #, that prints " ",#+1 times

b[a[" ",#+1],a["/ ",%-#],a["_",2#+IntegerLength[%]]]& 

                     //Make a lambda with arg # that
                     //prints the appropriate "     /_________" 
                     //depending on #

b[....]&/@Range[%,1,-1]; 
                     //map the lambda b[....] over {%,%-1,%-2,...,1}

b[a["\/",%]," ",%]; 
                     //print the last row "\/\/\/...\/ "

Link to notebook

Answer 13

C# (Visual C# Interactive Compiler), 217 154 bytes

n=>Join("",Range(0,n).Select(i=>new S(' ',n-i+1)+new S('/',i*2)+new S('_',(n-i)*2-~(n+"").Length)+'\n').Concat(Repeat("\\/",n))).Replace("//", "/ ")+" "+n

Try it online!

Edit: Removed 19 bytes thanks to @KevinCruijssen, and used the header better(?)

Answer 14

Haskell, 129 bytes

x%s=[1..x]>>s
0#b=b%"\\/"++' ':show b
x#b=(x+1)%" "++(b-x)%"/ "++(show b>>"_")++x%"__"++'\n':(x-1)#b
f x=x#x
main=interact$f.read

Try it online!

Ties the existing 129 byte answer but is compliant with the challenge by performing full IO.

Answer 15

Retina 0.8.2, 77 bytes

^
$.'$*_=$'$*/¶$'$*V 
/
=$.%'$*=¶  $.%'$* $`
=
__
(_+)(/+)
$2$1
/
/ 
V
\/
1A`

Try it online! Explanation:

^
$.'$*_=$'$*/¶$'$*V 

Insert some working elements: enough _s to cover the input, a / for each input, then on the next line, a V for each input (representing \/) and a space.

/
=$.%'$*=¶  $.%'$* $`

Now expand the /s into a bottom right triangle, and also add extra _s to overhang on both sides on each line.

=
__

Expand the =s which were placeholders for two _s.

(_+)(/+)
$2$1

Move the input cover next to the rest of the overhang.

/
/ 

Space the /s apart.

V
\/

Expand the Vs on the last line.

1A`

Delete some left-overs.

Answer 16

Haskell, 129 bytes

r=replicate
c=(concat.).r
f n|s<-show n=unlines$map(\o->r(n-o+1)' '++c o"/ "++r(2*(n-o)+length s)'_')[0..n-1]++[c n"\\/"++" "++s]

Try it online!

Answer 17

Java 11, 137 124 bytes

n->{String l="\\/".repeat(n)+" "+n,r=l;for(;n-->0;r=l+"\n"+r)l=" "+l.replace('\\',' ').replaceAll(".(?!.*/)","_");return r;}

-13 bytes by porting @Arnauld's JavaScript answer, so make sure to upvote him!

Try it online.

Explanation:

n->{                       // Method with integer parameter and String return-type
  String l=                //  Temp-String `l` for the current line, starting at:
           "\\/".repeat(n) //   The input amount of "\/"
           +" "+n,         //   appended with a space and the input
         r=l;              //  Result-String, starting at this (last) line
  for(;n-->0               //  Loop `n` amount of times:
      ;                    //    After every iteration:
       r=l+"\n"+r)         //     Prepend the new `l` with newline to the result-String
    l=                     //   Change `l` to the new line:
      " "                  //    A space
      +l                   //    appended with the current line, with the replacements:
        .replace('\\',' ') //     All '\' replaced with spaces
        .replaceAll(".(?!.*/)","_");
                           //     And all characters NOT followed by a '/' with a "_"
  return r;}               //  And return the result-String after the loop

Answer 18

Julia, 107 bytes

n=parse(Int,readline())
println.([[" "^(s+1)*"/ "^(n-s)*"_"^(2s+length("$n")) for s=n:-1:1];"\\/"^n*" $n"])

Try it online!

Breakdown

n = parse(Int, readline())
println.([ # broadcasting with `.` applies `println` to each element of vector
    [
        " "^(s + 1)*"/ "^(n - s)*"_"^(2s + length("$n"))
        for s ∈ n:-1:1 # array comprehension
    ];   # semicolon enables blockmatrix-style array syntax...
         # ...which unpacks elements in array above into elements of vector
    "\\/"^n*" $n" # last element of vector
])

Answer 19

Python 3, 100, 99 bytes

n=int(input())
for i in range(n):print(" "*(n+~i)," /"*i,"_"*(2*n-2*i+len(str(n))))
print("\/"*n,n)

Try it online!

thnx to @KevinCruijssen for -1

Answer 20

Perl 5 -ap, 86 bytes

$\=$/.'\\/'x$_." $_";$_=$"x($_+1).'_'x(2*$_+y///c);for$a(1.."@F"-1){say;s, /| __,/ ,g}

Try it online!

Answer 21

CJam, 46 bytes

li:A:B;{A)S*"/ "BA-*'_2A*Bs,+*NA(:A}g"\\/"B*SB

Try it online!

Port of my Python answer

Explanation:

li            take input as integer
:A:B;         assign that to the variables A and B
{             start of while A loop
A)S*          push A-1 spaces
"/ "BA-*      push B-A strings of "/ "
'_2A*Bs,+*    push 2A + the number of digits _
N             push a newline
A(:A          decrement A
}g            end of while loop
"\\/"B*       push B \/
SB            push B after a space

Answer 22

Haskell, 122 bytes

x%y=[1..x]>>y
f x|n<-read x=unlines[(n+1-i)%" "++i%"/ "++(n-i)%"__"++(x>>"_")|i<-[0..n-1]]++n%"\\/"++' ':x
main=interact f

Try it online!

I've deliberately constrained myself to standard I/O. See my comments on the question.

Answer 23

Vyxal So, 30 bytes

ɾṘ›?ʀṪ‛/ *꘍?ɾd?L+\_*Ṙ+⁋,‛\/*$"

Try it Online!

This code's sorta backwards to reduce stack operations.

           ?ɾd                 # (1...input) * 2
              ?L+              # + log_10(input)
                 \_*           # That many underscores for each
                    Ṙ+         # Reverse that, and append to...
ɾṘ›                            # (2...input+1) reversed
          ꘍                    # For each, that many spaces appended to each of... 
   ?ʀṪ                         # 0...input-2
      ‛/ *                     # For each, that many copies of "/ "

                      ⁋,       # Print that, joined on newlines
                        ‛\/*   # Input * "\/"
                            $" # Paired with input
                               # (So flags) print that joined by a space

Answer 24

Perl 5, 96 bytes

sub f{$n=pop;join"\n",(map' 'x($x=1+$n-$_).'/ 'x$_.'_'x($x*2-2+length$n),0..$n-1),'\/'x$n." $n"}

Try it online!

Answer 25

PHP, 121 bytes

for($x=($i=$j=$argn)/10+1,$f=str_repeat;$i;$c.="/ ")printf("%{$i}s $c%s\n"," ",$f("_",2*$i--+$x));echo$f("\\/",$j)." $j";

Try it online!

This is not that great maybe, but I came with this.

Answer 26

Pyth, 54 44 bytes

VQ+d++*-QNd*"/ "N*+*2-QNl+""Q"_";++*"\/"hNdQ

Try it online!

edit 1: Thanks @mathjunkie for saving 10 bytes!

Answer 27

Pip, 38 bytes

Fi,aP[sYsXa-i"/ "Xi'_Ma.y.y]"\/"Xa.s.a

Try it online!

Explanation

This is one of those very rare occasions in Pip when a for loop seems to be the shortest solution.

Fi,aP[sYsXa-i"/ "Xi'_Ma.y.y]"\/"Xa.s.a
                                        s is space; a is 1st command-line arg (implicit)
Fi,a                                    For i in range(a):
    P                                    Print, with a newline
     [                     ]             the contents of this list, implicitly concatenated:
      s                                   A space
        sXa-i                             Space, repeated (a-i) times
       Y                                   also, yank that string into the y variable
             "/ "Xi                       "/ ", repeated (i) times
                      a.y.y               Concatenate a with y twice
                   '_M                     and replace each character with an underscore,
                                           giving a string of len(a) + 2 * (a-i) underscores
                            "\/"Xa      "\/", repeated (a) times
                                  .s    concatenated to space
                                    .a  concatenated to a
                                        Autoprint (implicit)

Answer 28

MAWP, 138 bytes

%@![1A~!~]%![!!!1M[84W;1A]%\A[95W2M;84W;1A]%2W1M3A{3M[29W1M5W;1A]25W;%1A}]~!!0/[25WP~1M~]%\1A3M[29W1M5W;1A]25W;%[99W25WM1M;95W2M;1A]%84W;:

Works as expected for single digit numbers, but beyond that, the last root will be longer than the others.

Try it!

Answer 29

Scala, 91 bytes

n=>print(n.to(1,-1).map{i=>" "*(i+1)+"/ "*(n-i)+"_"*(2*i+1)}:+("\\/"*n+" "+n)mkString "\n")

Try it online!

Answer 30

Husk, 46 bytes

`:§+*"¦/"o:' s¹z+mR' ṫ¹m§+*" /"(:' R'_+L¹D≠¹)ŀ

Try it online!