İkinci dereceden bir sayı, başka bir tamsayının dördüncü gücü olan bir sayıdır, örneğin: 3^4 = 3*3*3*3 = 81

Girdi olarak bir tamsayı verildiğinde, en yakın iki dereceli sayıyı çıktılar.

İşte ilk 15 çift kare:

1, 16, 81, 256, 625, 1296, 2401, 4096, 6561, 10000, 14641, 20736, 28561, 38416, 50625

Bu kod golf , her dilde en az bayt kazanır

Bu OEIS A000583

Python 3 , 35 bayt

lambda n:int((n**.5-.75)**.5+.5)**4

Çevrimiçi deneyin!

Nasıl çalışır

Değeri , n çıkışı (geçer hangi k - 1) ⁴ için k ⁴ - + 1/2 = tatmin √ (3/4 √N) k ya da N = ((k - 1/2) ² + 3 / 4) ² = ( k ² - k + 1) ² = (( k - 1) ⁴ + k ⁴ + 1) / 2, ki bu tam olarak k ^4'e daha yakın olan ilk tam sayıdır .

(Tüm n ≤ 4504699340341245 = (8192 ⁴ + 8193 ⁴ - 7) / 2> 2 ^{52 için çalışır} , bundan sonra tüm n için matematiksel olarak çalışmasına rağmen kayan nokta yuvarlaması onu kırmaya başlar .)

Oktav , 35 bayt

Bu meydan okuma , evrişliğe dayalı bir yaklaşıma ihtiyaç duyuyordu .

@(n)sum(n>conv((1:n).^4,[1 1]/2))^4

Çevrimiçi deneyin!

açıklama

İfade (1:n).^4satır vektörü üretir [1 16 81 256 ... n^4].

Bu vektör daha sonra [1 1]/2, boyut bloklarının kayma ortalamasını hesaplamaya eşdeğer olan kıvrımlıdır 2. Bu dolaylı olarak vektörün sol ve sağ dolgulu olduğunu varsayar 0. Sonuçta ilk değer 0.5(örtük 0ve ortalama 1), ikincisi 8.5(ortalama 1ve 16), vb.

Örnek n = 9olarak conv((1:n).^4,[1 1]/2),

0.5 8.5 48.5 168.5 440.5 960.5 1848.5 3248.5 5328.5 3280.5

Karşılaştırma n>...daha sonra

1 1 0 0 0 0 0 0 0 0 0

ve uygulama sum(...)verir 2. Bu , iki dereceli sayılar arasındaki orta noktaların ntam olarak aşıldığı anlamına gelir 2(ek orta nokta dahil 0.5). Sonunda, sonucu elde ^4etmek 4için bunu yükseltir 16.

Haskell , 51 49 bayt

İşlev monad ftw!

f n=snd.minimum$(abs.(n-)<$>)>>=zip$(^4)<$>[1..n]

Çevrimiçi deneyin!

Açıklama:

                                (^4)<$>[1..n] -- creates a list of fourth powers
            (abs.(n-)<$>)>>=zip               -- creates a list of |n-(4th powers)| and
                                              -- zips it with the 4th powers list
    minimum                                   -- finds the minimum
                                              -- (only first tuple entry matters)
snd                                           -- exctracts the second entry (the 4th power)

MATL , 6 bayt

t:4^Yk

Çevrimiçi deneyin!

açıklama

Girişi 9örnek olarak ele alalım.

t    % Implicitly input n. Duplicate         
     % STACK: 9, 9
:    % Range [1 2 ... n]
     % STACK: 9, [1 2 3 4 5 6 7 8 9]
4^   % Raise to 4, element-wise
     % STACK: 9, [1 16 81 256 625 1296 2401 4096 6561]
Yk   % Closest element. Implicitly display
     % STACK: 16

Neim , 5 bayt

𝐈4𝕎S𝕔

Açıklama:

𝐈       Inclusive range [1 .. input]
  𝕎    Raise to the  v  power
 4                   4th
     𝕔  Select the value closest to
    S   the input

Çevrimiçi deneyin!

Excel, 25 bayt

=INT((A1^.5-3/4)^.5+.5)^4

Excel bunu şu şekilde günceller: =INT((A1^0.5-3/4)^0.5+0.5)^4

Mathematica, 21 bayt

Nearest[Range@#^4,#]&

Brachylog , 9 bayt

;I≜+.~^₄∧

Çevrimiçi deneyin!

açıklama

;I≜          I = 0 / I = 1 / I = -1 / I = 2 / etc. on backtracking
   +.        Output = Input + I
    .~^₄     Output = Something to the power 4
        ∧

JavaScript (ES7), 42 bayt

x=>(n=x**.25|0,x-(k=n**4)<++n**4-x?k:n**4)

Özyinelemeli sürüm, 44 bayt

f=(x,k,b)=>(a=k**4)>x?a-x>x-b?b:a:f(x,-~k,a)

gösteri

let f =

x=>(n=x**.25|0,x-(k=n**4)<++n**4-x?k:n**4)

console.log(f(16))
console.log(f(48))
console.log(f(49))

Oktav , 37 bayt

@(n)interp1(t=(1:n).^4,t,n,'nearest')

En yakın komşu enterpolasyonunu kullanan anonim işlev.

Çevrimiçi deneyin!

05AB1E , 6 bayt

LnnI.x

Çevrimiçi deneyin!

açıklama

LnnI.x
L      # Push [1 .. input]
 nn    # Raise every element to the 4th power
   I   # Push input
    .x # Closest element in the array to input

APL, 22 bayt

{o/⍨p=⌊/p←|⍵-⍨o←4*⍨⍳⍵}

Çevrimiçi deneyin!

Nasıl?

o←4*⍨⍳⍵- o= aralık ( ⍵) ⁴ _[vectorize]

p←|⍵-⍨o- p= abs ( o- ⍵) _[vektörize]

o/⍨- oöğeyi dizinde al ...

p=⌊/p- pminimum öğe

Jöle , 6 bayt

R*4ạÐṂ

Bir öğenin listesini veya sonucu yazdıran tam bir programı döndüren monadik bir bağlantı (verimsiz bir yöntem kullanarak).

Çevrimiçi deneyin!

Nasıl?

R*4ạÐṂ - Link: number, n
R      - range(n) -> [1,2,3,...,n]
 *4    - raise to the fourth power -> [1,16,81,...,n**4]
    ÐṂ - filter keep those (only ever one) minimal:
   ạ   -   absolute difference (with n)
       - if a full program: implicit print (one item lists print their content).

PHP , 33 bayt

<?=(($argn**.5-.75)**.5+.5^0)**4;

Çevrimiçi deneyin!

PHP , 56 bayt

<?=2*$argn-($x=($f=$argn**.25^0)**4)>($y=++$f**4)?$y:$x;

Çevrimiçi deneyin!

C ++, 96 bayt

int Q(int N){int i=1;while (pow(i,4)<N){i++;}if (pow(i,4)-N>N-pow(i-1,4)){i--;}return pow(i,4);}

Tam versiyon:

int Q(int N)
{
    int i = 1;

    while (pow(i, 4) < N)
    {
        i++;
    }

    if (pow(i, 4)-N > N-pow(i - 1, 4))
        i--;

    return pow(i,4);
}

Denemek için LINK

Haskell, 35 bayt

f n=(floor$(n**0.5-3/4)**0.5+0.5)^4

Anders Limanı'nın Python3 yanıtı .

R , 47 44 37 35 bayt

n=scan();which.min(((1:n)^4-n)^2)^4

Çevrimiçi deneyin!

Pyth , 9 bayt

.maQb^R4S

Çevrimiçi deneyin!

Pyth , 17 bayt

@ AndersKaseorg'un cevabı ile aynı aritemik yaklaşımı kullanan tam bir program :

K.5^s+^-^QK.75KK4

Çevrimiçi deneyin!

Japt , 20 bayt

Bu çok uzun hissettiriyor!

õp4
V®nU a
VgWaWrmU

Dene

QBIC , 38 bayt

{p=q^4~p>:|~p-a>a-o|_Xo\_Xp]\o=p┘q=q+1

açıklama

{           DO infinitely
p=q^4       Set p to q quad (q starts out as 1)
~p>:|       IF p exceeds the input THEN
~p-a>a-o    check the distance to p and to o (the last quad) and
|_Xo        PRINT o, or
\_Xp        PRINT p accordingly
]           END IF
\o=p        ELSE  ( p <= input) store p in o to keep track of this quad
┘q=q+1      and raise q for the next iteration

Java (OpenJDK 8) , 64 bayt

n->{int i=0,q,Q=0;while((q=i*i*i*i++)<n)Q=q;return q-n<n-Q?q:Q;}

Çevrimiçi deneyin!

Ortak Lisp, 50 bayt

(lambda(x)(expt(floor(+(sqrt(-(sqrt x).75)).5))4))

Çevrimiçi deneyin!

C #, 95 bayt

namespace System.Linq{n=>new int[940].Select((_,i)=>i*i*i*i).OrderBy(i=>Math.Abs(i-n)).First()}

940'ı ayarlanmış bir değer olarak kullanırız, çünkü daha büyük herhangi bir değer int'den taşacaktır.

Tam / Biçimli Sürüm:

namespace System.Linq
{
    class P
    {
        static void Main()
        {
            Func<int, int> f = n => new int[940].Select((_, i) => i * i * i * i).OrderBy(i => Math.Abs(i - n)).First();

            for (int i = 1; i <= Int32.MaxValue; ++i)
                Console.WriteLine($"{i} = {f(i)}");

            Console.ReadLine();
        }
    }
}

Ruby , 23 34 bayt

Bunun için neden 0.75bu kadar önemli bir sayı olduğu hakkında hiçbir fikrim yok , ama ne işe yarıyorsa.

->n{((n**0.5-0.75)**0.5).round**4}

Çevrimiçi deneyin!