Mezzi metallici di alta precisione

13

sfondo

I mezzi metallici , a partire dalla famosa media d'oro , sono definiti per ogni numero naturale (numero intero positivo) e ognuno è una costante irrazionale (ha un'espansione decimale infinita non ricorrente).

Per un numero naturale , la media metallica è la radice di un'equazione quadratica

Le radici sono sempre

ma la media metallica viene generalmente indicata come radice positiva. Quindi per questa domanda sarà definita da:

Per il risultato è il famoso rapporto aureo:

Sfida

Il codice dovrebbe richiedere 2 input: n e p (l'ordine non è importante finché è coerente)

  • n è un numero naturale che indica quale media metallica
  • p è un numero naturale che indica quante posizioni decimali di precisione

Il tuo codice dovrebbe generare l'ennesima media metallica con precisione decimale.

Validità

Il tuo codice è valido se funziona per valori di n e p compresi tra 1 e 65.535.

È necessario generare un decimale nel modulo

digit (s) .digit (s) (senza spazi)

Ad esempio, la media aurea con 9 cifre decimali è

1,618,033988 millions

Visualizza l'ultima cifra senza arrotondare, come apparirebbe in un'espansione decimale più lunga. La cifra successiva nella media aurea è un 7, ma l'ultimo 8 nell'esempio non deve essere arrotondato per eccesso a un 9.

Il numero di cifre decimali deve essere p, il che significa che devono essere inclusi anche eventuali zero finali.

Risposte del modulo

non sono validi: è necessario utilizzare un'espansione decimale.

È possibile generare fino a 1 newline principale e fino a 1 newline finale. Non è possibile generare spazi o altri caratteri oltre alle cifre e al punto singolo / punto / punto completo.

Punto

Questo è un codice golf standard: il tuo punteggio è il numero di byte nel tuo codice.

Classifica

(Utilizzando lo snippet della classifica di Martin )

Mostra snippet di codice

code-golf 
— trichoplax
fonte

Risposte:

17

dc, 12

?kdd*4+v+2/p
  • ? Spingere n e p sulla pila
  • k imposta la precisione su p
  • dd duplica n due volte (totale tre copie)
  • * moltiplicare n * n
  • 4+ aggiungi 4
  • v prendi radice quadrata
  • + aggiungi n (ultima copia in pila)
  • 2/ dividere per 2
  • p Stampa

TestCase:

$ dc -f metalmean.dc <<< "1 9"
1.618033988
$
— Trauma digitale
fonte
7
Strumento giusto per il lavoro.
— Dennis,
5
@Dennis deve essere la prima volta che CJam è quasi 3 volte più lunga di qualcos'altro ;-)
— Digital Trauma
2

R, 116 byte

library(Rmpfr);s=scan();n=mpfr(s[1],1e6);r=(n+(4+n^2)^.5)/2;t=toString(format(r,s[2]+2));cat(substr(t,1,nchar(t)-1))

Questo legge due numeri interi da STDIN e stampa il risultato su STDOUT. Puoi provarlo online .

Ungolfed + spiegazione:

# Import the Rmpfr library for arbitrary precision floating point arithmetic
library(Rmpfr)

# Read two integers from STDIN
s <- scan()

# Set n equal to the first input as an mpfr object with 1e6 bits of precision
n <- mpfr(s[1], 1e6)

# Compute the result using the basic formula
r <- (n + sqrt(4 + n^2)) / 2

# Get the rounded string representation of r with 1 more digit than necessary
t <- toString(format(r, s[2] + 2))

# Print the result with p unrounded digits
cat(substr(t, 1, nchar(t) - 1))

Se non hai Rmpfrinstallato la libreria, puoi install.packages("Rmpfr")e tutti i tuoi sogni diventeranno realtà.

— Alex A.
fonte
1

Mathematica, 50 byte

SetAccuracy[Floor[(#+Sqrt[4+#^2])/2,10^-#2],#2+1]&

Definisce una funzione anonima che accetta ne pin ordine. Uso Floorper evitare l'arrotondamento SetAccuracy, di cui ho bisogno per ottenere un risultato decimale.

— 2012rcampion
fonte
@Arcinde Purtroppo non posso usare i numeri di precisione della macchina, dal momento che non sarebbero in grado di gestirli p>15.
— 2012campo
1

CJam, 35 byte

1'el+~1$*_2#2$2#4*+mQ+2/1$md@+s0'.t

Prima legge p , poi n .

Provalo online nell'interprete CJam .

Come funziona

Calcoliamo semplicemente la formula dalla domanda per n × 10 p , otteniamo la parte intera e frazionaria del risultato divisa per 10 p , riempiamo la parte frazionaria con zero iniziali per ottenere cifre p e stampare le parti separate da un punto.

1'e  e# Push 1 and 'e'.
l+   e# Read a line from STDIN and prepend the 'e'.
~    e# Evaluate. This pushes 10**p (e.g., 1e3 -> 1000) and n.
1$*  e# Copy 10**p and multiply it with n.
_2#  e# Copy n * 10**p and square it.
2$   e# Copy 10**p.
2#4* e# Square and multiply by 4.
+    e# Add (n * 10**p)**2 and 4 * 10**2p.
mQ   e# Push the integer part of the square root.
+2/  e# Add to n * 10**p and divide by 2.
1$md e# Perform modular division by 10**p.
@+s  e# Add 10**p to the fractional part and convert to string. 
0'.t e# Replace the first character ('1') by a dot.
— Dennis
fonte
1

Python 2, 92 byte

Mentre sto guardando le risposte, sembra che la risposta di CJam usi lo stesso metodo di base di questo. Calcola la risposta per n*10**pe quindi aggiunge il punto decimale. È incredibilmente inefficiente a causa del modo in cui calcola la parte intera della radice quadrata (aggiungendo solo 1 finché non arriva).

n,p=input()
e=10**p;r=0
while(n*n+4)*e*e>r*r:r+=1
s=str((n*e+r-1)/2);print s[:-p]+'.'+s[-p:]
— KSab
fonte
1

PHP, 85 78 byte

echo bcdiv(bcadd($n=$argv[bcscale($argv[2])],bcsqrt(bcadd(4,bcpow($n,2)))),2);

Utilizza l' estensione matematica BC Math che, su alcuni sistemi, non potrebbe essere disponibile. Deve essere incluso nel tempo di compilazione specificando il--enable-bcmath opzione della riga di comando. È sempre disponibile su Windows e sembra che sia incluso nella versione PHP in bundle con OSX.

Aggiornamento :

Ho applicato tutti gli hack suggeriti da @blackhole nei loro commenti (grazie!), Quindi ho $ninserito l'inizializzazione nel suo primo utilizzo (altri 3 byte salvati) e ora il codice si inserisce in una singola riga nella casella di codice in alto.

— axiac
fonte
@Buco nero. 85, davvero. Probabilmente ho letto 86 (fatto una selezione leggermente più grande) e ho scritto 68 per errore. Riparato ora.
— axiac,
1
Nessun problema :). In ogni caso, puoi avere 1 byte in meno: rimuovi la parentesi attorno a echo, lascia solo uno spazio dopo di essa.
— Blackhole,
1
E poiché prevedi bcscaledi tornare true, puoi utilizzare $n=$argv[bcscale($argv[2])];e salvare altri 2 byte.
— Blackhole,
È un bel trucco.
— axiac,
La sporcizia del codice è un'arte: P. Oh, l'ultimo: bcpow($n,2)invece di bcmul($n,$n)risparmiare 1 byte.
— Blackhole,
1

J, 27 byte

4 :'}:":!.(2+x)-:y+%:4+*:y'

Spiegazione:

4 :'                      '   | Define an explicit dyad
                       *:y    | Square y
                     4+       | Add 4
                   %:         | Square root
                 y+           | Add y
               -:             | Half
      ":!.(2+x)               | Set print precision to 2+x
    }:                        | Remove last digit, to fix rounding

Chiamalo così:

    9 (4 :'}:":!.(2+x)-:y+%:4+*:y') 1
1.618033988

Un'altra soluzione leggermente più fredda:

4 :'}:":!.(2+x){.>{:p._1,1,~-y'

Il che calcola le radici del polinomio x ^ 2 - nx - 1. Sfortunatamente, il modo in cui J formatta il risultato rende leggermente più lungo il recupero della radice desiderata.

— Bolce Bussiere
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.