Klarstellung: Grundsätzlich müssen Sie dies machen

Eulers Totientenfunktion hat den Namen phi.

Versuchen wir, phi (8) zu berechnen.

Listen Sie zunächst alle Zahlen 8 und darunter rückwärts auf, ohne 0 oder darunter

8
7
6
5
4
3
2
1

Finden Sie nun heraus, welche Zahlen keinen Faktor mit 8 teilen (1 zählt nicht), und setzen Sie einen #an ihre Stelle.

8
#
6
#
4
#
2
#

Entfernen Sie die Zahlen.

#

#

#

#
                                                 -

Tun Sie dies nun, aber reihen Sie die Ausgaben in einem Dreieck aneinander

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

# Nicht-Faktor-Sharing-Nummern

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

Zahlen entfernen:

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

Dies wäre die Ausgabe für Eingabe 9 (seit 9 Spalten).

Führende + nachfolgende Zeilenumbrüche sind zulässig.

MATL , 17 15 Bytes

:Gq:!Zd1=RP35*c

Probieren Sie es online aus!

Wenn ein führender Zeilenumbruch akzeptabel ist: 13 Byte :

:t!Zd1=RP35*c

Erläuterung

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

Gelee, 20 18 Bytes

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

Probieren Sie es online aus!

Pyth - 22 Bytes

Ich werde versuchen, weiter Golf zu spielen.

j_.tmsm@"# "n1idkSdSQd

Probieren Sie es hier online aus .

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`

Wobei \ndas wörtliche Zeilenumbruchzeichen steht. Alternative Lösung, auch 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;}

Vollständiges Programm (nicht aktualisiert)

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

Erstellt eine vorbereitete Anweisung, die ausgeführt werden kann. Ich bin mir sicher, dass ich wahrscheinlich ein paar Bytes daraus machen kann, aber ich muss später darauf zurückgreifen. Verbindet sich ein Kreuz in einem Bereich von 1 bis n? Berechnet die GCD in einer lateralen Verbindung. Wenn der GCD 1 ist und die Serie A größer als die Serie B ist, wird ein '#' ausgegeben, andernfalls ein Leerzeichen. Aggregieren Sie die Ergebnisse zu einer Zeichenfolge, die nach Serie B gruppiert ist.

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

Führen Sie die folgenden Schritte aus

execute p(13)

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

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

Und aufgeräumt mit

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)