Chiarimento: Fondamentalmente, è necessario fare questo

La funzione totient di Euler ha il nome phi.

Proviamo a calcolare il phi (8)

Innanzitutto, elenca tutti i numeri 8 e precedenti all'indietro, escluso 0 o meno

8
7
6
5
4
3
2
1

Ora trova quali numeri non condividono un fattore con 8 (1 non conta) e posiziona un #al loro posto.

8
#
6
#
4
#
2
#

Rimuovi i numeri.

#

#

#

#
                                                 -

Ora fai questo, ma collega le uscite in un triangolo

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

# numeri di condivisione non fattoriali

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

Rimuovi numeri:

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

Questo sarebbe l'output per l'input 9 (da 9 colonne).

Sono consentite nuove linee guida + finali.

MATL , 17 15 byte

:Gq:!Zd1=RP35*c

Provalo online!

Se una nuova riga iniziale è accettabile: 13 byte :

:t!Zd1=RP35*c

Spiegazione

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

Gelatina, 20 18 byte

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

Provalo online!

Pyth - 22 byte

Proverò a giocare a golf ulteriormente.

j_.tmsm@"# "n1idkSdSQd

Provalo online qui .

JavaScript (ES6), 112 byte

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`

Dove \nrappresenta il carattere letterale di newline. Soluzione alternativa, anche 112 byte:

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 byte

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

Programma completo (non aggiornato)

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

Input Output:

9

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

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

SQL (PostGreSQL9.4), 239 291 byte

Crea un'istruzione preparata che può essere eseguita. Sono sicuro che probabilmente potrò prendere un bel po 'di byte da questo, ma dovrò risolverlo più tardi. Fa un cross join su un intervallo da 1 a n. Calcola il GCD in un join laterale. Dove il GCD è 1 e la serie A è maggiore della serie B emette un '#' altrimenti uno spazio. Aggrega i risultati in una stringa raggruppata per 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

Esegui nel modo seguente

execute p(13)

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

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

E ripulito con

deallocate p

Rubino, 84 byte

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

Python 2 (120 byte)

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)