Esclarecimento: Basicamente, você precisa fazer isso

A função totiente de Euler tem o nome phi.

Vamos tentar calcular phi (8)

Primeiro, liste todos os números 8 e abaixo, sem incluir 0 ou abaixo

8
7
6
5
4
3
2
1

Agora descubra quais números não compartilham um fator com 8 (1 não conta) e coloque um #no lugar deles.

8
#
6
#
4
#
2
#

Retire os números.

#

#

#

#
                                                 -

Agora faça isso, mas junte as saídas em um triângulo

        9
       88
      777
     6666
    55555
   444444
  3333333
 22222222
111111111
---------
123456789

# números de compartilhamento sem fator

        9
       8#
      7##
     6#66
    5####
   4#4#4#
  3##3##3
 2#2#2#2#
#########

Remover números:

        #
       ##
      #
     ####
    # # #
   ## ## 
  # # # #
#########

Essa seria a saída da entrada 9 (desde 9 colunas).

Novas linhas à esquerda e à direita são permitidas.

MATL , 17 15 bytes

:Gq:!Zd1=RP35*c

Experimente online!

Se uma nova linha principal for aceitável: 13 bytes :

:t!Zd1=RP35*c

Explicação

:     % Take input N. Generate row vector [1 2 ... N]
Gq:   % Row vector [1 2 ... N-1].
      % (In the 13-byte version this is replaced by function `t`, which duplicates
      % the array [1 2 ... N])
!     % Transpose into column vector
Zd    % GCD, element-wise with broadcast. Gives (N-1)×N matrix
1=    % True for entries that equal 1, corresponding to relatively prime pairs.
      % The rest of entries are set to false, i.e. 0.
R     % Upper triangular part: set values below diagonal to 0
P     % Flip matrix vertically
35*   % Multiply each entry by 35 (ASCII for '#')
c     % Convert to char. 0 will be displayed as a space. Implicitly display

Geléia, 20 18 bytes

RR⁶”#g’¥?€"Rz⁶U'j⁷

Experimente online!

Pitão - 22 bytes

Vai tentar jogar mais.

j_.tmsm@"# "n1idkSdSQd

Experimente online aqui .

JavaScript (ES6), 112 bytes

n=>[...s=` `.repeat(n)].map(_=>s.replace(/./g,_=>`# `[+g(n+1,i++)],n-=i=1),g=(i,j)=>i?i>j||g(j%i,i):j>1).join`\n`

Onde \nrepresenta o caractere literal de nova linha. Solução alternativa, também 112 bytes:

n=>(s=`# `.repeat(n)).replace(r=/../g,_=>s.replace(r,m=>m[+g(n+1,i++)],n-=i=1)+`
`,g=(i,j)=>i?i>j||g(j%i,i):j>1)

Java, 162 158 bytes

int g(int a,int b){return a<1?b:g(b%a,a);}
String d(int n){String r="";for(int i=0;i<n;i++){for(int j=1;j<=n;)r+=i+j<n|g(n-i,j++)>1?" ":"#";r+="\n";}return r;}

Programa completo (não atualizado)

import java.util.Scanner;

public class Q79082 {
    int gcd_ungolfed(int a,int b){
        if(a==0) return b;
        return gcd_ungolfed(b%a,a);
    }
    void draw_ungolfed(int n){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(i+j<=n || gcd_ungolfed(n+1-i,j)!=1){
                    System.out.print(" ");
                }else{
                    System.out.print("#");
                }
            }
            System.out.println();
        }
    }
    int g(int a,int b){return a<1?b:g(b%a,a);}
    String d(int n){String r="";for(int i=0;i<n;i++){for(int j=1;j<=n;j++)r+=(i+j<n||g(n-i,j)>1)?" ":"#";r+="\n";}return r;}
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.close();
        new Q79082().draw_ungolfed(n);
        System.out.println(new Q79082().d(n));
    }
}

Entrada / saída:

9

        #
       ##
      #  
     ####
    # # #
   ## ## 
  # # # #
#########

        #
       ##
      #  
     ####
    # # #
   ## ## 
  # # # #
#########

SQL (PostGreSQL9.4), 239 291 bytes

Cria uma instrução preparada que pode ser executada. Tenho certeza de que provavelmente consigo extrair alguns bytes disso, mas terei que resolver isso mais tarde. Uma junção cruzada varia de 1 a n. Calcula o GCD em uma junção lateral. Onde o GCD é 1 e a série A é maior que a série B, gera um '#', caso contrário, um espaço. Agregue os resultados em uma sequência agrupada pela série B.

prepare p(int)as
select string_agg(coalesce(CASE WHEN b<=a AND x=1THEN'#'END,' '),'')from generate_series(1,$1)a,generate_series(1,$1)b,LATERAL(SELECT MAX(G)x FROM generate_series(1,LEAST(a,b))g WHERE a%g+b%g=0)g
group by b
order by b desc

Execute da seguinte maneira

execute p(13)

string_agg
----------------

            #
           ##
          # #
         ## #
        # # #
       ######
      #   # #
     #### ###
    # # # # #
   ## ## ## #
  # # # # # #
#############

E limpo com

deallocate p

Ruby, 84 bytes

->n{s=[];n.times{|i|j=0;m=n-i;s<<(?#*n).gsub(/./){m.gcd(j+=1)>1||m>j ?' ':$&}};s*$/}

Python 2 (120 bytes)

g=lambda m,n:m if n<1 else g(n,m%n)
r=range(input())
for i in r[:0:-1]:print''.join('# '[i>j+1 or g(i,j+1)>1]for j in r)