text:
Divisor skyline
For any positive integer \$k\$, let \$d(k)\$ denote the number of divisors of \$k\$. For example, \$d(6)\$ is \$4\$, because \$6\$ has \$4\$ divisors (namely \$1, 2, 3, 6\$).
Given a positive integer \$N\$, display a "skyline" in ASCII art using a fixed character, such that the height of the "building" located at horizontal position \$k\$ is \$d(k)\$ for \$k = 1, ..., N\$. See test cases below.
Rules

Any non-whitespace character may consistently be used, not necessarily # as shown in the test cases.
The algorithm should theoretically work for arbitrarily high \$N\$. In practice, it is acceptable if the program is limited by time, memory, data-type size or screen size.
Horizontally or vertically leading or trailing spaces or newlines are allowed.
Input and output can be taken by any reasonable means.
Programs or functions are allowed, in any programming language. Standard loopholes are forbidden.
Shortest code in bytes wins.

Test cases
N = 10:
     # # #
   # # ###
 #########
##########

N = 50:
                                               #
                                   #           #
                       #     #     #   # #     #
                       #     #     #   # #     #
           #     # #   #   # # #   #   # # ##  # #
           #   # # #   #   # # #   #   # # ##  # #
     # # # # ### # ### # ### # ##### ### # ### # #
   # # ### # ### # ### ##### # ##### ### # ### ###
 #################################################
##################################################

N = 200:
                                                                                #
                                                                                #
                                                                                #                                               #           #
                                                                                #                       #                       #           #
                                                                                #                       #                       #           #           #
                                                                                #                       #                       #           #           #
                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #
                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #
                                               #           #           #       #   #     #     #           #   #       #     #     #       #   #     #     #   # #     #       #   #           #     # #
                                   #           #           #           #       #   #     #     #   #       #   #       #     #     #       #   #     #     #   # #     #       #   #           #   # # #
                       #     #     #   # #     #     # #   #     #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #
                       #     #     #   # #     #     # #   #   # #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #
           #     # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # #   #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #
           #   # # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # ##  #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #
     # # # # ### # ### # ### # ##### ### # ### # ### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ####### ##### ### ##### # ######### # ##### ##### ### # ### ##### # ######### # ### # #
   # # ### # ### # ### ##### # ##### ### # ### ##### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ############# ### ##### # ######### # ##### ##### ### ##### ##### # ######### # ### # #
 #######################################################################################################################################################################################################
########################################################################################################################################################################################################

Jelly, 9 bytes
Uses 0 instead of #.
RÆD0ṁz⁶ṚY

Try it online!

5 minutes and 10 seconds :-)

I was reading other stuff in the meantime... I'll be faster next time.

Octave, 41 40 32 bytes
Thanks to @StewieGriffin saved 8 bytes.
@(N)" #"(sort(~mod(k=1:N,k'))+1)

Try it online!
Previous answers:
@(N)" #"(sort(~bsxfun(@mod,k=1:N,k')+1))

Try it online!
@(N)" #"(sort(ismember((k=1:N)./k',k))+1)

Try it online!
Explanation:
N=5;
d = (1:N)./(1:N)'    %divide each of numbers from 1 to N by 1 to N
                     %a [N by N] matrix created
d =

   1.00   2.00   3.00   4.00   5.00
   0.50   1.00   1.50   2.00   2.50
   0.33   0.66   1.00   1.33   1.66
   0.25   0.50   0.75   1.00   1.25
   0.20   0.40   0.60   0.80   1.00

m = ismember(d,1:N)      %find divisors of each number
m =

  1  1  1  1  1
  0  1  0  1  0
  0  0  1  0  0
  0  0  0  1  0
  0  0  0  0  1

idx = sort(m)                  %sort the matrix

idx =

  0  0  0  0  0
  0  0  0  0  0
  0  0  0  1  0
  0  1  1  1  1
  1  1  1  1  1

" #"(idx+1)     %replace 0 and 1 with ' ' and '#' respectively

   #
 ####
#####

Very nice approach!

Octave performs singleton expansion implicitly, so @(N)" #"(sort(~mod(k=1:N,k')+1)) saves you a few bytes :) You get a bunch of leading newlines though, I'm not sure what the rules are in that regard.

Same bytecount (32): @(N)['',35*sort(~mod(k=1:N,k'))].

@StewieGriffin Thanks! I didn't aware of that feature . Is mod(1:N,(1:N).')  acceptable in MATLAB?

I think it is possible as of R2016b, but I can't test it myself unfortunately, since I don't have it.

C, 99 95 92 91 90 bytes
c,l,i,j;f(n){for(j=n;j--;puts(""))for(i=0;i<n;c=!putchar(32|c>j))for(l=++i;l;c+=i%l--<1);}

See it work here.

Haskell, 71 bytes
f takes an Int and returns a String.
f m|l<-[1..m]=unlines[[last$' ':drop(m-i)['#'|0<-mod n<$>l]|n<-l]|i<-l]

Try it online!

m is the N of the OP (Haskell variables must be lowercase.)
The abbreviation l=[1..m] is used in the nested list comprehensions for iterating through all of rows, columns, and potential divisors. This means some extra initial rows filled with whitespace.
n is column (also number checked), i is row.
['#'|0<-mod n<$>l] is a list of '#' characters with length the number of divisors of n.

Python 3, 111 bytes
lambda n:'\n'.join([*map(''.join,zip(*['#'*sum(x%-~i==0for i in range(x))+n*' 'for x in range(1,n+1)]))][::-1])

Try it online!

This produces some leading vertical whitespace

109 bytes should do :)

Octave, 61 bytes
for i=1:input(''),p(1:nnz(~rem(i,1:i)),i)=35;end,[flip(p),'']

Explanation:
for i=1:input('')         % Loop, for i from 1 to the input value
 p(1:nnz(~rem(i,1:i)),i)=35;end,[flip(p),'']
% Breakdown:
         ~rem(i,1:i)      % Return true if the remainder of i divided by any of the values
                          % in the vector 1 - i
     nnz(~rem(i,1:i))     % Check how many of them are non-zero
 p(1:nnz(~rem(i,1:i)),i)=35;end   % Assign the value 35 (ASCII for #) to rows 1
                                  % to the number of divisors of i, in column i
end,              % End loop
[flip(p),'']      % Flip the matrix, and concatenate it with the empty string

A few things I wish to highlight

Takes the input directly into the loop

Doesn't assign the input value to any variable

Doesn't initialize any array

It creates it on the fly, adding columns and rows as necessary

Automatically casts ASCII-value 0 to whitespace (ASCII-32)

What happens inside the loop (suppose input 6)
p =  35
p =
   35   35
    0   35
p =
   35   35   35
    0   35   35
p =
   35   35   35   35
    0   35   35   35
    0    0    0   35
p =
   35   35   35   35   35
    0   35   35   35   35
    0    0    0   35    0
p =
   35   35   35   35   35   35
    0   35   35   35   35   35
    0    0    0   35    0   35
    0    0    0    0    0   35

Starts of as a single 35
Expands one column and one row, to make room for the two divisors of 2
Expands one column, to make room for 3 (only two divisors)
Expands one column and one row, to make room for the 3 divisors (1,2,4)
Expands one column, to make room for 5
Expands one column and one row, to make room for the 4 divisors (1,2,3,6)

Finally we flip it, and converts it to a string, implicitly changing the 0 to 32:
warning: implicit conversion from numeric to char
ans =
     #
   # #
 #####
######

C#, 333 281 Bytes
using System.Linq;using C=System.Console;class P{static void Main(){var n=int.Parse(C.ReadLine());var v=new int[n];for(var k=2;k<=n;k++)for(var i=1;i<k;i++)if(k%i==0)v[k-1]++;for(var i=0;i<v.Length;i++)for(var u=v.Max()-v[i];u<v.Max();u++){C.SetCursorPosition(i,u);C.Write("#");}}}

With line breaks:
using System.Linq;
using C = System.Console;

class P
{
    static void Main()
    {
        var n = int.Parse(C.ReadLine());
        var v = new int[n];
        for (var k = 2; k <= n; k++)
            for (var i = 1; i < k; i++)
                if (k % i == 0)
                    v[k - 1]++;
        for (var i = 0; i < v.Length; i++)
            for (var u = v.Max() - v[i]; u < v.Max(); u++)
            {
                C.SetCursorPosition(i, u);
                C.Write("#");
            }
    }
}

While I'm sure this is possible shorter as well, I hope we'll achieve a shorter solution together ;)
Saved 52 Bytes with the help of raznagul

If you use an int-array instead of a list, you can save a lot of bytes from the using-statement.

@raznagul updated it.

222 bytes: using System.Linq;using C=System.Console;n=>{var v=new int[n];for(var k=1,i;++k<=n;)for(i=1;i<k;)if(k%i++==0)v[k-1]++;for(var i=0,u;i<v.Length;i++)for(u=v.Max()-v[i];u<v.Max();){C.SetCursorPosition(i, u++);C.Write("#");}}; Compile to an Action, move the increments around and a couple of other minor tweaks. I haven't tested that but it should work.

@TheLethalCoder I'll test it / update my answer tomorrow.

Mathematica, 99 bytes
{T=DivisorSigma[0,Range@#];Row[Column/@Table[Join[Table[,Max[T]-T[[i]]],$~Table~T[[i]]],{i,1,#}]]}&

for N=50

Are all those spaces (and newlines) necessary for the code to run? I've never programming Mathematica myself, but in most languages you could remove almost all of those spaces.

this is my first golf. thanks for the tips

No problem, and welcome to PPCG! If you haven't yet, you might find Tips for golfing in  and Tips for golfing in Mathematica interesting to read through. :) Enjoy your stay.

The outer curly braces can be changed to round brackets to prevent them from showing in the output, and you can use some infix/prefix syntax to save 2 bytes: (T=0~DivisorSigma~Range@#;Row[Column/@Table[Join[Table[,Max@T-T[[i]]],$~Table~T[[i]]],{i,1,#}]])&

Mathematica, 59 57 bytes
Rotate[Grid@Map[X~Table~#&,0~DivisorSigma~Range@#],Pi/2]&

Welcome to answering on PPCG, fellow Lego minifig :-)

Now there's no turning back...

Welcome! Nice to see another Mathematica golfer. This answer isn't entirely valid though because you've hardcoded the input into the snippet. Answers need to be full programs or callable functions (which may be unnamed though). So this can be fixed at no cost by replacing 50 with # and appending &. You can save some bytes with infix notation as well: X~Table~#& and 0~DivisorSigma~Range@#

@MartinEnder Thanks. I forgot that bit when I moved from testing to answering. And thanks for the hint about infixing. Its not something I normally use (as I don't really golf).

39 bytes: the central part can be done with 0Divisors@Range@#+X and the presentation expression becomes Rotate[Grid[0Divisors@Range@#+X],Pi/2]&.

APL (Dyalog), 19 bytes
⊖⍉↑'#'⍴¨⍨+⌿0=∘.|⍨⍳⎕

Try it online!
⎕ get evaluated input (N)
⍳ 1...N
∘.|⍨ division remainder table with 1...N both as vertical and as horizontal axis
0= where equal to zero (i.e. it divides)
+⌿ sum the columns (i.e. gives count of divisors for each number)
'#'⍴¨⍨ use each number to reshape the hash character (gives list of strings)
↑ mix (list of strings into table of rows)
⍉ transpose
⊖ flip upside down

Charcoal, 23 22 20 bytes
Ｆ…·¹Ｎ«Ｊι⁰Ｆι¿¬﹪ι⁺κ¹↑#

Try it online! Link is to verbose version of code. Edit: Saved 1 byte by looping k from 0 to i-1 and adding 1 inside the loop. Saved a further two bytes by not storing the input in a variable. Explanation:
Ｆ…·¹Ｎ       for (i : InclusiveRange(1, InputNumber()))
«           {
 Ｊι⁰         JumpTo(i, 0);
 Ｆι          for (k : Range(i))
  ¿¬﹪ι⁺κ¹     if (!(i % (k + 1)))
   ↑#          Print(:Up, "#");
            }

Edit: This 18-byte "one-liner" (link is to verbose version of code) wouldn't have worked with the version of Charcoal at the time the question was submitted: Try it online!
↑Ｅ…·¹Ｎ⪫Ｅι⎇﹪ι⁺¹λω#ω

better explanation :P

Japt, 34 33 16 14 bytes
Saved 17 bytes thanks to @ETHproductions
õ@'#pXâ lÃ·z w

Try it online!

You can save a lot of bytes by just letting z do the padding: õ_â lÃ£'#pXÃ·z w

Didn't know that padded the strings automatically. Thanks!

Python 2, 101 bytes
N=input();r=range
for i in r(N,0,-1):print''.join('# '[i>sum(x%-~p<1for p in r(x))]for x in r(1,1+N))

Try it online!
This produces (a lot of) vertically leading whitespace.  It prints a total of N lines, the great majority of which will typically be blank.

SOGL V0.12, 8 bytes
∫Λ⁄╗*}⁰H

Try it here!

05AB1E, 12 bytes
Code:
LÑ€g'#×.BøR»

Explanation:
L             # Create the range 1 .. input
 Ñ            # Get the list of divisors of each
  €g          # Get the length of each element
    '#        # Push a hash tag character
      ×       # String multiply
       .B     # Squarify, make them all of equal length by adding spaces
         ø    # Transpose
          R   # Reverse the array
           »  # Join by newlines

Uses the 05AB1E encoding. Try it online!

Can't you use ζ instead of .Bø? Also, the character doesn't have to be #

ζ didn't exist back then.

R, 83 82 bytes
-1 byte thanks to MickyT
N=scan();m=matrix('#',N,N);for(i in 1:N)m[i,1:sum(i%%1:N>0)]=' ';write(m,'',N,,'')

Reads N from stdin.
N=scan()                        # read N
m=matrix('#',N,N)               # make an NxN matrix of '#' characters
for(i in 1:N)                   # for each integer in the range
    m[i,1:sum(i%%1:N!=0)]=' '   # set the first n-d(n) columns of row i to ' '
write(m,'',N,,'')               # print to console with appropriate formatting

Try it online!

!=0 can be >0

PowerShell, 101 bytes
((($d=1.."$args"|%{($x=$_)-(1..$_|?{$x%$_}).Count})|sort)[-1])..1|%{$l=$_;-join($d|%{' #'[$_-ge$l]})}

Less golfed test script:
$f = {

$d=1.."$args"|%{
    ($x=$_)-(1..$_|?{$x%$_}).Count
}                                     # $d is the Divisor count array
$maxHeight=($d|sort)[-1]
$maxHeight..1|%{
    $l=$_
    -join($d|%{' #'[$_-ge$l]})
}

}

@(
    ,(10,
    "     # # #",
    "   # # ###",
    " #########",
    "##########")

    ,(50,
    "                                               #  ",
    "                                   #           #  ",
    "                       #     #     #   # #     #  ",
    "                       #     #     #   # #     #  ",
    "           #     # #   #   # # #   #   # # ##  # #",
    "           #   # # #   #   # # #   #   # # ##  # #",
    "     # # # # ### # ### # ### # ##### ### # ### # #",
    "   # # ### # ### # ### ##### # ##### ### # ### ###",
    " #################################################",
    "##################################################")

    ,(200,
    "                                                                                #                    ",
    "                                                                                #                    ",
    "                                                                                #                                               #           #                    ",
    "                                                                                #                       #                       #           #                    ",
    "                                                                                #                       #                       #           #           #        ",
    "                                                                                #                       #                       #           #           #        ",
    "                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #",
    "                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #",
    "                                               #           #           #       #   #     #     #           #   #       #     #     #       #   #     #     #   # #     #       #   #           #     # #",
    "                                   #           #           #           #       #   #     #     #   #       #   #       #     #     #       #   #     #     #   # #     #       #   #           #   # # #",
    "                       #     #     #   # #     #     # #   #     #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #",
    "                       #     #     #   # #     #     # #   #   # #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #",
    "           #     # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # #   #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #",
    "           #   # # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # ##  #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #",
    "     # # # # ### # ### # ### # ##### ### # ### # ### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ####### ##### ### ##### # ######### # ##### ##### ### # ### ##### # ######### # ### # #",
    "   # # ### # ### # ### ##### # ##### ### # ### ##### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ############# ### ##### # ######### # ##### ##### ### ##### ##### # ######### # ### # #",
    " #######################################################################################################################################################################################################",
    "########################################################################################################################################################################################################")

) | % {
    $n,$expected = $_
    $result = &$f $n
    "$result"-eq"$expected"
    #$result    # uncomment this to enjoy the view of the Divisor skyline
}

Output:
True
True
True

Husk, 13 11 bytes
↔T' †K'#mḊḣ

Try it online!
-2 bytes from Ko King(No, not JoKing).

Don't you mean JoKing?

@Lyxal Absolutely not

Who is this ko king?

Here.

J, 28 bytes
[:|:&.|.[('#',@$~1+_&q:)@-i.

Defines a monadic verb.
Try it online!
Explanation
[:|:&.|.[('#',@$~1+_&q:)@-i.  Input is y.
                          i.  Range from 0 to y-1
        [                -    subtracted from y (gives range from y to 1).
         (             )@     For each of the numbers:
                   _&q:         Compute exponents in prime decomposition,
                 1+             add 1 to each,
          '#'  $~               make char matrix of #s with those dimensions,
             ,@                 and flatten into a string.
                              The resulting 2D char matrix is padded with spaces.
[:|:&.|.                      Reverse, transpose, reverse again.

Brachylog, 34 bytes
⟦fᵐlᵐgDh⌉⟦↔gᵐ;D↔z{z{>₁∧0ṫ|∧Ṣ}ᵐcẉ}ᵐ

Try it online!

PHP, 126 Bytes
for(;$n++<$argn;)for($c=$d=0;$d++<$n;)$n%$d?:$r[$n]=++$c;for($h=max($r);$h--;print"
")for($n=0;$n++<$argn;)echo$h<$r[$n]?:" ";

Try it online!

Alice, 33 bytes
I.!.t&w?t!aot&wh.Bdt.?-ex' +o&;k@

Try it online!
Input is (unfortunately) in the form of a code point. At least it reads a UTF-8 character, so you can use larger inputs than 255, but they're still limited and it's a pretty painful input format. For three additional bytes, we can read a decimal integer:
/
ki@/.!.t&w?t!aot&wh.Bdt.?-ex' +o&;

Try it online!
The non-whitespace character in the output is !.
Note that the solution also prints a ton of leading whitespace (it always starts with an empty line and then prints an NxN grid so for larger N, there will be many lines of spaces before the first !s.)
Explanation
I've used and explained the &w...k construction before (for example here). It's a neat little idiom that pops an integer n and then runs a piece of code n+1 times (consequently, it's usually used as t&w...k to run a loop n times, with t decrementing the input value). This is done by working with the return address stack (RAS). w pushes the current IP address to the RAS, and if we repeat it with & then the address gets pushed n times. k pops one address from the RAS and jumps back there. If the RAS is empty, it does nothing at all and the loop is exited.
You might notice that it's not trivially possible to nest these loops, because at the end of the inner loop, the stack isn't empty, so the k doesn't become a no-op. Instead, the IP would jump back to the beginning of the outer loop. The general way to fix this involves wrapping the inner loop in its own subroutine. But if we can arrange the nested loop such that the outer loop ends with the inner loop, we can actually make use of this behaviour and even save on one k!
So this construction:
&wX&wYk

Is a working nested loop which runs the XYYYXYYYXYYY... (for some number of Ys in each iteration). It's pretty neat that we can end both loops with a single k, because it will consume an outer address from RAS each time the inner addresses have been depleted.
This idiom is used in the program to run the loop over the output grid.
I         Read a character and push its code point as input N.
.!        Store a copy on the tape.
.         Make another copy.
t&w       Run this outer loop N times. This loops over the lines of the
          output, so the current iteration corresponds to a divisor count
          no more than i (i counting down from N).
  ?t!       Decrement the value on the tape. That means we'll actually have
            i-1 on the tape during the iteration.
  ao        Print a linefeed. Doing this now leads to the weird leading linefeed,
            but it's necessary for the &w...&w...k pattern.
  t&w       Remember that we still have a copy of N on the stack. We'll also
            ensure that this is the case after each loop iteration. So this
            also runs the inner loop N times. This iterates over the columns
            of the output grid so it's j that goes from 1 to N and corresponds
            to the number whose divisors we want to visualise.
              At this point the stack will always be empty. However, operating
              on an empty stack works with implicit zeros at the bottom of
              the stack. We'll use the top zero to keep track of j.
    h         Increment j.
    .B        Duplicate j and push all of its divisors.
    dt        Push the stack depth minus 1, i.e. the divisor count of j.
    .         Duplicate the divisor count.
    ?-        Retrieve i-1 from the tape and subtract it. So we're computing
              d(j)-i+1. We want to output a non-whitespace character iff this
              value is positive (i.e. if i is no greater than d(j)).
    ex        Extract the most significant bit of this value. This is 1 for
              all positive values and 0 for non-positive ones. It's the shortest
              way (I believe) to determine if a value is positive.
    ' +       Add this to the code point of a space. This gives a 33, or '!',
              if the cell is part of the skyline.
    o         Output the character.
    &;        We still have all the divisors and the divisor count on the stack.
              We pop the divisor count to discard that many values (i.e. to
              get rid of the divisors again).
k         Return to the appropriate loop beginning to run the continue the
          nested loop.
@         Terminate the program.

First Alice program with a single line ever? :-)

@LuisMendo No, I think Leo has written a few Cardinal-only programs (and maybe I have as well... the quine and the Hello, World for example). Probably the most elaborate single-line program though. :)

Hmm, my solution could save some bytes with "ton of leading whitespace" trick

Actually, 25 bytes
R♂÷♂l;M' *╗⌠'#*╜@+⌡M┬♂ΣRi

Try it online!
22-byte version with a lot of leading newlines
;╗R⌠÷l'#*╜' *@+⌡M┬♂ΣRi

Try it online!

Okay, the Readme on the github should be updated to include ÷l as the standard divisor counting function...

PHP, 99 bytes
for(;$d<$k?:$k++<$argn+$d=$n=0;)$k%++$d?:$r[--$n]=str_pad($r[$n],$k).H;ksort($r);echo join("
",$r);

prints one leading space; run as pipe with php -nr '<code>' or try it online.
breakdown
for(;$d<$k?:                    # inner: loop $d from 1 to $k
    $k++<$argn+$d=$n=0;)        # outer: loop $k from 1 to $argn, reset $d and $n
    $k%++$d?:                       # if $d divides $k
        $r[--$n]=str_pad($r[$n],$k).H;  # add one store to building $k
ksort($r);echo join("\n",$r);   # reverse and print resulting array

SpecBAS - 149 bytes
1 INPUT n: DIM h(n)
2 FOR i=1 TO n
3 FOR j=1 TO i
4 h(i)+=(i MOD j=0)
5 NEXT j
6 NEXT i
7 FOR i=1 TO n
8 FOR j=51-h(i) TO 50
9  ?AT j,i;"#"
10 NEXT j
11 NEXT i

An array keeps track of number of divisors, then prints the right number of characters down to screen position 50.

Wolfram Language (Mathematica), 46 44 bytes
Grid[PadLeft[0Divisors@Range@#-" "]+" "]&

Try it online!  But maybe try it online! with ColumnForm instead of Grid, since Grid doesn't work in TIO. In Mathematica, it looks better:

A third Mathematica solution... Divisors@Range@# finds all the divisors in the range we want, and then we multiply by 0 and subtract " ", making every divisor equal to -" ".
PadLeft adds zeroes on the left, creating a sideways skyline, whose orientation we fix with =\[Transpose]. Finally, adding " " to everything makes all entries either 0 or " ".
As an alternative, the 59-byte ""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]& produces string output.

Add++, 58 bytes
D,g,@,FL1+
D,k,@~,J
L,R€gd"#"€*$dbM€_32C€*z£+bUBcB]bR€kbUn

Try it online!
How it works
Our program consists of two helpers functions, g and k, and the main lambda function. g iterates over each integer, \$x\$, between \$1\$ and \$n\$ and returns \$d(x)\$ as defined in the challenge body, while k takes a list of characters and concatenates them into a single string.
The main lambda function generates \$A = [d(1), d(2), d(3), ..., d(n)]\$, then repeats the # character for each element of \$A\$. We then take \$\max(A)\$, and subtract each element in \$A\$ from this maximum, before yielding this number of spaces for each element and concatenating the spaces to the repeated hashes. Next, we transpose and reverse the rows, before joining each line on newlines. Finally, we output the skyline.

Vyxal, L, 6 5 bytes
ƛKL×*

Try it Online!
Explained
ƛKL×*
ƛ       # Over the range [1, input] do the following:
 KL     #   Push the length of the list of that number's divisors
   ×    #   Push '*'
    *   #   And multiply the two together, repeating the "*"
        # Automatically close the map and then use the L flag to vertically join that list

ƛ this character been exercising(also this answer is scarily short)

It is spooktober after all lol

It's incredible how many M flags my suggestion has reduced...

@2x-1 I know. Thank you!

05AB1E, 7 bytes
LÑ_ζRJ»

Uses 0 (or 1) instead of #.
Try it online.
Explanation:
L        # Push a list in the range [1, (implicit) input]
 Ñ       # Convert each value to a list of its divisors
  _      # Convert each inner integer to 0
   ζ     # Zip/transpose; swapping rows/columns, with space as default filler
    R    # Reverse the list of lists
     J   # Join each inner list together
      »  # And then join the list of strings by newlines
         # (after which the result is output implicitly)

The _ (==0) has some a few alternatives to get distinct values: a (is_alphabetic); Ā (!=0); d (>=0):
try it online.

Pyth, 16 bytes
j_.tm*\#/%LdSQ0S

Try it online!

Japt -R, 10 bytes
Uses 1 instead of #.
õ_â mÎ¬ÃÕÔ

Try it
õ_â mÎ¬ÃÕÔ     :Implicit input of integer U
õ              :Range [1,U]
 _             :Map
  â            :  Divisors
    m          :  Map
     Î         :    Sign
      ¬        :  Join
       Ã       :End map
        Õ      :Transpose
         Ô     :Reverse
               :Implicit output joined with newlines

Redefining the concept of "one up" :-)

Stax, 11 bytes
ñ┌½♠å←ⁿ╨║x╦

Run and debug it


text:
Venn Diagram Cells
Given multiple sets, e.g. s1={2,3,7}, s2={1,2,4,7,8} and s3={4,7}, a Venn diagram visualizes each set by a closed curve and set elements which are either inside or outside the curve's perimeter, depending on whether they are element of the set or not. Because all set elements appear only once in the Venn digram, the curves representing each set need to overlap if an element is present in more than one set. We call each such overlapping a cell of the Venn diagram.
This explanation might be a bit confusing, so let's have a look at an example.
Example
A Venn diagram for sets s1, s2 and s3 could look like this:

The cells of this Venn diagram are (read from top to bottom, left to right) {1,8}, {2}, {7}, {4}, {3}, {} and {}.
In practice, one commonly encounters only Venn diagrams of two or three sets, because the representation of Venn diagrams of four or more sets is not very clear. However they do exist, e.g. for six sets:

CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=1472309
The Task
Given a non-empty set of sets of positive integers in any reasonable representation, return the set of cells of the input sets' Venn diagram. Specifically, no graphical representation is needed.

You may write a full program or a function.
You may return as many empty sets as there are empty cells (i.e. a list of all cells) instead of just one empty set (i.e. the set of cells).
Some reasonable ways of input for the above example include but are not limited to {{2,3,7},{1,2,4,7,8},{4,7}}, [[2,3,7],[1,2,4,7,8],[4,7]], "2,3,7;1,2,4,7,8;4,7" or "2 3 7\n1 2 4 7 8\n4 7". If in doubt whether your chosen input format is acceptable, feel free to ask in a comment.
Your output format should match your input format, if possible. Note that this rule requires your format to be able to unambiguously display empty sets.
This is code-golf, so try to use as few bytes as possible in the language of your choice. In order to encourage competition per language instead of between languages, I won't accept an answer.

Test Cases
Here are some inputs along with possible outputs:
input -> output
{{2,3,7},{1,2,4,7,8},{4,7}} -> {{1,8},{2},{7},{4},{3},{}} (or {{1,8},{2},{7},{4},{3},{},{}})
{{1,2,3},{4,5,6},{7,8,9}} -> {{1,2,3},{4,5,6},{7,8,9},{}}
{{}} -> {{}}
{{1,2,3},{1,2}} -> {{1,2},{3},{}}
{{4,3,8},{1,2,9,3},{14,7,8,5},{6,11,3,8},{10},{9,4,3,7,10}} -> {{6,11},{10},{4},{3},{8},{5,14},{1,2},{9},{7},{}}
{{2,3,4,7},{},{1,3,7,5,6},{2,3,7,5},{7,2,4,3,6},{1,4,5}} -> {{},{4},{2},{7,3},{1},{6},{5}}
{{1,2,3,4},{1,2,5,6},{1,3,5,7}} -> {{4},{3},{2},{1},{6},{5},{7}}

I'm assuming this is true because of the definition of a set, but may we assume that there will be no duplicates within one of the subsets?

@Hyper Neutrino Yes, you can assume all sets are duplicate free.

Perhaps you could add a test case where none of the cells are empty. E.g. {{1,2,3,4},{1,2,5,6},{1,3,5,7}}.

How does the second one not give {{1,2,3},{4,5,6},{7,8,9},{},{},{},{}}?

@Leaky Nun You are allowed to return either the set of cells or the list of cells. Appart from the first example, the test cases give only the set version, so all empty sets collapse into a single empty set. This means that your output is acceptable, too.

Do I understand right that "you may return as many empty sets as there are empty cells" will pad the output to 2^n-1 entries, where n is the numbers of sets in the input? An the Venn diagram exterior is not a cell?

@ØrjanJohansen Thanks, added the tescase.

@xnor Yes, exactly.

I always saw a 6-set Venn Diagram like this: http://4.bp.blogspot.com/-VEml0lMUxcM/UvwDoZ1bAZI/AAAAAAAAHPQ/ozJI18BlkLI/s1600/Large_venn.jpg

@carusocomputing Upon closer inspection you will find that this is not a true Venn diagramm because some possible overlappings are missing.

Haskell, 71 bytes
An anonymous function taking a list of lists of integers and returning a similar list.
Use as (foldr(\x r->(x\\(id=<<r)):([intersect x,(\\x)]<*>r))[])[[1,2,3],[1,2]].
import Data.List
foldr(\x r->(x\\(id=<<r)):([intersect x,(\\x)]<*>r))[]

Try it online!
How it works

Uses the set-like operations \\ (difference) and intersect from Data.List.
Folds the list of "sets" (represented as lists) into a list of cells, starting with the empty list [].
x is the current set to be added to the diagram, and r is the list of cells already constructed.

x\\(id=<<r) is the subset of elements of x that are not in any of the already constructed cells.
[intersect x,(\\x)]<*>r splits up each cell in r according to whether its elements are in x or not.

Most definitely does not attempt to merge empty cells, so there are quite a bit of those in the output.

The same idea as my implementation, but two bytes shorter. Well done!

Perl 5, 79 bytes
sub{for$.(0..@_){$x{$_}+=2**$.for@{$_[$.]}};push@{$h{$x{$_}}},$_ for keys%x;%h}

Takes input as a list of anonymous arrays like ([2,3,7],[1,2,4,7,8],[4,7]). Outputs a hash where the keys are labels and the values are anonymous arrays corresponding to the output sets.
As part of a full program:
*x=
sub{for$.(0..@_){$x{$_}+=2**$.for@{$_[$.]}};push@{$h{$x{$_}}},$_ for keys%x;%h};
%x=x([2,3,7],[1,2,4,7,8],[4,7]);
print"Set $_:@{$x{$_}}\n"for keys%x;

Explanation:
Gives each set an integer as a label, $.. Creates a hash that stores an integer for each unique element $_. Adds 2**$. for each set that $_ appears in, effectively making a binary map showing what sets each element appears in. Finally, makes an anonymous array for each cell of the Venn diagram and pushes the elements appearing in the corresponding sets to the array. So each element of each array exists in the same sets and thus the same cell of the Venn diagram.

Jelly, 14 17 bytes
FṀ‘³iþ¬Ḅµ;ṀḶ$ĠṖṖ€

Try it online!
Function submission (because the format Jelly prints lists in by default doesn't round-trip – it can't read its own output format – but a function inputs and outputs in the same format). The TIO link contains a footer that runs the function and prints its output in the same format that input is parsed.
Explanation
FṀ‘³iþ¬Ḅµ;ṀḶ$ĠṖṖ€
FṀ‘               Find the largest number that appears in any of the input sets, + 1
   ³ þ            For each number from 1 to that number, and each of the input sets
    i ¬             find whether the number is missing from the set
       Ḅ          Convert the list of missing sets into a single number using binary
         ;        Append
        µ ṀḶ$     all numbers from 0 to the maximum value minus 1
             Ġ    Group indexes by values
              ṖṖ€ Delete the last group and last element of other groups

The requirement that we output at least one empty set if not all the Venn diagram sections are used manages to take up over half the program here (it's responsible for the ’ that makes sure we have at least one group for non-matching elements, allowing us to keep track of how many sets there were originally, plus the last nine bytes of the source code except for the Ġ). The basic way in which we implement it is to ensure that all the 2^n Venn diagram subsets have at least one entry, by adding a dummy entry that will fill the "in no sets" section and (later) a dummy entry to each other section, then Ġ will output a group for each subset, which we can remove using ṖṖ€.

Um there's no restriction to at most 7 sets, and one of the test cases has more.

I assumed the original set had length 3, because that's how Venn diagrams work, but apparently not? In that case, perhaps I need a different way to add the empty set only if not all the sections of the Venn diagram are filled. That's something of a nasty blemish on what's otherwise a fairly elegant question.

Well you could replace 7 by 2^n-1, I assume.

I found a way to get at the 2^n-1 value that matches the spec, but it's painfully long. Hopefully there's a shorter way, but even so, this question is frustrating.

Pyth, 11 bytes
m-@Fds-Qdty

Test suite.
How it works
Each region of the Venn diagram represents elements that are in [certain combinations of the sets] but not in [the other sets].
So, we generate all the possible combinations (and remove the empty combinations) by finding the power set of the input.
For each combination generated, we find the intersection of the sets in the combination, and filter out the elements which are in the other sets.
m-@Fds-Qdty  input as Q
          y  power set
         t   remove the first one (empty combination)
m            for each combination d:
  @Fd            find the intersection of all the sets in d
 -               filter out those who are in
     s               the union of
      -Qd            the sets not in the combination
                     (input minus combination)

JavaScript (ES6), 123 bytes
a=>a.map((b,i)=>b.map(e=>m[e]|=1<<i),m=[])&&[...Array(1<<a.length)].map((_,i)=>m.map((e,j)=>e==i&&j).filter(j=>j)).slice(1)

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Easier communication means… ○ circular edition!
Based on this, but I was asked[1],[2] to do a graphical edition.

Task
Generate a circular display of the text EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS . Any uppercase font goes. The letter tops must face out of the circle. Either the space before FEWER must be at the bottom (6 o'clock) or (for brownie points) your text must rotate.

@Uriel Well, nominally, each letter takes 5.45°, so shall we say 5.4° to 5.5°?

I believe that would be a good precision, considering the 2/21 approximation error is small than 0.002.

Octave, 168 bytes
for i=1:(n=nnz(s='CATION MEANS FASTER CODING MEANS FEWER CODERS MEANS EASIER COMMUNI')),text(sin(i/n*2*pi),cos(i/n*2*pi),s(i),'rotation',-i/n*360);axis([-2,2,-2,2]);end

Try it here

Nice! It seems axis([-2,2,-2,2]); is not needed. But you may want to add axis equal at the end to get a true circle

what do you do with the for loop? Can you add an explanation for an Octave novice like me?

Of course, I'll add an explanation when I have the time. Hopefully later today :-)

Mathematica, 153 Bytes
x=Pi/33;Graphics@Map[StringSplit["CATION MEANS FASTER CODING MEANS FEWER CODERS MEANS EASIER COMMUNI",""][[#/x]]~Text~{Sin@#,Cos@#}~Rotate~-#&,Range@66x]

Increasing it to 178 bytes lets it rotate:
x=Pi/33;Graphics@Map[StringSplit["CATION MEANS FASTER CODING MEANS FEWER CODERS MEANS EASIER COMMUNI",""][[#/x-a]]~Text~{Sin@#,Cos@#}~Rotate~-#&,(a+Range@66)x]~Animate~{a,1,66,1}

HTML and JS, 13 + 170 = 284 227 192 186 183  bytes
41 bytes saved thanks to @Shaggy

(x=c.getContext("2d")).translate(r=c.height/2,r)
for(i in t="CATION MEANS FASTER CODING MEANS FEWER CODERS MEANS EASIER COMMUNI"){x.rotate(2/21);x.fillText(t[i],0,-r*.8)}
<canvas id=c height=250 width=250>

The width and height set to 250 to allow better visibility were not included in the bytes count.

Reduce your JS to 223 bytes with (x=c.getContext("2d"))[t="translate"](r=c.height/2,r,i=66);r*=.8;while(i--){x.rotate(a=i*Math.PI/33);x[t](0,-r);x.fillText("EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "[i],0,0);x[t](0,r);x.rotate(-a)}.

Or, reduce the latest version of your JS to 179 bytes with (x=c.getContext("2d")).translate(r=c.height/2,r);r*=.8;for(i in t="EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "){x.rotate(Math.PI/33);x.fillText(t[i],0,-r)}

If you're happy to sacrifice a little bit of precision, you could replace Math.PI with 22/7 to save another 6 bytes.

and Math.PI/33 ≈ 2/21, but is that considered ok?

You might need to run it past @Adám for confirmation.

@Uriel 2/21 is fine. I can't tell the difference.

You can save some bytes using es6 for...of: for(c of"CATION... and x.fillText(c,

Bash + ImageMagick, 168 bytes
convert -font $(convert -list font|grep Font:|head -n1|cut -d" " -f4) label:"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS " -distort Arc 360 i.png

Example output:

I think you can use a fixed font name to shorten it.

BBC BASIC, 248
Download interpreter at http://www.bbcbasic.co.uk/bbcwin/download.html
F.i=6TO767a=i DIV6*.024-.3r=(80+i MOD6)MOD83*9-369IFASC(M."?[O@Wo}@b}O@O|O@y?l@xHH@GGE@zmo@yo|@}oU@o?m@?L|@phh@GEE@?u?@?{o@Wk?@?I?@g|O@EGE@?]M@z}o@|_|@}?m@?MO@GDG@xhh@?k?@?oU@z}o@?LO@a?L",i DIV6))>>i MOD6A.1CIRCLEFILL500-r*COS(a),500+r*SIN(a),9
N.

Ungolfed
  FORi=6TO767
    a=i DIV 6 * .024 - .3
    r=(80 + i MOD 6) MOD 83 * 9 - 369            :REM iterate through ({80,81,82,0,1,2} - 41 = {39,40,41,-41,-40,-39}) * 9
    IF ASC(MID$("?[O@Wo}@b}O@O|O@y?l@xHH@GGE@zmo@yo|@}oU@o?m@?L|@phh@GEE@?u?@?{o@Wk?@?I?@g|O@EGE@?]M@z}o@|_|@}?m@?MO@GDG@xhh@?k?@?oU@z}o@?LO@a?L",i DIV6))>>i MOD6AND1    THEN
      CIRCLEFILL 500-r*COS(a), 500+r*SIN(a), 9   :REM dots are circle radius 9 according to documentation (but BBC BASIC actually draws them smaller.)
    ENDIF
  NEXT

Doing this in a language that doesn't support rotated text - for fun. Each character is a 3x3 dot matrix array. There are a total of 66 characters but there are 2 diametrically opposite spaces that we do not print (after CODERS and before FASTER.) Each byte of the magic string encodes for a single vertical row of one letter and a single vertical row of the opposite letter. In this way we only have to sweep through 180 degrees.

Clever, but you should be able to do 4 pixels high letters in a byte, no? Also, your text should be rotated 5 characters counter-clockwise.

@Adám difficult to do 4 pixels high as code will contain many unprintables.  I don't think the interpreter will like it. I misinterpreted/misremembered the spec for rotation. (MEANS was already at the bottom and I rotated it the wrong way) +.2 needs to be changed to -.3 Editing.

Since the OP specifies uppercase, maybe do A as ⠰⠳ and R as ⠸⠫?

@Adam that's a lot of extra work now, and I believe it will reduce readability. It's common in arty and calculator fonts for certain uppercase letters to be replaced with equivalents resembling lowercase. I will see how it looks later.

SVG(HTML5), 212 bytes

<svg width=500 height=500><defs><path id=p d=M250,451a201,201,0,0,1,0,-402a201,201,0,0,1,0,402></defs><text font-size="32"><textPath xlink:href=#p>FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS

Static version of my answer to Easier communication means faster coding means fewer coders means … tweaked so that FEWER is at the bottom. Adjustable version in case your font doesn't match mine:

<input type=number value=0 min=0 max=9 oninput=p.setAttribute('d','M250,250m0,20_a20_,20_,0,1,1,20_,-20_a20_,20_,0,1,1,-20_,-20_a20_,20_,0,1,1,-20_,20_a20_,20_,0,1,1,20_,20_'.replace(/_/g,this.value))>

<svg width=500 height=500><defs><path id=p d=M250,250m0,200a200,200,0,1,1,200,-200a200,200,0,1,1,-200,-200a200,200,0,1,1,-200,200a200,200,0,1,1,200,200></defs><text font-size="32"><textPath xlink:href=#p>FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS

How do you adjust the spacing between MEANS and FEWER? In my browser, they read like one word.

@Adám I've ported the adjustable version across.

Nice. That's going over and beyond.

Java 8, 1,087 bytes
import javafx.animation.*;import javafx.application.*;import javafx.scene.*;import javafx.scene.layout.*;import javafx.scene.shape.*;import javafx.scene.text.*;import javafx.stage.*;import javafx.util.*;import java.util.*;import static javafx.animation.PathTransition.*;public class P extends Application{@Override public void start(Stage stage)throws Error{char[] t="EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS".toCharArray();Shape q=new Circle(400,400,120);List<Text>h=new ArrayList<>();List<Transition>z=new ArrayList<>();for(char c:t){Text o=new Text(c+"");h.add(o);z.add(x(q, o));}Pane p=new Pane();p.getChildren().addAll(h);int s=h.size();for(int i=0;i<s;i++){Transition w=z.get(i);w.jumpTo(Duration.seconds(10).multiply((i+.5)*1/s));w.play();}stage.setScene(new Scene(p,800,800));stage.show();}Transition x(Shape e,Text t){PathTransition v=new PathTransition(Duration.seconds(10),e,t);v.setCycleCount(INDEFINITE);v.setOrientation(OrientationType.ORTHOGONAL_TO_TANGENT);v.setInterpolator(Interpolator.LINEAR);return v;}static void main(String[]a){launch(a);}}

Nice, but you seem to be missing a space between MEANS and EASIER COM.

@Adám: It does not conform with the FEWER at 6 o'clock rule!

Postscript (127 bytes)
Hex dump:
00000000: 2f53 2031 92a5 9233 2f4d 6f6e 6f20 3992  /S 1...3/Mono 9.
00000010: 8e88 6432 3030 926b 3292 9a28 4943 4154  ..d200.k2..(ICAT
00000020: 494f 4e20 4d45 414e 5320 4641 5354 4552  ION MEANS FASTER
00000030: 2043 4f44 494e 4720 4d45 414e 5320 4645   CODING MEANS FE
00000040: 5745 5220 434f 4445 5253 204d 4541 4e53  WER CODERS MEANS
00000050: 2045 4153 4945 5220 434f 4d4d 554e 297b   EASIER COMMUN){
00000060: 5388 0033 2032 9287 9278 5320 6661 6c73  S..3 2...xS fals
00000070: 6592 112d 352e 3435 9288 7d92 4992 a7    e..-5.45..}.I..

Ungolfed (text) version:
/S 1 string def
/Mono 9 selectfont
100 200 moveto
2 setlinejoin
(ICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS EASIER COMMUN)
{S 0 3 2 roll put S false charpath -5.45 rotate} forall
stroke

Sample output:

You can golf this down to 106 bytes, or 148 without binary tokens. ()9 selectfont 100 200 moveto(ICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS EASIER COMMUN){(.)dup 0 4 3 roll put show -5.47 rotate}forall is 148 bytes, which tokenizes down to 106 bytes, which xxd -ps renders as 282939928e8864323030926b2849434154494f4e204d45414e5320464153 54455220434f44494e47204d45414e5320464557455220434f4445525320 4d45414e532045415349455220434f4d4d554e297b282e29923830880433 9287927892a02d352e343792887d9249.

LaTeX + TikZ, 380 bytes
\documentclass[tikz,border=20pt]{standalone}\usetikzlibrary{decorations,decorations.text,}\begin{document}\begin{tikzpicture}\draw[color=white,rotate=-90,postaction={decorate,decoration={text along path,raise=4pt,text align={align=center},text={FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS },reverse path}}](0,0)circle(2.425cm);\end{tikzpicture}\end{document}

Example output

Tcl/Tk, 222
grid [canvas .c]
set i 90;lmap c [split "FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS" ""] {.c cr t [expr {93*cos([set i [expr $i+5.5]]/57.3)+99}] [expr {93*sin($i/57.3)+99}] -te $c -ang [expr -$i-90]}

Will golf it more later!

Java 10, 690 bytes
import java.awt.*;v->new Frame(){{add(new Panel(){RenderingHints R;Math M;public void paint(Graphics g){Graphics2D G=(Graphics2D)g;G.setRenderingHint(R.KEY_ANTIALIASING,R.VALUE_ANTIALIAS_ON);var v=new Font("Hei",0,8).createGlyphVector(G.getFontRenderContext(),"ICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS EASIER COMMUN");int n=99,i=0;for(G.translate(n,0);i<66;){double p=M.PI/2,t=-6/1.1*i*p/90+p;v.setGlyphPosition(i,new Point(0,0));var a=java.awt.geom.AffineTransform.getTranslateInstance((int)(n*M.cos(t)+n),(int)(-n*M.sin(t)+n));a.rotate(t=4*p*i/66);a.translate(n*M.cos(p-t),n*M.sin(p-t));a.translate(-4,0);G.fill(a.createTransformedShape(v.getGlyphOutline(i++)));}}});show();}}

Result:

Explanation:
import java.awt.*;              // Required import for almost everything
v->                             // Method with empty unused parameter and Frame return-type
  new Frame(){                  //  Create the Frame
   {                            //   In an inner code-block:
     add(new Panel(){           //    Add a Panel we can draw on:
       RenderingHints R;        //    RenderingHints null-instance on class-level, for static calls
       Math M;                  //    Math null-instance on class-level, for static calls
       public void paint(Graphics g){
                                //     Overwrite its paint method:
         Graphics2D G=(Graphics2D)g;
                                //      Cast Graphics to Graphics2D, to open up more methods
         G.setRenderingHint(R.KEY_ANTIALIASING,R.VALUE_ANTIALIAS_ON);
                                //      Apply a focus rendering, otherwise the text would be too vague
         var v=new Font("Hei",0,//      Create a "Hei"-Font (could alternatively be Kai)
                                //      (note that a centered monospace font would look a lot better
                                //       for letters like the 'I's)
               8)               //      of font-size 8
               .createGlyphVector(G.getFontRenderContext(),
                                //      Create a GlyphVector using that Font
           "ICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS EASIER COMMUN");
                                //      With this String as text (first character will be at the top)
         int n=99,              //      Integer we'll use a bunch of times, radius of the circle 99
             i=0;               //      Index integer, starting at 0
         for(G.translate(n,0);  //      Set the starting coordinate at 99,0, otherwise the circle
                                //      would be partially outside of the Frame boundaries
             i<66;){            //      Loop `i` in the range [0, 66):
                                //      (66 is the amount of characters of the text)
           double p=M.PI/2,     //       Temp-double `p`, set to PI/2
                  t=            //       Temp-double, which will start at:
                    -6/1.1      //        -360 / 66
                    *i          //        multiplied by the current `i`
                    *p/90       //        multiplied by PI/180
                    +p;         //        And add PI/2 to that
           v.setGlyphPosition(i,new Point(0,0));
                                //        Start the `i`'th Glyph position at 0,0
           var a=java.awt.geom.AffineTransform.getTranslateInstance(
                                //        Create an AffineTransform Translation instance, starting at:
                  (int)(        //         x-coordinate as casted integer:
                   n            //          99
                   *M.cos(t)    //          multiplied by the cosine of `t`
                   +n),         //          Add 99 to that
                  (int)(        //         y-coordinate as casted integer:
                   -n           //          -99
                   *M.sin(t)    //          multiplied by the sinus of `t`
                   +n));        //          Add 99 to that
           a.rotate(            //         Then rotate the current letter by,
                    t=          //         and set `t` to it at the same time:
                      4*p       //          2*PI
                      *i        //          multiplied by the current `i`
                      /66);     //          divided by the length 66
           a.translate(         //         Then move the letter to the correct position:
                                //          x-coordinate:
              n                 //           99
              *M.cos(p-t),      //           multiplied by the cosine of PI/2 - the new `t`
                                //          y-coordinate:
              n                 //           99
              *M.sin(p-t));     //           multiplied by the sinus of PI/2 - the new `t`
           a.translate(-4,0);   //          Slightly adjust based on the font-size
           G.fill(              //          Then add to the Panel through the Graphics2D:
             a.createTransformedShape(
                                //           The shape of:
               v.getGlyphOutline(i++)));}}});
                                //            The current `i`'th Glyph we just created
     show();}}                  //    And afterwards show the Frame

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/