Integers in cosine

Question

Integers in cosine

From trigonometry we know that

\$\sin(a) =-\cos(a + \frac{(4*m + 1)\pi}{2})\$

where \$a\$ is an angle and \$m\in\mathbb{Z}\$ (integer).

The task

For an input of a positive integer \$n\$ calculate the value of the integer \$k\$ with \$n\$ digits that minimizes the difference between \$\sin(a)\$ and \$-\cos(a + k)\$. Or in a simpler way, generate the sequence A308879.

First few values

1 digit : 8
2 digits: 33
3 digits: 699
4 digits: 9929
5 digits: 51819
6 digits: 573204

Output

You can create a function or print the result on the standard output. Your program needs to be able to calculate at least the 6 cases in the section above.

Scoring

This is code-golf, shortest code in bytes wins.

Reference

https://www.iquilezles.org/blog/?p=4760

Answer 1

Wolfram Language (Mathematica), 25 bytes

This uses a trick: Mathematica doesn't expand Sin[51819] into a proper number even when Max is called on a list of such things, and because of how Last works, it doesn't care that Sin[51819] is not a list and simply returns 51819.

Last@Max@Sin@Range[10^#]&

Try it online!

Answer 2

Ruby, 37 bytes

->n{(1..10**n).max_by{|k|Math.sin k}}

Try it online!

Minimising the difference between \$\sin(a)\$ and \$-\cos(a+k)\$ amounts to minimising \$|k-(4m+1)\pi/2|\$ for some \$m\$, or equivalently maximising \$\sin(k)\$.

Iterating over (1..10**n) works at least for \$n\le6\$, as required. More generally, according to the OEIS (reference courtesy of @Λ̸̸'s 05AB1E answer):

It is not guaranteed that each term in the sequence produces a better approximation than the previous one, although numerical evidence suggests so.

Iterating over (10**~-n...10**n) is guaranteed to work for any \$n\$, at a cost of 7 extra bytes.

Answer 3

05AB1E, 7 bytes

Port of Dingus's answer. (It's A308879. From that page, it says that the sequence is also "the n-digit integer m that maximizes sin(m)"...)

°LΣŽ}θ

Try it online!

Explanation

°       10 ** n
 L      1 range
  Σ     Sort by:
   Ž}  Sine
      θ Maximum under that mapping

Answer 4

R 30 27 bytes

Following the same thread as @Dingus' Ruby answer, as indicated in the entry to A308879, i.e. looking at the maximum value of \$\sin(k)\$ over \$1,\ldots,10^n\$:

which.max(sin(1:10^scan()))

Try it online!

Answer 5

Java 8, 91 bytes

n->{double r=0,m=0,s,k=Math.pow(10,n);for(;k-->1;)if((s=Math.sin(k))>m){m=s;r=k;}return r;}

Port of @Dingus' Ruby answer, so make sure to upvote him!

Try it online. (It's barely able to reach up to \$n=9\$ on TIO before it times out.)

Explanation:

n->{                           // Method with integer parameter and double return-type
  double r=0,                  //  Result-double, starting at 0
         m=0,                  //  Maximum `m`, starting at 0
         s,                    //  Integer `s` for the Sine calculation, uninitialized
  k=Math.pow(10,n);for(;k-->1; //  Loop `k` in the range (10^input, 1]:
    if((s=Math.sin(k))         //   Set `s` to the Sine of `k`
       >m){                    //   If this `s` is larger than the current maximum `m`:
      m=s;                     //    Replace the maximum with this `s`
      r=k;}                    //    And replace the result with `k`
  return r;}                   //  Return the result after the loop

Answer 6

JavaScript (Node.js), 64 63 bytes

n=>[...Array(t=10**n)].map(_=>[9-Math.sin(--t),t]).sort()[0][1]

Try it online!

Answer 7

Japt -h, 10 bytes

ApU õ ñ!sM

Try it

Answer 8

APL (Dyalog Extended), 9 bytes

⊃⍒1○⍳10*⎕

-7 bytes from ngn and Adám.

Try it online!

APL (Dyalog Extended), 20 16 bytes

{i[⊃⍒1○i←⍳10*⍵]}

-4 bytes from Bubbler.

Try it online!

Implements Dingus's algorithm.

Explanation

{i[⊃⍒1○i←⍳10*⍵]}
{              } function body
 i     i←⍳10*⍵   assign to i the range of 1 to 10^n
     1○          find the sine of each value in i
     ⊃⍒          Grade(sort) by descending value, select index of first(maximum) value
 i[           ]  return k in i where sin k is maximum

Answer 9

Python 3, 51 bytes

import math
lambda n:max(range(10**n),key=math.sin)

Try it online!

Uses Dingus's observation about maximizing sine.

Answer 10

Fortran (GFortran), ⁵³ 51 bytes

read*,n
print*,maxloc([(sin(1d0*k),k=1,10**n)])
end

Try it online!

Port of my own Ruby answer. Because why not?