Aclaración: Básicamente, necesitas hacer esto

La función totient de Euler tiene el nombre de phi.

Intentemos calcular phi (8)

Primero, enumere todos los números 8 y hacia atrás, sin incluir 0 o menos

8
7
6
5
4
3
2
1

Ahora encuentre qué números no comparten un factor con 8 (1 no cuenta) y coloque un #en su lugar.

8
#
6
#
4
#
2
#

Elimina los números.

#

#

#

#
                                                 -

Ahora haz esto, pero une las salidas en un triángulo

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

# fuera números que no comparten factores

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

Eliminar números:

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

Esta sería la salida para la entrada 9 (desde 9 columnas).

Nuevas líneas iniciales + finales permitidas.

MATL , 17 15 bytes

:Gq:!Zd1=RP35*c

Pruébalo en línea!

Si una nueva línea inicial es aceptable: 13 bytes :

:t!Zd1=RP35*c

Explicación

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

Jalea, 20 18 bytes

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

Pruébalo en línea!

Pyth - 22 bytes

Intentará jugar más al golf.

j_.tmsm@"# "n1idkSdSQd

Pruébelo en línea aquí .

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`

Donde \nrepresenta el carácter de nueva línea literal. Solución alternativa, también 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, 162158 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 (no actualizado)

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

De entrada y salida:

9

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

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

SQL (PostGreSQL9.4), 239 291 bytes

Crea una declaración preparada que se puede ejecutar. Estoy seguro de que probablemente pueda eliminar bastantes bytes de esto, pero tendré que elegirlo más tarde. ¿Se une una cruz en un rango de 1 a n? Calcula el MCD en una unión lateral. Donde el GCD es 1 y la serie A es mayor que la serie B, genera un '#', de lo contrario, un espacio. Agregue los resultados en una cadena agrupada por la serie 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

Ejecutar de la siguiente manera

execute p(13)

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

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

Y limpiado con

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)