이 FiveThirtyEight 수수께끼 에서 적응 .

배경

다음의 무한 시퀀스를 검사하십시오.

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

시퀀스가 1 인덱싱되었다고 가정 해 봅시다. i시퀀스 의 th 숫자 3는 ith 2이전과 이후의 수를 결정합니다 2. 따라서 시퀀스가 ​​시퀀스로 시작하기 3때문에 시퀀스가 ​​시작되어야하고 시퀀스 의 시작 부분에 3 3 3 2세 개의 3s가 있으므로 서브 시퀀스는 3 3 3 2자체적으로 세 번 반복되어야합니다. 그 후 3 3 2시퀀스의 네 번째 숫자는2 입니다.

FiveThirtyEight 수수께끼는 3 대 2의 비율 제한을 요구하지만 (여기서는 망치지 않을 것입니다) index 이후 누적 비율이 무엇인지 물어볼 수도 있습니다 i. 예를 들어의 비율 i=4IS 3/1 = 3와의 i=15그것의 11/4 = 2.75.

종합하자

숫자 감안할 n와 k우리와 함께 시작하는 유사한 시퀀스를 만들 수 있습니다 n그냥 원래 순서와 같은 인덱스의 수를 설명 i얼마나 많은 결정 n전과 표시의 i일 k및 이전을 다음과k 들.

예 :

n=2, k=5 시퀀스를 제공합니다 2 2 5 2 2 5 2 2 2 2 2 5 2 2 5 ...

n=3, k=0 준다 3 3 3 0 3 3 3 0 3 3 3 0 0 3 3 3 0 ...

n=1, k=3 준다 1 3 1 1 1 3 1 3 1 3 1 3 1 1 1 3 1 ...

도전

기능 / 프로그램을 작성하고 다음을 수행하십시오. 입력으로 받아 :

• 양의 정수 n
• 음이 아닌 정수 k ≠ n
• 양의 정수 i > n

처음 두 입력 n및 k상기 한 바와 같은 순서를 결정 i하는 인덱스이다. 예제에서 1 인덱싱을 사용하고 있지만 0 또는 1 인덱싱을 자유롭게 사용할 수 있습니다. 인덱스가 0 인 경우 제한 i은i ≥ n .

세 개의 숫자 를 사용하면 인덱스의 숫자까지의 시퀀스에서 ns 대 ks 의 비율을 출력합니다 i. 출력의 포맷 중 적어도 5 개 정밀도 나 숫자와 같은 비율로 정확한 값을 십진수 값이 될 수 3524/837또는 3524:837.

10 진수 형식으로, 마지막 숫자는 원하는대로 반올림 할 수 있습니다. 후행 0과 공백이 허용됩니다.

두 문자열 중 하나에서 두 숫자는 코 프라임이되도록 정규화해야합니다. 예를 들어, 비 4분의 22이었다 경우 11/2와 11:2수락 가능하지만 22/4아니다.

예

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

이것은 언어 당 코드 골프이므로 각 언어에서 가장 짧은 코드가 승자입니다.

껍질 , 16 바이트

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

온라인으로 사용해보십시오!

테스트 사례와 동일한 순서로 입력을받습니다. 유리수를 출력합니다. 나는 이것이 위첨자가 너무 많다고 생각하지만 그것들을 제거하는 방법을 모른다 ...

설명

¤/#ωȯ↑⁰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.

파이썬 3 , 94 92 89 87 바이트

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)

온라인으로 사용해보십시오!

크레딧

• 94 바이트에서 92 바이트로 감소 : Colera Su 줄었습니다 .
• dylnan 에서 92 바이트에서 89 바이트로 줄었습니다 .
• ovs 89에서 87 바이트로 줄었습니다 .

젤리 , 22 바이트

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

온라인으로 사용해보십시오!

전체 프로그램. 인수를 취합니다 n.k ,i .

1 바이트 씩 불필요하게 길어야하는 버그가 있습니다.

젤리 ,  25  16 바이트

-9 바이트 ~ 50 % 기인하는 에릭 Outgolfer의 젤리 응답 (1. 빠른 새로운 틱 키를 사용하여 ƙ도 인터프리터에서 문제를 현재 바이트 원가 계산과, 2. 현재의 순서로 피하기 계산 및 인덱싱에 매핑 반복을 사용하여 .) 그에게 신용을 줘!

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

세 개의 인수를 복용 전체 프로그램은 : n, k, i결과를 출력한다.

온라인으로 사용해보십시오!

어떻게?

³ẋЀ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)

입력으로 실행하는 예 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

수학, 85 바이트

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

온라인으로 사용해보십시오!

APL (Dyalog Unicode) , 126 70 바이트

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

온라인으로 사용해보십시오!

이 답변에서 56 바이트를 제거 한 @ Adám에게 감사드립니다.

이것은 무항 Tradfn이다 ( 트라 itional F unctio N 3 요소 목록 1 개 입력을 가지고).

⎕PP←5그것만으로 제한하는 데 사용하기 때문에 바이트 카운트에 추가되지 P의 RINT을 P의 에 recision을 5 자리.

∇f그리고 ∇코드의 일부가 아니기 때문에 바이트 수에 추가되지 않으며 tradfn의 구분자 만 추가됩니다.

작동 방식 :

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 바이트

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)}

온라인으로 사용해보십시오!

스위프트 , 152 바이트

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)")}

Java보다 짧을까요?

설명

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
}

루비 , 77 71 70 바이트

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

온라인으로 사용해보십시오!

유리수를 반환합니다.이 숫자는 숫자로 작동하고 정확히 감소 된 부분으로 줄입니다.

Pyth , 24 바이트

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

테스트 스위트.

[n]배열의 특정 기능에서 고정 지점 .

제퍼 , 284 바이트

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

stdin에서 세 개의 숫자를 세 개의 개별 줄에서 가져옵니다. 정확한 비율 출력 등 104/11또는63 .

언 골프

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