10

Il tuo compito è prendere una matrice di numeri e un numero reale e restituire il valore in quel punto della matrice. Le matrici iniziano da $\pi$ e vengono contate in intervalli di $\pi$ . Il fatto è che in realtà interpoleremo tra gli elementi dato l '"indice". Come esempio:

Index:    1π   2π   3π   4π   5π   6π
Array: [ 1.1, 1.3, 6.9, 4.2, 1.3, 3.7 ]

Poiché è $\pi$ , dobbiamo fare la trigonometria obbligatoria, quindi useremo l'interpolazione del coseno usando la seguente formula:

${\cos(i \mod \pi) + 1 \over 2} * (\alpha - \beta) + \beta$

dove:

$i$ è il "index" input
$\alpha$ è il valore dell'elemento immediatamente prima dell '"indice"
$\beta$ è il valore dell'elemento immediatamente dopo l '"indice"
$\cos$ prende il suo angolo in radianti

Esempio

Dato [1.3, 3.7, 6.9], 5.3:

L'indice 5.3 è compreso tra $1\pi$ e $2\pi$ , quindi 1.3 verrà utilizzato per beforee 3.7 verrà utilizzato per after. Mettendolo nella formula, otteniamo:

${\cos(5.3 \mod \pi) + 1 \over 2} * (1.3 - 3.7) + 3.7$

Che esce a 3.165

Appunti

L'input e l'output possono essere in qualsiasi formato conveniente
Si può presumere che il numero di input sia maggiore di $\pi$ e minore di array length* $\pi$
Si può presumere che l'array di input sarà lungo almeno 2 elementi.
Il risultato deve avere almeno due punti decimali di precisione, essere accurati entro 0,05 e supportare numeri fino a 100 per questa precisione / accuratezza. (i galleggianti a precisione singola sono più che sufficienti per soddisfare questo requisito)

Buon golf!

code-golf array

— Beefster
fonte

8

Per i golfisti, potrebbe essere più breve scrivere riscrivere come usando la formula del mezzo angolo per .

(\cos (x) + 1) / 2

$(\cos(x)+1)/2$

\cos (x / 2)^{2}

$\cos(x/2)^2$

\cos

$\cos$

— xnor

Posso prendere in un dizionario con i doppi come chiavi? I doppi saranno numeri interi, ovviamente.

— Incarnazione dell'ignoranza

@EmbodimentofIgnorance, certo. Dubito che ti aiuterà, ma è una rappresentazione perfettamente ragionevole degli array poiché è così che Lua lo fa.

— Beefster

@KevinCruijssen Non vedo perché sia importante. 3.7 è tra pi e 2pi.

— Beefster

5

R , 59 53 byte

function(x,i)x[0:1+i%/%pi]%*%c(a<-cos(i%%pi/2)^2,1-a)

Provalo online!

Niente di troppo intelligente qui - solo una versione R della formula nella domanda. Grazie @MickyT per aver salvato un byte, e @Giueseppe e indirettamente @xnor per altri due, e grazie a @RobinRyder per averne salvato altri 3.

— Nick Kennedy
fonte

Penso che puoi rilasciare un byte con...*(cos(i%%pi)+1)/2

— MickyT

@MickyT grazie, avevo originariamente messo il +1 tra parentesi, ma avevo aggiunto una coppia di parentesi ridondanti, finendo con 60 byte

— Nick Kennedy

56 byte in seguito al commento di xnor sulla formula del mezzo angolo.

— Giuseppe

1

53 byte

— Robin Ryder,

4

Python 3.8 (pre-release) , 85 74 byte

-8 byte grazie a @xnor
-2 byte grazie a @Quintec

Questo sfrutta il nuovo :=operatore di assegnazione della pre-release di Python 3.8 . A parte questo, questa è davvero solo l'equazione scritta in Python.

import math
lambda l,i:cos(i%math.pi/2)**2*(l[(j:=int(i/pi))-1]-l[j])+l[j]

Uso:

>>> p=lambda l,i:cos(i%math.pi/2)**2*(l[(j:=int(i/pi))-1]-l[j])+l[j]
>>> print(p([1.3, 3.7, 6.9],5.3))
3.165249203414993

Provalo online!

— senox13
fonte

1

Puoi semplicemente assegnare jil primo posto in cui è menzionato : parte del potere delle espressioni di assegnazione è che valutano il valore e lo assegnano.

— xnor

1

Un altro salvataggio di byte: utilizzare le identità trig per convertire (cos(i%pi)+1)/2 incos(i%pi/2)**2

— xnor

@xnor Ottimo punto. Sapevo che stavo usando quello sbagliato

— senox13

1

Puoi eliminare le p=funzioni anonime perché sono ok

— Quintec

1

Hai dimenticato di aggiornare bytecount :)

— Quintec

3

Gelatina , 17 byte

d©ØPṪÆẠ‘H×I_@Ḋ}®ị

Un programma completo che accetta e l'array che stampa il valore interpolato. $i$

Provalo online!

Come?

Interpola tra tutti i vicini usando quindi seleziona il valore rilevante. $\frac{\cos(i \mod \pi)+1}2$

d©ØPṪÆẠ‘H×I_@Ḋ}®ị - Link: number, i; list of numbers, A
  ØP              - pi (ish) = 3.141592653589793
d                 - divmod = [i//pi, i%pi]
 ©                - (copy to register for later)
    Ṫ             - tail (gets i%pi leaving register copy as [i//pi])  
     ÆẠ           - cosine = cos(i%pi)
       ‘          - increment
        H         - halve
         ×        - multiply by A (vectorises)
          I       - increments -- i.e. (cos(i%pi)+1)(r-l)/2 for neighbours [l,r]
             Ḋ}   - dequeue A
           _@     - swapped arg subtract (vectorises) -- i.e. r-(cos(i%pi)+1)(r-l)/2
                  -                                         = r+(cos(i%pi)+1)(l-r)/2
               ®  - recall value from the register
                ị - index into (vectorises) -- i.e. [β+(cos(i%pi)+1)(α-β)/2]
                  - implicit print of Jelly representation (only 1 entry so [] wont appear)

— Jonathan Allan
fonte

2

C # (compilatore interattivo Visual C #) , 69 byte

n=>m=>(Math.Cos(m%Math.PI)+1)/2*(n[m=(int)(m/Math.PI)-1]-n[++m])+n[m]

~~Ho battuto Python!~~ ~~Accidenti, Python mi ha battuto.~~ Ho battuto di nuovo Python!

Provalo online!

— Incarnazione dell'ignoranza
fonte

1

Guarda il lato positivo. Nessuno di noi aveva una possibilità contro Jelly

— senox13

@ senox13 Tranne forse Stax

— Incarnazione dell'ignoranza

1

Röda , 51 byte

f a,i{j=i//PI;[(cos(i%PI)+1)/2*(a[j-1]-a[j])+a[j]]}

Provalo online!

— fergusq
fonte

1

Stax , 17 byte

≈ëBü☺ÆssÅ¢â)KjjïΔ

Esegui ed esegui il debug

Disimballato, ungolfed e commentato sembra così.

VP|%    divmod with pi;  push div and mod results separately
|7^h    do (cos(modpart) + 1) / 2
sX      swap the original div result to top of stack, store it in the x register
v       decrement
;:-     pairwise differences of array
@       get element at index
N*      negate and multiply
;x@     get element from the original array at the x index, where x is the register
+       add

Esegui questo

— ricorsivo
fonte

1

Japt , 47 46 38 byte

u0;J=V/MP[A=UgJc) nUgJf))½McVuMP)Ä]×+A

Continua ... (golf)

Provalo online!

— Quintec
fonte

1

APL + WIN, 39 37 byte

2 byte salvati grazie ad Adám

2⊃m+(-/m←⎕[0 1+⌊n÷○1])÷2÷1+2○(○1)|n←⎕

Provalo online! Dyalog Classic

Spiegazione:

n←⎕ prompt for input of integer

2÷1+2○(○1)|n evaluate first term of formula

[0 1+⌊n÷○1] identify indices of alpha and beta

m←⎕[...] prompt for input of vector and select alpha and beta

-/m alpha-beta

2⊃m+ take result of adding beta to complete the equation

— Graham
fonte

×.5×→ ÷2÷e m[2]→2⊃m

— Adám

1

Haskell , 65 byte

v!i|(c,r)<-properFraction$i/pi=cos(r*pi/2)^2*(v!!(c-1)-v!!c)+v!!c

Provalo online!

Nota: l'array è rappresentato come un elenco.

Grazie a @xnor per la punta a mezzo angolo.

— dfeuer
fonte

0

Gelatina , 23 20 18 byte

³%ØPÆẠ×_++H
÷ØPịÇ/

Provalo online!

÷ØPịṁØ½µ³%ØPÆẠ×I_@SH    Dyadic link, arguments x (index) and Z (array):
÷ØP                     x/pi
   ị                    Index (into Z).
                        When x/pi is an integer, returns that elt of Z.
                        Otherwise returns 2 elements at floor and ceiling.
     Ø½                   [1,2] (generic 2 element array)
    ṁØ½                 Mold; shape like [1,2] to ensure we have 2 elements.
       µ                Start a new, monadic chain with the result [a,b]
        ³%ØPÆẠ×I_@SH    Monadic chain
        ³               x
         %ØP            x mod pi
            ÆẠ          Unarccosine; cos(x mod pi).
               I          Increment; b-a.
              ×I        (b-a) cos(x mod pi)
                  S       a+b
                _@S     a + b - (b-a) cos(x mod pi)
                   H    Halve; this is equivalent to our desired result.

— lirtosiast
fonte

0

Attache , 54 byte

${Cos[y%PI/2]^2*&`-@(j:=x[1'-1*Floor[y'-y/PI]-1])+j@1}

Provalo online!

Spiegazione

${Cos[y%PI/2]^2*&`-@(j:=x[1'-1*Floor[y'-y/PI]-1])+j@1}
${                                                   }  parameters: x, y
  Cos[y%PI/2]^2                                         the scaling function factor
               *                                        times
                     j:=                                set j to
                        x[                     ]        the element in x at
                          1'-1*Floor[y'-y/PI]-1         the closest indices scaled by PI
                &`-@(                           )       spread subtraction over bounds
                                                 +j@1   add the upper bound

— Conor O'Brien
fonte

0

C (GCC) 99 79 byte

-20 byte plafoniera

float P=3.141593;b;
#define f(i,a)(cos(fmod(i,P))+1)/2*(a[b=i/P-1]-a[++b])+a[b]

Provalo online!

Codice di chiamata

int main() {
  float a[3] = {1.3,3.7,6.9};
  printf("%f\n", f(5.3,a));
}

nota che aveva bisogno del flag del compilatore -lmper collegarsi con le librerie matematiche, quindi +3 byte se lo conti.

— rtpax
fonte

0

05AB1E , 22 21 20 19 byte

žq‰`Å¾>;UÝèÐÁ-θX*-θ

Provalo online o verifica alcuni altri casi di test .

Spiegazione:

žq‰        # Take the divmod PI of the (implicit) input-decimal
           # (part = input integer-divided by PI, remainder = input modulo-PI)
           #  i.e. 5.3 → [1, 2.158...]
   `       # Push both values separately to the stack
    Å¾     # Take the cosine of the remainder
           #  i.e. 2.158... → -0.554...
      >    # Increase it by 1
           #  i.e. -0.554... → 0.554...
       ;   # Halve it
           #  i.e. 0.554... → 0.222...
        U  # Pop and store it in variable `X`
    Ý      # Pop the part, and push a list in the range [0, part]
           #  i.e. 1 → [0, 1]
     è     # (0-based) index all of them into the (implicit) input-list
           #   i.e. [1.3, 3.7, 6.9] and [0, 1] → [1.3, 3.7]
Ð          # Triplicate this list
 Á         # Rotate the last copy once towards the right
           #  i.e. [1.3, 3.7] → [3.7, 1.3]
  -        # Subtract the values in the top two lists from one another
           #  i.e. [1.3, 3.7] and [3.7, 1.3] → [-2.4, 2.4]
   θ       # Pop and only leave the last value of this list
           #  i.e. [-2.4, 2.4] → 2.4
    X*     # Multiply it by `X`
           #  i.e. 2.4 * `X`=0.222... → 0.534...
     -     # Subtract it from each of the values in the list we triplicated
           #  i.e. [1.3, 3.7] - 0.534... → [0.765..., 3.165...]
      θ    # And only leave the last value of this list
           #  i.e. [0.765..., 3.165...] → 3.165...
           # (which is output implicitly as result)

— Kevin Cruijssen
fonte

0

Rubino , 67 byte

->a,i{z=Math::PI;Math.cos(i%z/2)**2*(a[-1+j=(i/z).to_i]-a[j])+a[j]}

Provalo online!

— Value Ink
fonte