Tanımlar

• Bir mükemmel bir kare bir tamsayı bir kare olarak ifade edilebilir bir tamsayıdır. Örneğin, 36mükemmel bir kare çünkü 6^2 = 36.
• Bir squarefree sayısı dışında, herhangi bir mükemmel kare tarafından bölünebilir olmayan bir tamsayıdır 1. Örneğin, 10kare içermeyen bir sayıdır. Ancak, 12kare içermeyen bir sayı değildir, çünkü 12bölünebilir 4ve 4mükemmel bir karedir.

Görev

Pozitif bir tamsayı verildiğinde n, bölünen en büyük kare içermeyen sayıyı verin n.

testcases

n   output
1   1
2   2
3   3
4   2
5   5
6   6
7   7
8   2
9   3
10  10
11  11
12  6
13  13
14  14
15  15
16  2
17  17
18  6
19  19
20  10
21  21
22  22
23  23
24  6
25  5
26  26
27  3
28  14
29  29
30  30
31  31
32  2
33  33
34  34
35  35
36  6
37  37
38  38
39  39
40  10
41  41
42  42
43  43
44  22
45  15
46  46
47  47
48  6
49  7
50  10

puanlama

Bu kod golfü . Bayt cinsinden en kısa cevap kazanır.

Standart boşluklar uygulanır.

Referans

• OEIS A007947

05AB1E , 2 bayt

fP

Çevrimiçi deneyin!

Nasıl çalışır

f   Implicitly take input and compute the integer's unique prime factors.
 P  Take the product.

Brachylog , 3 bayt

ḋd×

Çevrimiçi deneyin!

Çok özgün bir cevap ...

açıklama

ḋ          Take the prime factors of the Input
 d         Remove duplicates
  ×        Multiply

JavaScript (ES6), 55 54 50 46 bayt

Aktaran OEIS :
a (n) n öyle ki n böler u ^ n en küçük bölen u ise

Güncellenmiş uygulama:
a (n), n'nin bölüştüreceği şekilde n pozitif tamsayısının u en küçük bölenidir.

let f =

n=>(g=(p,i=n)=>i--?g(p*p%n,i):p?g(++u):u)(u=1)

for(n = 1; n <= 50; n++) {
  console.log(n,f(n));
}

MATL , 6 4 bayt

@LeakyNun yardımı ile kaydedilen 2 bayt

Yfup

Çevrimiçi deneyin!

açıklama

Girişi düşünün 48.

Yf   % Implicit input. Push prime factors with repetitions.  STACK: [2 2 2 2 3]
u    % Unique.                                               STACK: [2 3]
p    % Product of array. Implicit display.                   STACK: 6

Jöle , 4 bayt

ÆfQP

Çevrimiçi deneyin!

ÆfQP  Main link, argument is z
Æf    Takes the prime factors of z
  Q   Returns the unique elements of z
   P  Takes the product

CJam , 8 bayt

rimf_&:*

^{Neden bu programdaki her işlem 2 byte olmak zorunda -_-}

Çevrimiçi deneyin!

ri       e# Read int from input
  mf     e# Get the prime factors
    _&   e# Deduplicate
      :* e# Take the product of the list

Retina , 36 30 28 bayt

+`((^|\3)(^(1+?)|\3\4))+$
$3

Tekli giriş ve çıkış .

Çevrimiçi deneyin! (Ondalık <-> düzenli dönüşüm için bir üstbilgi ve altbilgi içerir ve bir kerede birden fazla test senaryosu çalıştırır.)

açıklama

Fikir, girdiyi bazı faktörlerin kare çarpı olarak eşleştirmektir. Bir kareyi eşleştirmek için kullanılan temel regex, ardışık garip tam sayıların toplamlarını eşleştirmek için ileri referans kullanır:

(^1|11\1)+$

Mükemmel kareleri eşleştirmek istemediğimiz için, fakat kareler tarafından bölünebilen sayılar, onu 1bir geri tepkime ile değiştiririz :

(^(1+?)|\1\2\2)+$

Yani şimdi dış grup 1kullanılacaktır n nerede kere n ² büyük kare o böler giriş ve grup 2mağazaları kalan faktörü. İstediğimiz, kareyi kaldırmak için tamsayıyı n'ye bölmektir . Sonuç, grup 1zaman grubunun yinelemelerinin sayısı olarak ifade edilebilir 2, ancak bu yapılması biraz zordur. Retina $*muhtemelen karakter değiştirmeyen bir jetonu sağ el argümanı olarak alacak, bu durumda bunun yerine basitçe değiştirebileceğiz $#1$*$2ama bu işe yaramadı.

Bunun yerine, tek sayıları farklı şekilde ayrıştırırız. Mükemmel kareleri eşleştirmenin daha basit örneğine geri dönelim (^1|11\1)+$. Bunun yerine bir sayacı sahip \1üzere bir sıfırlanır 1 tarafından ve artırılır 2 her tekrarında, iki sayaçları gerekecek. Biri 0'a , biri 1'e ilklendirilir ve her ikisi de her yinelemede 1 artırılır . Temelde tek sayılar çürümüş ettik Yani 2n + 1 içine (n) + (n + 1) . Bunun yararı, gruplardan birinde n ile sonuçlanmamızdır. En basit haliyle, şuna benzer:

((^|1\2)(^1|1\3))+$

Burada \2olduğu , n ve \3bir n + 1 . Ancak, biz biraz daha verimli olduğunu fark ederek yapabilirsiniz + 1, n tek yinelemenin eşittir n bir tasarruf böylece sonraki yineleme 1burada:

((^|\3)(^1|1\3))+$

Şimdi sadece 1mükemmel bir kareyle bölünen girdileri eşleştirmek yerine başlangıç ​​faktörünü kullanmaya geri dönmemiz gerekiyor :

((^|\3)(^(1+?)|\3\4))+$

Şimdi tek yapmamız gereken $3, sonunda tüm faktörlerin yerini almaktır; bu , başlangıç ​​faktörünü çarpı adım sayısını depolayan ve kareden bir faktörü girişten alan adımlardır.

Bu, +programın başlangıcında, karelerden daha yüksek güç içeren girdileri hesaba katmak için tekrar tekrar yapılır .

Octave, 27 bayt

@(x)prod(unique(factor(x)))

Diğer cevaplarla benzer bir yaklaşım. Fark şudur: İşlevlerin çok daha uzun adları vardır. Alır: Ben kodu gerçekten kendini açıklıyor inanıyoruz prodait ürünün içine uniqueasal factorbir sayı s.

Wolfram Dili, 29 28 bayt

-1 @Martin Ender Thanks sayesinde

Most[1##&@@FactorInteger@#]&

Açıklama:

           FactorInteger@#    (*Get prime factorization as {{a,b},{c,d}}*)
     1##&@@                   (*Multiply list elements together, to get the product of the factors and the product of their exponents*)
Most[                     ]&  (*Take the first element*)

Python , 37 bayt

f=lambda n,r=1:1>>r**n%n or-~f(n,r+1)

Çevrimiçi deneyin!

En büyük karesiz bölen, tüm asal çarpanlara sahip nen küçük sayıdır . Biz bu şekilde kontrol edebilirsiniz beri, marka her asal faktörünün kopya ve bölünemeyen bir tek ise her temsil edilir bireyin asal faktörleri.rnr**n%n==0r**nnrnn

1>>r**n%nEşdeğerdir int(r**n%n==0). Eğer Trueçıkışı 1 kullanılabilir, bu 2 yapmak daha kısa bayt var.

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

Matematik , 40 bayt

Times@@(Transpose@FactorInteger@#)[[1]]&

Çevrimiçi deneyin!

Alice , 4 bayt

iDo@

Çevrimiçi deneyin!

Giriş ve çıkış, bir karakterin kod noktası olarak verilir (tüm geçerli Unicode kod noktaları için çalışır).

açıklama

Peki, Alice'in Dtanımı "Dedüplicate asal çarpanları" olan bir yerleşik vardır . Yani bir değer bazıları tarafından bölünebilir olduğu sürece, olan p ² asal için p , bölmek Bununla değer p . Bu tam olarak bu mücadelede gerekli olan fonksiyon olarak gerçekleşir. Gerisi sadece girdi, çıktı, programı sonlandırır.

Bunun Alice'e eklenmesinin sebebi aslında bu tamsayı dizisi ile ilgisi yok. Bölenleri alt dizelerle ve ana faktörleri karakterlerle ilişkilendirme temasına bağlı kalmaya çalışıyordum. Ve "tekilleştirilmiş karakterler" ile çalışan bir işleve ihtiyacım vardı (genel olarak çok daha faydalıdır, çünkü dizeleri kümeler gibi, özellikle de çeşitli multiset operatörleriyle birlikte kullanıldığında).

Haskell , 31 bayt

f n=until(\r->r^n`mod`n<1)(+1)1

Çevrimiçi deneyin!

Pyke , 3 bayt

P}B

Çevrimiçi deneyin!

P   -   factors(input)
 }  -  uniquify(^)
  B - product(^)

Prolog (SWI) , 84 39 bayt

f(N,P):-between(1,N,P),P^N mod N=:=0,!.

Çevrimiçi deneyin!

@ Xnor'ın Haskell'in cevabı fikri Prolog'a uyarlandı .

PHP, 70 Bayt

for($r=1,$i=2;1<$n=&$argn;)$n%$i?++$i:$n/=$i+!($r%$i?$r*=$i:1);echo$r;

Çevrimiçi deneyin!

Pyth, 8 6 bayt

*F+1{P

@LeakyNun sayesinde * -2 bayt

Pyth, listelerin ürünleri için yerleşik olsaydı 3 olurdu ...

Dene!

*F+1{P
      Q     # Implicit input
     P      # Prime factors of the input
    {       # Deduplicate
  +1        # Prepend 1 to the list (for the case Q==1)
*F          # Fold * over the list

C, 6550 bayt

İhtiyacı ortadan kaldırdığı için @ Ørjan Johansen'e teşekkürler r. Bu ve diğer bazı kirli hileler sayesinde 15 bayt sıkmak başardı!

d;f(n){for(d=1;d++<n;)n%(d*d)||(n/=d--);return n;}

whilegitti ve yerine ||koydu ve dizin twiddling. <=baştan beri olmalıydı <.

<=<almak için artışı hareket ettirerek döndürülür n%(++d*d)(operatör önceliği nedeniyle iyi tanımlanmalıdır).

Orijinal kod:

d;r;f(n){for(r=d=1;d++<=n;)while(n%d<1)r*=r%d?d:1,n/=d;return r;}

Aksiyom, 89 bayt

f(x:PI):PI==(x=1=>1;g:=factor x;reduce(*,[nthFactor(g,i) for i in 1..numberOfFactors g]))

test ve sonuçlar

(38) -> [[i, f(i)] for i in 1..30 ]
   (38)
   [[1,1], [2,2], [3,3], [4,2], [5,5], [6,6], [7,7], [8,2], [9,3], [10,10],
    [11,11], [12,6], [13,13], [14,14], [15,15], [16,2], [17,17], [18,6],
    [19,19], [20,10], [21,21], [22,22], [23,23], [24,6], [25,5], [26,26],
    [27,3], [28,14], [29,29], [30,30]]

bu değil faktör () işlevini kullanmaktır

g(x:PI):PI==(w:=sqrt(x);r:=i:=1;repeat(i:=i+1;i>w or x<2=>break;x rem i=0=>(r:=r*i;repeat(x rem i=0=>(x:=x quo i);break)));r)

ama sadece 125 bayttır

R, 52 bayt

`if`((n=scan())<2,1,prod(unique(c(1,gmp::factorize(n))))

nstdin'den okur . gmpKütüphanenin kurulmasını gerektirir (böylece TIO çalışmaz). Yukarıdaki cevapların birçoğuyla aynı yaklaşımı kullanır, ancak bir girdiyle çarpışır 1, çünkü ne yazık ki, çarpışan , factorize(1)boş bir sınıf vektörü döndürür .bigzunique

Aslında 2 bayt

yπ

Çevrimiçi deneyin!

Açıklama:

yπ
y   prime divisors
 π  product

Pari / GP , 28 bayt

n->factorback(factor(n)[,1])

Çevrimiçi deneyin!

Pyt , 3 bayt

←ϼΠ

Açıklama:

←                  Get input
 ϼ                 Get list of unique prime factors
  Π                Compute product of list
                   Implicit print