18

Un numero biquadratico è un numero che rappresenta la quarta potenza di un altro numero intero, ad esempio: 3^4 = 3*3*3*3 = 81

Dato un numero intero come input, emette il numero biquadratico più vicino.

Ecco i primi 15 quadrati doppi:

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

Si tratta di code-golf quindi vince il minor numero di byte in ogni lingua

Questo è OEIS A000583

— Skidsdev
fonte

È interessante notare che questo non legherà mai, poiché la sequenza alterna numeri pari e dispari.

— Okx,

5

potresti cambiare il nome in "Trova lo zenzizenzico più vicino". en.wiktionary.org/wiki/zenzizenzic

— Destructible Lemon

1

@Mayube Lo fa necessariamente, perché la sequenza è giusta n^4e si nalterna in segno.

— Martin Ender,

2

Quella nomenclatura di biquadratic è confusa: prima di vedere il contenuto della domanda, ho pensato che fossero i 2 x n²numeri: 2, 8, 18, 32, 50, 72, 98, ...

— sergiol

2

Non si chiama "quartico"? ( Merriam-Webster , Wikizionario )

— Olivier Grégoire,

15

Python 3 , 35 byte

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

Provalo online!

Come funziona

Il valore n in corrispondenza del quale l'uscita passa da ( k - 1) ⁴ a k ⁴ soddisfa √ (√n - 3/4) + 1/2 = k , oppure n = ((k - 1/2) ² + 3 / 4) ² = ( k ² - k + 1) ² = (( k - 1) ⁴ + k ⁴ + 1) / 2, che è esattamente il primo intero più vicino a k ⁴ .

(Funziona per tutti n ≤ 4504699340341245 = (8192 ⁴ + 8193 ⁴ - 7) / 2> 2 ⁵² , dopo di che il roundoff in virgola mobile inizia a romperlo, anche se funziona matematicamente per tutti i n .)

— Anders Kaseorg
fonte

È possibile salvare un byte con roundse si passa a Python 2 che arrotonda per eccesso tutti i 0,5.

— xnor

8

Ottava , 35 byte

Questa sfida aveva bisogno di un approccio basato sulla convoluzione.

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

Provalo online!

Spiegazione

L'espressione (1:n).^4produce il vettore riga [1 16 81 256 ... n^4].

Questo vettore viene quindi contorto [1 1]/2, il che equivale a calcolare la media mobile di blocchi di dimensioni 2. Ciò presuppone implicitamente che il vettore sia imbottito a destra e a sinistra 0. Quindi il primo valore nel risultato è 0.5(media di un implicito 0e 1), il secondo è 8.5(media di 1e 16), ecc.

Ad esempio, per n = 9il risultato di 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

Il confronto n>...quindi cede

1 1 0 0 0 0 0 0 0 0 0

e l'applicazione sum(...)dà 2. Ciò significa che nsupera esattamente 2i punti medi tra i numeri biquadratici (incluso il punto intermedio aggiuntivo 0.5). Infine, ^4solleva questo 4per ottenere il risultato 16.

— Luis Mendo
fonte

2

È ancora più golfista!

— Flawr,

7

Haskell , 51 49 byte

Funzione monade ftw!

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

Provalo online!

Spiegazione:

                                (^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)

— flawr
fonte

6

MATL , 6 byte

t:4^Yk

Provalo online!

Spiegazione

Considera l'input 9come esempio.

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

— Luis Mendo
fonte

5

Neim , 5 byte

𝐈4𝕎S𝕔

Spiegazione:

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

Provalo online!

— Okx
fonte

2

Questo linguaggio di programmazione sembra utilizzare caratteri Unicode ("𝕎" e "𝕔"). Tali caratteri richiedono in genere più di un byte. Sei sicuro che i 5 caratteri possano essere memorizzati usando solo 5 byte?

— Martin Rosenau,

3

@MartinRosenau Neim utilizza una tabella codici personalizzata

— Okx,

5

Excel, 25 byte

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

Excel lo aggiorna a =INT((A1^0.5-3/4)^0.5+0.5)^4

— Wernisch
fonte

1

Solo una nota sulla convenzione per Excel: è lo standard di fatto che Excel e Excel VBA che prendono input Excel.ActiveSheetdall'oggetto li prendono dalla cellaA1

— Taylor Scott

1

@TaylorScott, grazie per averlo sottolineato. Ho aggiornato.

— Wernisch,

4

Mathematica, 21 byte

Nearest[Range@#^4,#]&

— Martin Ender
fonte

4

Brachylog , 9 byte

;I≜+.~^₄∧

Provalo online!

Spiegazione

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

— Fatalize
fonte

3

JavaScript (ES7), 42 byte

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

Versione ricorsiva, 44 byte

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

dimostrazione

Mostra snippet di codice

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

Espandi frammento

— Arnauld
fonte

3

Ottava , 37 byte

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

Funzione anonima che utilizza l'interpolazione del vicino più vicino.

Provalo online!

— Luis Mendo
fonte

2

-1 no conv :(

— flawr

1

@flawr fa questo ti fa sentire meglio?

— Luis Mendo,

1

Lo fa molto!

— Flawr,

2

05AB1E , 6 byte

LnnI.x

Provalo online!

Spiegazione

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

— Datboi
fonte

2

APL, 22 byte

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

Provalo online!

Come?

o←4*⍨⍳⍵- o= range ( ⍵) ⁴ _{[vettorializzare]}

p←|⍵-⍨o- p= abs ( o- ⍵) _{[vettorializzare]}

o/⍨- prendi l' oelemento nell'indice dove ...

p=⌊/p- l' pelemento minimo è

— Uriel
fonte

2

Gelatina , 6 byte

R*4ạÐṂ

Un collegamento monadico che restituisce un elenco di un elemento o un programma completo che stampa il risultato (utilizzando un metodo inefficiente).

Provalo online!

Come?

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).

— Jonathan Allan
fonte

1

PHP , 33 byte

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

Provalo online!

PHP , 56 byte

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

Provalo online!

— Jörg Hülsermann
fonte

1

C ++, 96 byte

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

Versione completa:

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

LINK da provare

— koita_pisw_sou
fonte

1

Haskell, 35 byte

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

Python3 di Port of Anders .

— CR Drost
fonte

1

R , 47 44 37 35 byte

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

Provalo online!

— Maxim Mikhaylov
fonte

puoi restituire una funzione anonima (rimozione f=) e invece di x[which.min((x-n)^2)]utilizzarla which.min((x-n)^2)^4, quindi inserirla f=nell'intestazione del link TIO per test come qui :)

— Giuseppe,

1

@Giuseppe Oh, non è necessario definirlo xaffatto. Grazie!

— Maxim Mikhaylov,

ah, quindi l'unico altro miglioramento sta prendendo l'input da stdin n=scan();which.min(((1:n)^4-n)^2)^4e l'input va nella sezione piè di pagina su TIO.

— Giuseppe,

@Giuseppe Grazie ancora! Utile da sapere per le risposte future in R.

— Maxim Mikhaylov,

1

Pyth , 9 byte

.maQb^R4S

Provalo online!

Pyth , 17 byte

Un programma completo che utilizza lo stesso approccio aritmico della risposta di @ AndersKaseorg :

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

Provalo online!

— Mr. Xcoder
fonte

0

Japt , 20 byte

Sembra troppo lungo!


õp4
V®nU a
VgWaWrmU

Provalo

— ispido
fonte

0

QBIC , 38 byte

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

Spiegazione

{           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

— steenbergh
fonte

0

Java (OpenJDK 8) , 64 byte

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

Provalo online!

— Olivier Grégoire
fonte

0

Lisp comune, 50 byte

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

Provalo online!

— Renzo
fonte

0

C #, 95 byte

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

Usiamo 940 come valore impostato poiché qualsiasi valore maggiore trabocca int.

Versione completa / formattata:

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

— TheLethalCoder
fonte

0

Ruby , 23 anni 34 byte

Non ho idea del perché 0.75sia un numero così importante per questo, ma ehi, qualunque cosa funzioni.

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

Provalo online!

— Value Ink
fonte

Questo non darà il biquadratico più vicino. Ad esempio, restituirà 256 per 151.

— P.Péter,

Trova il numero biquadratico più vicino

Python 3 , 35 byte

Come funziona

Ottava , 35 byte

Spiegazione

Haskell , 51 49 byte

MATL , 6 byte

Spiegazione

Neim , 5 byte

Excel, 25 byte

Mathematica, 21 byte

Brachylog , 9 byte

Spiegazione

JavaScript (ES7), 42 byte

Versione ricorsiva, 44 byte

dimostrazione

Ottava , 37 byte

05AB1E , 6 byte

Spiegazione

APL, 22 byte

Gelatina , 6 byte

Come?

PHP , 33 byte

PHP , 56 byte

Haskell, 35 byte

R , 47 44 37 35 byte

Pyth , 9 byte

Pyth , 17 byte

Japt , 20 byte

QBIC , 38 byte

Spiegazione

Java (OpenJDK 8) , 64 byte

Lisp comune, 50 byte

C #, 95 byte

Ruby , 23 anni 34 byte