Betrachten Sie drei Zahlenfolgen A, Bund C:

• A: Eine auf wiederkehrenden Beziehungen basierende Sequenz f(n) = f(n-1)+f(n-2), beginnend mit f(1) = 3, f(2) = 4. Die Sequenz beginnt also so:3 4 7 11 18 29 47 76 ...
• B: Die zusammengesetzten Zahlen , dh alle Ganzzahlen, die keine Primzahlen (oder 1) sind:4 6 8 9 10 12 14 15 16 ...
• C: Die Ziffern von Pi: 3 1 4 1 5 9 2 6 5 ...

Bei einer positiven Ganzzahl N < 50, entweder als Funktionsargument oder als STDIN, wird der Dezimalwert des Bruchs A(N)/B(N)mit C(N)Nachkommastellen zurückgegeben. Es gelten die normalen Rundungsregeln (aufrunden, wenn die N + 1-te Ziffer 5 oder höher ist). Wenn die n-te Ziffer piNull ist, sollte eine Ganzzahl gedruckt werden. Wissenschaftliche Notation / Das Standardformular wird für Zahlen über 1000 akzeptiert.

Dies ist Codegolf, daher gewinnt die kürzeste Antwort in Bytes.

Einige Beispiele:

N = 1: 0.750
N = 2: 0.7
N = 3: 0.8750
N = 4: 1.2
N = 6: 2.416666667
N = 10: 11.056
N = 20: 764.8750

Natürlich gelten die Standard-Code-Golfregeln.

Die Funktion muss auf jedem modernen Laptop in weniger als zwei Minuten beendet sein.

Pyth, 60 57 58 Bytes

.[K`.Rchu,eGsGQjT7e.ftPZQ)Je/u+/*GHhyHy^TQr^T3ZZT\0+xK\.hJ

Kabelbaum testen

Es ist ganz einfach: Berechnen Sie pi, die Fibonacci-Reihe und die Komposite, gerundet auf C (n) -Ziffern, auf C (n) -Ziffern auffüllen und die Position der Dezimalstellen, fertig.

Ein): hu,eGsGQjT7

B (n): e.ftPZQ)

C (n): e/u+/*GHhyHy^TQr99ZZT

60 -> 57: Der Sonderfall n = 1 in der pi-Berechnung wurde bereinigt.

57 -> 58: Es wurde nicht genügend Präzision für pi für den gesamten Eingabebereich verwendet - 99 Iterationen wurden auf 1000 Iterationen erhöht.

Hinweis zum Runden: Dies verwendet Pythons "Nearest Even" -Rundungssystem und nicht das vom OP festgelegte "Into Infinity" -System. Der Unterschied ist jedoch nur dann von Bedeutung, wenn die unmittelbar auf den Rundungspunkt folgenden Stellen 5000...z. B. 1,25 auf 1 Stelle gerundet sind. Ich habe den Eingabebereich überprüft, und dies geschieht nie, sodass immer das richtige Ergebnis zurückgegeben wird.

PowerShell, 420 Bytes (JJJJJJJ) 378 Bytes

param($n);[int[]]$p="03141592653589793238462643383279502884197169399375"-Split'';$a=@(0,3,4);for($i=3;$i-lt50;$i++){$a+=$a[$i-1]+$a[$i-2]};$c=[char[]]"00001010111010111010111011111010111110111010111011111011111010111110111";$b=@(0);for($i=4;$i-le70;$i++){if($c[$i]-eq'1'){$b+=$i}};[double]$r=$a[$n]/$b[$n];$q=$p[$n+1];$s="";(0..($q-1))|%{$s+="0"};([math]::Round($r,$q,[MidpointRounding]::AwayFromZero)).ToString("0.$s")

_{Danke an isaacg für das Speichern von 41 Bytes, für die Berechnung, wie die Frage rundet. Bedeutet, dass ich das Schreckliche nicht mit einbeziehen musste [MidpointRounding]::AwayFromZeround nicht explizit als [double].}

Dieser hat großen Spaß gemacht!

Erweitert:

# Take input N
param($n)

# First digits of pi, stored as integer array
[int[]]$p="03141592653589793238462643383279502884197169399375"-Split''

# Fibonacci sequence A(N)
$a=@(0,3,4)
for($i=3;$i-lt50;$i++){
  $a+=$a[$i-1]+$a[$i-2]
}

# Zero-indexed bitmask for if the n-th integer is composite (1) or not (0)
$c=[char[]]"00001010111010111010111011111010111110111010111011111011111010111110111"

# Populate B(N) as an array using the $c mask
$b=@(0)
for($i=4;$i-le70;$i++){
  if($c[$i]-eq'1'){
    $b+=$i
  }
}

# Calculation Time!
$r=(a($n))/$b[$n]

# A small golf, as $p[$n+1] gets used a couple times
$q=$p[$n+1]

# Need to generate a string of zeroes for padding
$s=""
(0..($q-1))|%{$s+="0"}

# Round the number, then send it to a string so we get the necessary number of zeroes
([math]::Round($r,$q)).ToString("0.$s")

Die Rekursion in PowerShell ist ... langsam, sagen wir mal, also müssen wir A(N)die andere Richtung bauen und sie in einem Array speichern und dann indizieren.

ALT

Auch, heilige Kuh, haben die Ausgabeanforderungen dies zunichte gemacht. PowerShell rundet standardmäßig auf die nächste a / k / a-Banker-Rundung, was die Verwendung der außerordentlich ausführlichen [MidpointRounding]::AwayFromZeroAngaben zum Wechseln der Rundungsstile erforderlich macht . Darüber hinaus müssen wir gegebenenfalls nachfolgende Nullen auffüllen. Diese beiden Anforderungen haben zusammengenommen die letzten Zeilen von 20 Bytes [math]::Round($r,$q) auf 102 Bytes (von $s=""bis +$s)) geändert ... wow.

Javascript (ES6), 302 Bytes

Ein Wort: Unvollendet.

x=>{a=[0,3,4],b=[0],c='03141592653589793238462643383279502884197169399375';for(i=1;i<x;a[i+2]=a[i]+a[++i]);for(i=1,p=[];++i<70;v=p.every(x=>i%x),(v?p:b).push(i));r=''+Math.round(a[x]/b[x]*(l=Math.pow(10,c[x])))/l;if(x==33)return r;r.indexOf`.`<0&&(r+='.');while(!r[r.indexOf`.`+ +c[x]])r+='0';return r}

Die ersten 49 Stellen von pi werden in einer Zeichenfolge gespeichert, und die anderen beiden Sequenzen werden automatisch generiert. Dies wurde etwa auf halber Strecke golfen; Ich bin (fast) sicher, dass ich weitere 50 Bytes herausholen könnte.

Funktioniert für alle Testfälle und sollte für den Rest funktionieren. Abstürze bei mehr als 49 oder weniger als 0 (diese Situationen sollten sowieso nie auftreten). Besonders gut gefällt mir das Ergebnis für 0:

NaN.

Oktave, 276 236 Bytes

Zunächst dachte ich, es wäre cool, in diesen mathematischen Werkzeugen eine unbegrenzte Genauigkeit zu verwenden (und etwas Wissen darüber aufzufrischen), also fing ich an, einige Algorithmen zu schreiben, und fand schließlich heraus, dass der piWert nicht so genau ist, wie ich muss das Array erneut verwenden. Also wieder kein großer Erfolg:

function c(A)p="3141592653589793238462643383279502884197169399375";f=ones (1,50);f(1)=3;f(2)=4;for i=3:53f(i)=f(i-1)+f(i-2);end
i=0;x=1;while i<A
x++;for j=2:x/2
if mod(x,j)==0 i++;break;end end end
printf(["%." p(A) "f\n"],f(A)/x);end

Immer noch gut lesbar, nicht wahr?

Verwendung

Kopieren-Einfügen-Funktion in Oktave, Funktion cmit Argument des gewünschten Wertes aufrufen :

>>> c(1)
0.750
>>> c(49)
407880480.04348

Optimierungen:

• Ersatz endif, endforund ähnlich mit enddenen die gleiche Weise funktioniert
• Variable ium eins verringern , ein Byte speichern
• num2str(str2num(p(A)))Unsinn entfernen :)