Adaptiert von diesem FiveThirtyEight-Rätsel .

Hintergrund

Untersuche die folgende unendliche Folge:

3 3 3 2 3 3 3 2 3 3 3 2 3 3 2 3 3 3 2 ...

Angenommen, die Sequenz ist 1-indiziert. Die ith-Zahl in der Sequenz bestimmt, wie viele 3s vor dem ith 2und nach vorherigen 2s vorhanden sind. Da die Sequenz mit a beginnt 3, muss die Sequenz beginnen, 3 3 3 2und da 3am Anfang der Sequenz drei s stehen, 3 3 3 2muss sich die Teilsequenz dreimal wiederholen. Danach erreichen Sie, 3 3 2weil die vierte Nummer in der Sequenz ist 2.

Das FiveThirtyEight-Rätsel fragt nach der Begrenzung des Verhältnisses von Dreien zu Zweien (was ich hier nicht verderben werde), aber Sie können auch fragen, wie hoch das kumulative Verhältnis nach dem Index ist i. Zum Beispiel ist das Verhältnis bei i=4heißt 3/1 = 3und i=15es ist 11/4 = 2.75.

Lassen Sie uns allgemein werden

Gegeben Zahlen nund kwir können eine ähnliche Sequenz machen , die mit beginnt nund genau wie die ursprüngliche Reihenfolge der Anzahl an Index beschrieben ibestimmt , wie viele ns zeigen sich vor dem ith kund nach alle früheren ks.

Beispiele:

n=2, k=5 gibt die Reihenfolge an 2 2 5 2 2 5 2 2 2 2 2 5 2 2 5 ...

n=3, k=0 gibt 3 3 3 0 3 3 3 0 3 3 3 0 0 3 3 3 0 ...

n=1, k=3 gibt 1 3 1 1 1 3 1 3 1 3 1 3 1 1 1 3 1 ...

Die Herausforderung

Schreiben Sie eine Funktion / ein Programm und machen Sie damit folgendes. Als Eingabe nehmen:

• eine positive ganze Zahl n
• eine nichtnegative ganze Zahl k ≠ n
• eine positive ganze Zahl i > n

Die ersten beiden Eingaben nund kbestimmen eine Sequenz wie oben beschrieben und isind ein Index. In den Beispielen verwende ich die 1-Indizierung, aber Sie haben die Freiheit, die 0- oder 1-Indizierung zu verwenden. Wenn 0-indiziert dann die Beschränkung iheißt i ≥ n.

Mit den drei Zahlen wird das Verhältnis von ns zu ks in der Reihenfolge bis einschließlich der Zahl am Index ausgegeben i. Das Ausgabeformat kann entweder ein Dezimalwert mit mindestens 5 Stellen Genauigkeit oder ein exakter Wert als Verhältnis wie 3524/837oder sein 3524:837.

In Dezimalform kann die letzte Ziffer beliebig gerundet werden. Nachgestellte Nullen und Leerzeichen sind zulässig.

In jeder der Zeichenkettenformen müssen die beiden Zahlen normalisiert werden, damit sie Koprime sind. Zum Beispiel, wenn das Verhältnis 22/4 war 11/2und 11:2akzeptabel ist, aber 22/4nicht.

Beispiele

n   k   i      output
2   4   15     2.75     or   11/4
6   0   666    5.1101   or   557:109
50  89  64     63       or   63:1
3   2   1000   2.7453   or   733/267
9   12  345    9.4545   or   104/11

Dies ist Codegolf pro Sprache, so dass der kürzeste Code in jeder Sprache der Gewinner ist.

Schale , 16 Bytes

¤/#ωȯ↑⁰J¹`C∞²N¹²

Probieren Sie es online!

Nimmt Eingaben in der gleichen Reihenfolge wie die Testfälle vor. Gibt eine rationale Zahl aus. Ich habe das Gefühl, dass es zu viele hochgestellte Texte gibt, aber ich weiß nicht, wie ich sie loswerden soll ...

Erläuterung

¤/#ωȯ↑⁰J¹`C∞²N¹²  Inputs are n, k, i.
             N    Starting with the natural numbers [1,2,3..
   ωȯ             do this until a fixed point is reached:
                    Argument is a list s.
           ∞²       Take the infinite list [n,n,n..
         `C         and split it to the lengths in s.
       J¹           Join the resulting blocks with k.
     ↑⁰             Take the first i elements.
                  Call the result x.
¤             ¹²  For each of n and k,
  #               count their number of occurrences in x
 /                and perform exact division on the results.

Python 3 , 94 92 89 87 Bytes

def g(n,k,i):o,t=[n],0;exec('o+=[n]*o[t]+[k];t+=1;'*i);return-1-i/(o[1:i+1].count(n)-i)

Probieren Sie es online!

Credits

• Reduziert von 94 auf 92 Bytes: Colera Su .
• Reduziert von 92 auf 89 Bytes: Dylnan .
• Reduziert von 89 auf 87 Bytes: ovs .

Jelly , 22 Bytes

³ẋЀ;€⁴Ẏḣ⁵
ẋ`;ÇÐLLƙ`÷/

Probieren Sie es online!

Volles Programm. Nimmt Argumente n, k, i.

Es gibt einen Fehler, der dazu führt, dass dies um 1 Byte unnötig länger sein muss.

Jelly ,  25  16 Bytes

-9 Bytes ~ 50% entfallen auf Erik den Jelly Antwort des Outgolfer (1. den neuen-ish Schlüssel schnell mit ƙsogar mit einem Fehler in dem Interpreter zur Zeit ein Byte Kalkulation, 2. mit einer kartiert Wiederholung zu vermeiden Zählen und Indizierung in die aktuelle Sequenz .) Geh und gib ihm etwas Ehre!

³ẋЀj⁴ṁ⁵µÐLLƙ`÷/

Ein volles Programm nimmt drei Argumente: n, k, idas druckt das Ergebnis aus .

Probieren Sie es online!

Wie?

³ẋЀj⁴ṁ⁵µÐLLƙ`÷/ - Main link
        µ        - monadic chain separation
         ÐL      - apply the monadic chain to the left repeatedly until no change occurs:
³                -   program's 1st argument, n
  Ѐ             -   map across the current sequence (initially just n)
 ẋ               -     repeat (the first run give triangle of n i.e. [[n],[n,n],...,[n]*n]
     ⁴           -     program's 2nd argument, k
    j            -     join
       ⁵         -     program's 3rd argument, i
      ṁ          -     mould like (repeat the list to fill, or cut it, to length i)
            ƙ    - keyed application, map over groups of identical items:
             `   - (this has an arity of 2, make it monadic by repeating the argument)
           L     -   length -> [numberOfNs, numberOfKs]
               / - reduce with:
              ÷  -   division -> [numberOfNs / numberOfKs]
                 - implicit print (a single item list just prints its content)

Beispiel Lauf mit Eingängen n=2, k=3, i=30:

Start the "loop until no change", ÐL
Note: Initial left argument, n=2, implicitly range-ified by Ѐ to become [1,2]
1. mapped repeat of n: [[2],[2,2]]
          join with k: [2,3,2,2]
         mould like i: [2,3,2,2,2,3,2,2,2,3,2,2,2,3,2,2,2,3,2,2,2,3,2,2,2,3,2,2,2,3]

2. mapped repeat of n: [[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2]]
          join with k: [2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2]
         mould like i: [2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2]
                          ^different to previous result

3. mapped repeat of n: [[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2]]
          join with k: [2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2]
         mould like i: [2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2]
                                  ^different to previous result

4. mapped repeat of n: [[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2]]
          join with k: [2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2]
         mould like i: [2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2]
                                                      ^different to previous result

5. mapped repeat of n: [[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2]]
          join with k: [2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2]
         mould like i: [2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2]
                       all the same as the previous result; stop loop and yield this.

length applied to equal elements: [length([2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]), length([3,3,3,3,3,3,3,3,3])]
                                = [21,9]
reduce by division              = [21/9] = [2.3333333333333335]
implicit print                  2.3333333333333335

Mathematica, 85 Bytes

(s={#};Do[s=Join[s,#~Table~s[[t]],{#2}],{t,#3}];Last@@Ratios@Tally@s[[#+3;;#3+#+2]])&

Probieren Sie es online!

APL (Dyalog Unicode) , 126 70 Byte

k n i←⎕
j←⍴v←⍬
:While j<i
v,←k,⍨n⍴⍨{v≢⍬:j⊃v⋄n}j+←1
:End
÷/+/¨n k⍷¨⊂j⍴v

Probieren Sie es online!

Vielen Dank an @ Adám für das Auslöschen von 56 Bytes aus dieser Antwort.

Dies ist ein argumentlose Tradfn ( einf itional f unctio n ) wobei 1 Eingang, der eine 3 - Element - Liste ist.

⎕PP←5wird nicht zur Byteanzahl hinzugefügt, da hiermit nur die P rint P- Wiederholung auf 5 Stellen begrenzt wird.

∇fund ∇werden nicht zur Byteanzahl hinzugefügt, da sie nicht Teil des Codes sind, sondern nur Begrenzer für die Tradfn.

Wie es funktioniert:

k n i←⎕                   ⍝ Take input (←⎕) for k, n and i.
j←⍴v←⍬                    ⍝ Assign (←) an empty vector (⍬) to v, then assign its shape (⍴, which is 0) to j.
:While j<i                ⍝ while j<i, do:
v,←k,⍨n⍴⍨{v≢⍬:j⊃v⋄n}j+←1 ⍝ this:
                     j+←1 ⍝ increment j (+←1)
          {v≢⍬:     }     ⍝ if (:) v does not match (≢) ⍬
               j⊃v        ⍝ return the jth element of v (v[j])
                  ⋄n      ⍝ else (⋄) return n
      n⍴⍨                 ⍝ shape (⍴) n as the result (repeats n result times)
   k,⍨                    ⍝ append (,⍨) k
v,←                       ⍝ append to (,←) v
:End                      ⍝ End while loop
÷/+/¨n k⍷¨⊂j⍴v            ⍝ then:
           j⍴v            ⍝ shape (⍴) v as j (truncates v to j elements)
          ⊂               ⍝ enclose the resulting vector
         ¨                ⍝ for each element
        ⍷                 ⍝ find (returns a boolean vector)
     n k                  ⍝ n and k (⍷ will return a boolean vector for each)
  +/¨                     ⍝ cumulative sum of each vector (returns the number of times n and k appear in v)
÷/                        ⍝ divide them and implicitly return the result.

R 88 Bytes

function(n,k,i){s=rep(n,n);for(j in 1:i){s=c(s,k,rep(n,s[j]))};z=sum(s[1:i]==n);z/(i-z)}

Probieren Sie es online!

Schnell , 152 Bytes

func f(n:Int,k:Int,i:Int){var a=[0];(1...i).map{a+=(0..<(a.count>$0 ?a[$0]:n)).map{_ in n}+[k]};let m=a[1...i].filter{n==$0}.count;print("\(m)/\(i-m)")}

Wird es kürzer als Java sein?

Erläuterung

func f(n:Int,k:Int,i:Int){
  var a=[0]                                    // Initialize the array (the zero is to
                                               //  define the type of the array and will be
                                               //  ignored by the code)
  (1...i).map{                                 // Repeat i times (more than enough):
    a+=(0..<(a.count>$0 ?a[$0]:n)).map{_ in n} //  Add the right amount of n:s to the array
      +[k]                                     //  Add k to the array
  }                                            // End repeat
  let m=a[1...i].filter{n==$0}.count           // Count the amount of n:s in the first
                                               //  i elements of the array
  print("\(m)/\(i-m)")                         // Print the result
}

Ruby , 77 71 70 Bytes

->n,k,i{r=[n]
i.times{|c|r+=[n]*r[c]+[k]}
1r*(j=r[1,i].count n)/(i-j)}

Probieren Sie es online!

Gibt ein Rational zurück, das sowohl als Zahl als auch als String auf den exakten reduzierten Bruch arbeitet.

Pyth , 24 Bytes

AEtcH/e.u<sm+*d]QGNH]Q)G

Testsuite.

Fixpunkt [n]unter bestimmter Funktion des Arrays.

Zephyr , 284 Bytes

input n as Integer
input k as Integer
input m as Integer
set s to Array(m)
for i from 1 to n
set s[i]to n
next
set s[i]to k
set N to n
set K to 1
for a from 2 to m
for b from 1 to s[a]
inc i
if i<=m
set s[i]to n
inc N
end if
next
inc i
if i<=m
set s[i]to k
inc K
end if
next
print N/K

Nimmt die drei Zahlen von stdin in drei separaten Zeilen. Gibt ein genaues Verhältnis wie 104/11oder aus 63.

Ungolfed

input n as Integer
input k as Integer
input maxIndex as Integer

set sequence to Array(maxIndex)
for i from 1 to n
    set sequence[i] to n
next
set sequence[i] to k

set nCount to n
set kCount to 1

for a from 2 to maxIndex
    for b from 1 to sequence[a]
        inc i
        if i <= maxIndex
            set sequence[i] to n
            inc nCount
        end if
    next
    inc i
    if i <= maxIndex
        set sequence[i] to k
        inc kCount
    end if
next

print nCount / kCount