Hitung fungsi total Euler


27

Latar Belakang

Euler totient fungsi φ(n)didefinisikan sebagai jumlah bilangan bulat kurang dari atau sama dengan nyang relatif prima untuk n, yaitu, jumlah nilai yang mungkin dari xdalam 0 < x <= nyang gcd(n, x) == 1. Kami sudah sebuah beberapa totient - terkait tantangan sebelumnya, tapi tidak pernah satu yang hanya menghitung itu.

Pemetaan fungsi totient ke seluruh angka adalah OEIS A000010 .

Tantangan

Diberikan bilangan bulat n > 0, hitung φ(n). Anda dapat mengambil input melalui argumen baris perintah, input standar, argumen fungsi, atau hal lain yang masuk akal. Anda dapat memberikan output melalui output standar, nilai pengembalian, atau hal lain yang masuk akal. Fungsi anonim dapat diterima. Anda dapat berasumsi bahwa input tidak akan meluap metode alami Anda menyimpan bilangan bulat, misalnya intdalam C, tetapi Anda harus mendukung input hingga 255. Jika bahasa Anda memiliki fungsi totient bawaan, Anda tidak boleh menggunakannya.

Contohnya

φ(1) => 1
φ(2) => 1
φ(3) => 2
φ(8) => 4
φ(9) => 6
φ(26) => 12
φ(44) => 20
φ(105) => 48

Jawaban terpendek dalam byte menang. Jika bahasa Anda menggunakan penyandian selain UTF-8, sebutkan itu dalam jawaban Anda.


4
Nah ada ini beberapa hari yang lalu. Saya tidak berpikir aplikasi yang diulang membuat perbedaan yang cukup, tetapi jika ada saya akan menutup yang lain, karena saya juga tidak berpikir aplikasi yang diulang menambahkan sesuatu. Yang mengatakan, perbedaan yang lebih besar adalah bahwa yang diizinkan built-in dan yang ini tidak.
Martin Ender

Menolak bawaan tampaknya tidak berdampak pada jawaban.
Julie Pelletier

2
@JuliePelletier Kenapa begitu? Jawaban Mathematica saya seharusnya lebih pendek 19 byte:EulerPhi
Martin Ender

@JuliePelletier GCD diperbolehkan karena menghitung GCD bukanlah masalah yang dimaksudkan untuk diselesaikan. Tentu, itu mungkin meningkatkan byte yang mengandalkan jawaban ini, tetapi itu tidak membuat tantangan lebih baik. Saya akan mengedit untuk mengklarifikasi.
bkul

Jawaban:


13

Mathematica, 27 22 byte

Range@#~GCD~#~Count~1&

Fungsi tanpa nama yang mengambil dan mengembalikan integer.

Tidak banyak yang dijelaskan di sini, kecuali yang @notasi awalan untuk panggilan fungsi dan notasi ~...~(asosiatif-kiri), sehingga di atas sama dengan:

Count[GCD[Range[#], #], 1] &

11

MATL, 7 byte

t:Zd1=s

Anda dapat TryItOnline . Ide paling sederhana, buatlah vektor 1 ke N, dan ambil gcd dari setiap elemen dengan N ( Zdjangan gcd). Kemudian, cari elemen mana yang sama dengan 1, dan jumlah vektor untuk mendapatkan jawabannya.


Builtin adalah _Zpuntuk mereka yang bertanya-tanya.
David

10

J, 9 byte

(-~:)&.q:

Ini didasarkan pada esai Jsoftware tentang fungsi totient.

Diberikan n = p 1 e 1p 2 e 2 ∙∙∙ p k e k di mana p k adalah faktor utama dari n , fungsi total φ ( n ) = φ ( p 1 e 1 ) ∙ φ ( p 2 e 2 ) ∙∙∙ φ ( p k e k ) = ( p 1 - 1) p 1 e 1 - 1 ∙ ( p 2 - 1) p 2e 2 - 1 ∙∙∙ ( p k - 1) p k e k - 1 .

Pemakaian

   f =: (-~:)&.q:
   (,.f"0) 1 2 3 8 9 26 44 105
  1  1
  2  1
  3  2
  8  4
  9  6
 26 12
 44 20
105 48
   f 12345
6576

Penjelasan

(-~:)&.q:  Input: integer n
       q:  Prime decomposition. Get the prime factors whose product is n
(   )&     Operate on them
  ~:         Nub-sieve. Create a mask where 1 is the first occurrence
             of a unique value and 0 elsewhere
 -           Subtract elementwise between the prime factors and the mask
     &.q:  Perform the inverse of prime decomposition (Product of the values)

Gunakan fakta bahwa totient adalah multiplikatif untuk membuat solusi lain dalam J menggunakan rekursi :)
Leaky Nun

@ LeakyNun Saya tidak berpikir ada cara mudah untuk golf anjak piutang, karena bahkan menggunakan bentuk iteratif [:*/@({.(^-(^<:)){:)2&p:membutuhkan 24 byte, bahkan menggunakan builtin untuk mendapatkan bilangan prima dan eksponen mereka. Atau mungkin ada jalan yang lebih pendek dan saya tidak melihatnya.
mil

8

Jelly, 4 byte

Rgċ1

Cobalah online!

Penjelasan

Rgċ1   Main monadic chain. Argument: z

R      Yield [1 2 3 .. z].
 g     gcd (of each) (with z).
  ċ1   Count the number of occurrences of 1.

Dengan built-in

ÆṪ

Cobalah online!

Penjelasan

ÆṪ   Main monadic chain. Argument: z

ÆṪ   Totient of z.

7

Haskell, 28 byte

f n=sum[1|1<-gcd n<$>[1..n]]

Menggunakan pola konstanta yang cocok dengan Haskell . Trik di sini cukup standar untuk bermain golf, tetapi saya akan menjelaskan kepada khalayak umum.

Ekspresi gcd n<$>[1..n]memetakan gcd nke [1..n]. Dengan kata lain, itu menghitung gcddengan nsetiap nomor dari 1ke n:

[gcd n i|i<-[1..n]]

Dari sini, output yang diinginkan adalah jumlah 1entri, tetapi Haskell tidak memiliki countfungsi. Cara idiomatis filteruntuk mempertahankan hanya 1, dan mengambil hasilnyalength , yang terlalu lama untuk bermain golf.

Sebaliknya, filterdisimulasikan oleh pemahaman daftar [1|1<-l]dengan daftar yang dihasilkan l. Biasanya, daftar pemahaman mengikat nilai ke variabel seperti di [x*x|x<-l], tetapi Haskell memungkinkan pola untuk dicocokkan, dalam hal ini konstanta1 .

Jadi, [1|1<-l]menghasilkan 1pada setiap pertandingan 1, secara efektif mengekstraksi hanya 1dari daftar asli. Memanggilnya summemberikan panjangnya.


Saya pikir ini adalah jawaban Haskell pertama yang saya mengerti. Bahasa yang sangat keren, tetapi sangat berbeda dari kebanyakan yang lain.
bkul

Wow, saya berharap pencocokan pola harus lengkap dalam daftar pemahaman. Terima kasih untuk triknya.
Damien

7

Python 2, 44 byte

f=lambda n,d=1:d/n or-f(d)*(n%d<1)-~f(n,d+1)

Kurang bermain golf:

f=lambda n:n-sum(f(d)for d in range(1,n)if n%d<1)

Menggunakan formula yang Euler totients dari pembagi nmemiliki jumlah n:

masukkan deskripsi gambar di sini

Nilai ϕ(n)kemudian dapat dihitung secara rekursif sebagai nminus jumlah di atas pembagi nontrivial. Secara efektif, ini melakukan inversi Möbius pada fungsi identitas. Saya menggunakan metode yang sama dalam golf untuk menghitung fungsi Möbius .

Terima kasih kepada Dennis untuk menghemat 1 byte dengan case dasar yang lebih baik, menyebarkan nilai awal +nke dalam +1untuk setiap nloop, dilakukan sebagai -~.


6

Pyke, 5 byte

m.H1/

Coba di sini!

count(map(gcd, range(input)), 1)

1
Begitu banyak turunan Python .. Aku suka yang ini. Premis yang menarik.
bkul

5

J, 11 byte

+/@(1=+.)i.

Pemakaian

>> f =: +/@(1=+.)i.
>> f 44
<< 20

di mana >>STDIN dan <<STDOUT.

Penjelasan

+/ @ ( 1 = +. ) i.
               │
   ┌───────────┴┐
 +/@(1=+.)      i.
   │
 ┌─┼──┐
+/ @ 1=+.
    ┌─┼─┐
    1 = +.

>> (i.) 44            NB. generate range
<< 0 1 2 3 4 ... 43
>> (+.i.) 44          NB. calculate gcd of each with input
<< 44 1 2 1 4 ... 1
>> ((1=+.)i.) 44      NB. then test if each is one (1 if yes, 0 if no)
<< 0 1 0 1 0 ... 1
>> (+/@(1=+.)i.) 44   NB. sum of all the tests
<< 20

Bagaimana Anda mendapatkan representasi pohon vertikal? Saya pikir itu hanya menghasilkan horisontal.
mil

@miles saya mengetiknya sendiri.
Leaky Nun

5

Python> = 3.5, 76 64 58 byte

Terima kasih kepada LeakyNun untuk bermain golf dengan 12 (!) Byte.

Berkat Sp3000 untuk bermain golf 6 byte.

import math
lambda n:sum(math.gcd(n,x)<2for x in range(n))

Saya suka bagaimana Python dibaca. Ini masuk akal, bahkan melalui golf.


1
lambda n:sum(gcd(n,x)<2for x in range(n))
Leaky Nun

Oh, Python akhirnya ditambahkan gcdke modul matematika! Saya tidak tahu itu.
rubik

5

Regex (ECMAScript), 131 byte

Setidaknya -12 byte berkat Deadcode (dalam obrolan)

(?=((xx+)(?=\2+$)|x+)+)(?=((x*?)(?=\1*$)(?=(\4xx+?)(\5*(?!(xx+)\7+$)\5)?$)(?=((x*)(?=\5\9*$)x)(\8*)$)x*(?=(?=\5$)\1|\5\10)x)+)\10|x

Cobalah online!

Output adalah panjang pertandingan.

Regex ECMAScript membuatnya sangat sulit untuk menghitung apa pun. Setiap backref yang didefinisikan di luar loop akan konstan selama loop, setiap backref yang didefinisikan di dalam loop akan direset ketika looping. Dengan demikian, satu-satunya cara untuk membawa status melintasi loop berulang adalah menggunakan posisi kecocokan saat ini. Itu bilangan bulat tunggal, dan itu hanya bisa berkurang (well, posisinya meningkat, tetapi panjang ekornya berkurang, dan itulah yang bisa kita lakukan dengan matematika).

Mengingat pembatasan-pembatasan itu, menghitung angka-angka coprime tampaknya mustahil. Sebagai gantinya, kami menggunakan formula Euler untuk menghitung angka total.

Begini tampilannya di pseudocode:

N = input
Z = largest prime factor of N
P = 0

do:
   P = smallest number > P that’s a prime factor of N
   N = N - (N / P)
while P != Z

return N

Ada dua hal yang meragukan tentang ini.

Pertama, kita tidak menyimpan input, hanya produk saat ini, jadi bagaimana kita bisa sampai pada faktor utama input? Triknya adalah bahwa (N - (N / P)) memiliki faktor prima yang sama> P dengan N. Ini mungkin mendapatkan faktor prima baru <P, tetapi kita tetap mengabaikannya. Perhatikan bahwa ini hanya berfungsi karena kita beralih pada faktor utama dari yang terkecil hingga yang terbesar, sebaliknya akan gagal.

Kedua, kita harus mengingat dua angka di seluruh iterasi loop (P dan N, Z tidak dihitung karena konstan), dan saya hanya mengatakan itu tidak mungkin! Syukurlah, kita dapat memutar dua angka itu dalam satu. Perhatikan bahwa, pada awal loop, N akan selalu menjadi kelipatan Z, sedangkan P akan selalu kurang dari Z. Dengan demikian, kita bisa mengingat N + P, dan mengekstrak P dengan modulo.

Berikut kode semu yang sedikit lebih detail:

N = input
Z = largest prime factor of N

do:
   P = N % Z
   N = N - P
   P = smallest number > P that’s a prime factor of N
   N = N - (N / P) + P
while P != Z

return N - Z

Dan inilah regex yang dikomentari:

# \1 = largest prime factor of N
# Computed by repeatedly dividing N by its smallest factor
(?= ( (xx+) (?=\2+$) | x+ )+ )

(?=
        # Main loop!
        (
                # \4 = N % \1, N -= \4
                (x*?) (?=\1*$)

                # \5 = next prime factor of N
                (?= (\4xx+?) (\5* (?!(xx+)\7+$) \5)? $ )

                # \8 = N / \5, \9 = \8 - 1, \10 = N - \8
                (?= ((x*) (?=\5\9*$) x) (\8*) $ )

                x*
                (?=
                        # if \5 = \1, break.
                        (?=\5$) \1
                |
                        # else, N = (\5 - 1) + (N - B)
                        \5\10
                )
                x
        )+
) \10

Dan sebagai bonus ...

Regex (ECMAScript 2018, jumlah kecocokan), 23 byte

x(?<!^\1*(?=\1*$)(x+x))

Cobalah online!

Output adalah jumlah kecocokan. ECMAScript 2018 memperkenalkan variabel-panjang melihat-belakang (dievaluasi dari kanan ke kiri), yang memungkinkan untuk hanya menghitung semua angka coprime dengan input.

Ternyata ini adalah metode independen yang sama yang digunakan oleh solusi Retina Leaky Nun , dan regex bahkan memiliki panjang yang sama ( dan dapat dipertukarkan ). Saya meninggalkannya di sini karena mungkin menarik bahwa metode ini berfungsi di ECMAScript 2018 (dan bukan hanya .NET).

                        # Implicitly iterate from the input to 0
x                       # Don’t match 0
 (?<!                 ) # Match iff there is no...
                 (x+x)  # integer >= 2...
         (?=\1*$)       # that divides the current number...
     ^\1*               # and also divides the input

4

Perl 6 ,  26 24  22 byte

{[+] (^$^n Xgcd $n) X== 1}
{+grep 2>*,(^$_ Xgcd$_)}
{[+] 2 X>(^$_ Xgcd$_)}

Penjelasan:

{
  [+] # reduce using &infix:<+>
    2
    X[>] # crossed compared using &infix:«>»
    (
      ^$_    # up to the input ( excludes input )
      X[gcd] # crossed using &infix:<gcd>
      $_     # the input
    )
}

Contoh:

#! /usr/bin/env perl6
use v6.c;

my  = {[+] 2 X>(^$_ Xgcd$_)};

say φ(1) # 1
say φ(2) # 1
say φ(3) # 2
say φ(8) # 4
say φ(9) # 6
say φ(26) # 12
say φ(44) # 20
say φ(105) # 48

say φ 12345 # 6576


4

Julia, 25 byte

!n=sum(i->gcd(i,n)<2,1:n)

Sederhana - sumfungsi ini memungkinkan Anda untuk memberikannya fungsi untuk diterapkan sebelum dijumlahkan - pada dasarnya setara dengan menjalankan mapdan kemudian sum. Ini secara langsung menghitung jumlah bilangan prima yang relatif kurang n.


4

Python 2, 57 byte

f=lambda n,k=1,m=1:n*(k>n)or f(n-(n%k<m%k)*n/k,k+1,m*k*k)

Uji di Ideone .

Latar Belakang

Dengan formula produk Euler ,

Formula produk Euler

di mana φ menunjukkan fungsi total Euler dan p bervariasi hanya pada bilangan prima.

Untuk mengidentifikasi bilangan prima, kami menggunakan wajar teorema Wilson :

akibat dari teorema Wilson

Bagaimana itu bekerja

Setiap saat, variabel m akan sama dengan kuadrat faktorial dari k - 1 . Bahkan, kami menamai argumen default ke k = 1 dan m = 0! 2 = 1 .

Selama k ≤ n , n*(k>n)dievaluasi menjadi 0 dan kode berikut ordijalankan.

Ingat bahwa m%kakan menghasilkan 1 jika m adalah prima dan 0 jika tidak. Ini berarti bahwa x%k<m%kakan menghasilkan True jika dan hanya jika kedua k adalah bilangan prima dan x dapat dibagi oleh k .

Dalam hal ini, (n%k<m%k)*n/khasilkan n / k , dan kurangi dari n menggantikan nilai sebelumnya dengan n (1 - 1 / k) , seperti dalam formula produk Euler. Jika tidak, (n%k<m%k)*n/khasil 0 dan n tetap tidak berubah.

Setelah menghitung di atas, kami menambah k dan mengalikan m dengan nilai "lama" dari k 2 , dengan demikian mempertahankan hubungan yang diinginkan antara k dan m , kemudian memanggil f secara rekursif dengan argumen yang diperbarui.

Setelah k melebihi n , n*(k>n)evaluasi ke n , yang dikembalikan oleh fungsi.


4

Ruby, 32 byte

->n{(1..n).count{|i|i.gcd(n)<2}}

sebuah lambda yang mengambil bilangan bulat n, dan mengembalikan jumlah berapa banyak bilangan bulat dalam rentang (1..n) yang coprime dengan n.


Halo, dan selamat datang di PPCG! Ini adalah pos pertama yang bagus.
NoOneIsHere

Selamat Datang di Programming Puzzles dan Code Golf! Ini adalah solusi pertama yang bagus, teruskan!
bkul

Terima kasih, tidak sesingkat itu, saya ingin tahu apakah mungkin untuk memperbaikinya.
Redouane Red

3

Brachylog , 25 byte

:{:1e.$pdL,?$pd:LcCdC}fl.

Penjelasan

Brachylog belum memiliki built-in GCD, jadi kami memeriksa bahwa kedua angka tersebut tidak memiliki faktor utama yang sama.

  • Predikat utama:

    :{...}fl.             Find all variables which satisfy predicate 1 when given to it as
                          output and with Input as input.
                          Unify the Output with the length of the resulting list
    
  • Predikat 1:

    :1e.                  Unify Output with a number between Input and 1
        $pdL              L is the list of prime factors of Output with no duplicates
            ,
             ?$pd:LcC     C is the concatenation of the list of prime factors of Input with
                          no duplicates and of L
                     dC   C with duplicates removed is still C
    

3

Pyth, 6 byte

smq1iQ

Cobalah online!

/iLQQ1

Cobalah online!

Penjelasan

smq1iQ     input as Q
smq1iQdQ   implicitly fill variables

 m     Q   for d in [0 1 2 3 .. Q-1]:
    iQd        gcd of Q and d
  q1           equals 1? (1 if yes, 0 if no)
s          sum of the results


/iLQQ1     input as Q

 iLQQ      gcd of each in [0 1 2 3 .. Q-1] with Q
/    1     count the number of occurrences of 1

3

PowerShell v2 +, 72 byte

param($n)1..$n|%{$a=$_;$b=$n;while($b){$a,$b=$b,($a%$b)};$o+=!($a-1)};$o

PowerShell tidak memiliki fungsi GCD yang tersedia, jadi saya harus memutar sendiri.

Ini membutuhkan input $n, kemudian berkisar dari 1ke $ndan menyalurkannya ke dalam satu lingkaran |%{...}. Setiap iterasi kami menetapkan dua variabel penolong $adan $bkemudian mengeksekusi GCD whilelingkaran. Setiap iterasi yang kami periksa $bmasih non-nol, dan kemudian disimpan $a%$bke $bdan nilai sebelumnya $buntuk $auntuk loop berikutnya. Kami kemudian mengakumulasikan apakah $asama dengan 1variabel output kami $o. Setelah for loop selesai, kita menempatkan $opada pipeline dan output tersirat.

Sebagai contoh cara kerja whileloop, pertimbangkan $n=20dan kita aktif $_=8. Cek pertama sudah $b=20, jadi kita masuk ke loop. Kami pertama-tama menghitung $a%$batau 8%20 = 8, yang ditetapkan $bpada saat yang sama dengan yang 20ditetapkan $a. Periksa 8=0, dan kami memasuki iterasi kedua. Kami kemudian menghitung 20%8 = 4dan mengaturnya $b, kemudian mengatur $ake 8. Periksa 4=0, dan kami masukkan iterasi ketiga. Kami menghitung 8%4 = 0dan mengaturnya menjadi $b, lalu mengatur $ake 4. Periksa 0=0dan kita keluar dari loop, jadi GCD (8,20) adalah $a = 4. Jadi, !($a-1) = !(4-1) = !(3) = 0jadi $o += 0dan kami tidak menghitungnya.


3

Faktor, 50 byte

[ dup iota swap '[ _ gcd nip 1 = ] filter length ]

Membuat rentang ( iota ) n , dan menyematkan n ke dalam fungsi yang mendapat gcd xn untuk semua nilai 0 <= x <= n , menguji jika hasilnya 1 . Saring rentang asli pada apakah hasil gcd xn adalah 1 , dan ambil panjangnya .


[ dup iota swap '[ _ gcd nip 1 = ] map sum ]menghemat 6 byte (saya pikir - tidak terlalu berpengalaman dengan Factor).
bkul

@kul Terima kasih atas sarannya! : D Sayangnya, tidak ada kompatibilitas apa pun antara angka dan t/f(simbol) di Factor, jadi satu-satunya cara untuk mengimplementasikannya adalah dengan [ dup iota swap '[ _ gcd nip 1 = 1 0 ? ] map sum ], yang sama persis panjangnya dengan solusi saat ini.
kucing

Ah, sial. Pengetikan yang kuat menyerang lagi.
bkul

@kul Yah, aku berterima kasih atas pengetikan yang kuat dan TYPED:dalam kode faktor nyata : P
cat


2

Retina, 36 29 byte

7 byte berkat Martin Ender.

.+
$*
(?!(11+)\1*$(?<=^\1+)).

Cobalah online!

Penjelasan

Ada dua tahap (perintah).

Tahap pertama

.+
$*

Ini adalah penggantian regex sederhana, mengubah input menjadi banyak.

Misalnya, 5akan dikonversi menjadi 11111.

Tahap kedua

(?!(11+)\1*$(?<=^\1+)).

Regex ini mencoba mencocokkan posisi yang memenuhi kondisi (co-prime dengan input), dan kemudian mengembalikan jumlah kecocokan.


Lookbehind tidak mundur kecuali di dalam lookahead?
Leaky Nun

Penelusuran tidak mundur secara umum.
Martin Ender

Lalu bagaimana regex menguji setiap pembagi?
Leaky Nun

1
Ya, mereka melakukan backtrack selama Anda tidak meninggalkannya. Selama mesin berada di dalam lookaround, ia akan mencoba segala kemungkinan untuk membuat kecocokan lookaround (atau gagal dalam kasus lookaround negatif). Tapi begitu lookaround dilewati, mesin tidak akan mundur ke dalamnya jika ada sesuatu setelah gagal (kecuali kemudian mulai melacak hal-hal di depan lookaround dan harus mengevaluasi kembali semuanya).
Martin Ender

2

Gangguan Umum, 58 byte

(defun o(x)(loop for i from 1 to x if (=(gcd x i)1)sum 1))

Ini adalah loop sederhana yang menghitung hingga 1 sampai n yang diberikan dan menambah jumlah jika gcd = 1. Saya menggunakan nama fungsi o karena t adalah nilai boolean yang sebenarnya. Bukan yang terpendek tapi cukup sederhana.


Apakah CL tidak memiliki semacam fungsi anonim?
kucing

2

MATLAB / Oktaf, 21 byte

@(n)sum(gcd(n,1:n)<2)

Membuat fungsi anonim bernama ansyang dapat dipanggil dengan integer nsebagai satu-satunya input:ans(n)

Demo online




1

Sebenarnya, 11 byte

;╗R`╜g`M1@c

Cobalah online!

Penjelasan

;╗R`╜g`M1@c   register stack             remarks

                       44
;                      44 44
 ╗            44       44
  R           44       [1 2 3 .. 44]
       M      44       10                for example
    ╜         44       10 44
     g        44       2
              44       [1 2 1 .. 44]     gcd of each with register
        1     44       [1 2 1 .. 44] 1
         @    44       1 [1 2 1 .. 44]
          c   44       20                count

Dengan built-in

Cobalah online!


Anda dapat menggunakan alternatif ;╗R`╜g1=`MΣuntuk jumlah byte yang sama
Mego

1

JavaScript (ES6), 67 byte

f=n=>[...Array(n)].reduce(r=>r+=g(n,++i)<2,i=0,g=(a,b)=>b?g(b,a%b):a)


1

APL, 7 byte

+/1=⊢∨⍳

Ini adalah kereta fungsi monadik yang mengambil bilangan bulat di sebelah kanan. Pendekatan di sini adalah yang jelas: jumlah (+/ ) berapa kali GCD dari input dan angka dari 1 ke input ( ⊢∨⍳) sama dengan 1 ( 1=).

Coba di sini


1

Haskell, 31 30 byte

\n->sum[1|x<-[1..n],gcd n x<2]

1 byte disimpan, terima kasih kepada @Damien.

Pilih nilai dengan gcd = 1, petakan masing-masing ke 1, lalu ambil jumlah.


Anda dapat menggantinya ==1dengan<2
Damien

1

Batch, 151 145 144 byte

@echo off
set t=
for /l %%i in (1,1,%1)do call:g %1 %%i
echo %t%
exit/b
:g
set/ag=%1%%%2
if not %g%==0 call:g %2 %g%
if %2%==1 set/at+=1

Sunting: Disimpan 4 byte dengan menghapus spasi yang tidak perlu. Disimpan 1 byte dengan menggunakan +=. Disimpan 1 byte dengan mengosongkan tsebagaimana +=akan menafsirkannya sebagai 0pula. Disimpan 1 byte berkat @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ.

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.