당신의 작업은 integer를 취하는 프로그램을 만들고 단면 다이 n > 1의 롤을 출력하는 n것입니다. 그러나이 주사위는 주사위를 폭발 시키기위한 규칙을 따릅니다 .

주사위를 굴릴 때 어떤 값을 굴 렸는지 확인하십시오. 해당 종류의 다이에 대한 최대 값 (d6의 경우 4 또는 6 인 표준 d4 등)을 최대로 얻은 경우 다시 굴려서 새 롤을 해당 합계에 추가하십시오. 더 이상 최대 수를 구르지 않을 때까지 각 롤에 총계가 계속 추가됩니다. 최종 번호는 여전히 추가됩니다.

프로그램은 단일 정수를 취하고 n폭발 n성형 주사위를 굴려야합니다 . 여기에 어떻게 보이는지 보여주는 배포 예제가 n=4있습니다. 의 배수 n는 항상 분해되므로 절대로 배수를 출력해서는 안됩니다 .

재귀의 스택 크기가 무한하다고 가정 할 수 있으며 임의의 함수 는 임의성에 대한 표준 (내장 임의 생성기 또는 시간 / 날짜 )을 충족해야합니다 . 랜덤 함수는 우리가 말하는 주사위이기 때문에 기하 분포와 같은 가능한 한 균일해야합니다.

x86 머신 코드 (Intel Ivy Bridge 이상용), 17 바이트

31 C9 0F C7 F0 31 D2 F7 F6 42 01 D1 39 F2 74 F2 C3

위의 바이트 코드는 폭발 다이를 시뮬레이트하는 함수를 정의합니다. ESI레지스터에 전달 된 단일 입력을 사용 하여 최대 다이 수를 나타냅니다. ECX롤의 결과 인 레지스터에 단일 값을 반환합니다 .

내부적으로, 그것은 사용 지시 난수를 생성한다. Intel Ivy Bridge 프로세서 이상의 하드웨어에 내장 된 난수 생성기 (RNG)를 사용합니다 (일부 AMD CPU도이 명령을 지원합니다).RDRAND

함수의 논리는 그렇지 않으면 매우 간단합니다. 생성 된 난수는 표준 기술 ( (rand % dieSize) + 1)을 사용하여 원하는 범위 내에 놓 이도록 조정 된 다음 폭발이 발생하는지 확인합니다. 최종 결과는 누산기 레지스터에 유지됩니다.

다음은 어셈블리 언어 니모닉을 보여주는 주석이 달린 버전입니다.

           unsigned int RollExplodingDie(unsigned int dieSize)
31 C9        xor     ecx, ecx    ; zero-out ECX, which accumulates the final result
           Roll:
0F C7 F0     rdrand  eax         ; generate a random number in EAX
31 D2        xor     edx, edx    ; zero-out EDX (in preparation for unsigned division)
F7 F6        div     esi         ; divide EDX:EAX by ESI (the die size)
                                 ;   EAX receives the quotient; EDX receives the remainder
42           inc     edx         ; increment the remainder
01 D1        add     ecx, edx    ; add this roll result to the accumulator
39 F2        cmp     edx, esi    ; see if this roll result should cause an explosion
74 F2        jz      Roll        ; if so, re-roll; otherwise, fall through
C3           ret                 ; return, with result in ECX register

나는 약간의 바람을 피우고 있다 . 모든 표준 x86 호출 규칙은 EAX레지스터 의 함수 결과를 반환합니다 . 그러나 실제 머신 코드에는 호출 규칙이 없습니다. 입 / 출력에 원하는 레지스터를 사용할 수 있습니다. ECX출력 레지스터를 사용하면 1 바이트가 절약되었습니다. 을 사용하려면 명령어 바로 앞에 EAX1 바이트 XCHG eax, ecx명령어를 삽입하십시오 ret. 그러면 EAX및 ECX레지스터 의 값이 바뀌어에 결과가 ECX에 효과적으로 복사 되고의 이전 값으로 EAX휴지통이 비워 ECX집니다 EAX.

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

다음 은 명령어 를 생성하기 위해 GCC, Clang 및 ICC에서 지원 하는 __builtin_ia32_rdrand32_step내장 함수를 사용하여 C로 작성된 동등한 함수입니다 RDRAND.

#include <immintrin.h>

unsigned int RollExplodingDie(unsigned int dieSize)
{
    unsigned int result = 0;
Roll:
    unsigned int roll;
    __builtin_ia32_rdrand32_step(&roll);
    roll    = ((roll % dieSize) + 1);
    result += roll;
    if (roll == dieSize)   goto Roll;
    return result;
}

흥미롭게도, 플래그 가있는 GCC는 -Os이를 거의 동일한 머신 코드로 변환합니다 . 그것은 EDI대신에 입력을 취하는데 ESI, 이것은 완전히 임의적이며 코드에 관한 내용은 전혀 변경하지 않습니다. EAX앞에서 언급했듯이 결과를으로 반환해야 하며보다 효율적인 (그러나 더 큰) MOV명령을 사용하여 RET. 그렇지 않으면 samezies. 프로세스가 완전히 뒤집을 수 있으면 항상 재미 있습니다. 어셈블리에서 코드를 작성하고 C로 복사하고 C 컴파일러를 통해 실행하고 원래 어셈블리를 다시 가져옵니다!

파이썬 2 , 66 64 61 바이트

xnor 덕분에 -3 바이트

f=lambda n,c=0:c%n or c+f(n,randint(1,n))
from random import*

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

이전 롤은에 저장되어 c있으므로 파이썬 람다에서는 수행 할 수없는 변수에 저장하지 않고도 여러 번 액세스 할 수 있습니다. 재귀마다, 우리는 폭발 주사위를 굴 렸는지 확인합니다.

c0으로 초기화되므로 c%n거짓입니다. 다음 반복에서는 폭발하는 주사위를 굴린 경우에만 거짓이됩니다.

파이썬 2 , 55 바이트

f=lambda n:randint(1,n)%n or n+f(n)
from random import*

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

내 다른 대답은 약간 과도하게 설계된 것 같습니다.

R , 39 바이트

n=scan();n*rgeom(1,1-1/n)+sample(n-1,1)

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

$n$$n$$\frac1n$$\mathrm{Geometric}\left(1-\frac{1}{n}\right)$$n$$\mathrm{Uniform}(1,2,\ldots,n-1)$

펄 6 , 26 바이트

{sum {roll 1..$_:}...*-$_}

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

설명

{                        } # Anonymous block
                  ...      # Sequence constructor
     {roll 1..$_:}         #   Next elem is random int between 1 and n
                           #   (Called as 0-ary function with the original
                           #   $_ for the 1st elem, then as 1-ary function
                           #   with $_ set to the previous elem which
                           #   equals n.)
                     *-$_  #   Until elem not equal to n (non-zero difference)
 sum                       # Sum all elements

J , 16 11 바이트

(+$:)^:=1+?

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

설명

TL; DR 1+? 은 다이 롤을 수행 (+$:)^:=하고 입력과 같을 때만 반복합니다.

이 함수는 4 동사의 기차입니다.

             ┌─ + 
         ┌───┴─ $:
  ┌─ ^: ─┴─ =     
  │               
──┤      ┌─ 1     
  └──────┼─ +     
         └─ ?     

기차는 두 개 이상의 동사가 연결될 때입니다. 대답은 다음과 같습니다 f g h j.

(+$:)^:=  1  +  ?
    f     g  h  j

소위 "4 트레인"은 후크와 포크로 구문 분석됩니다.

f g h j   ⇔   f (g h j)

따라서 답은 다음과 같습니다.

(+$:)^:= (1 + ?)

후크 : (f g) x및x (f g) y

인수가 주어지면 두 동사의 모나 딕 (1 인수) 후크 x는 다음과 같습니다.

(f g) x   ⇔   x f (g x)

예를 들어로 (* -) 5평가하면 5 * (- 5)로 평가됩니다 _25.

이는 4의 트레인 인 f및 의 후크 (g h j)가 다음에 해당함을 의미합니다.

(f (g h j)) x   ⇔   x f ((g h j) x)

그러나 f여기서 무엇을합니까? 전원 연결을 (+$:)^:=사용하는 두 개의 동사 : 다른 후크 ( )와 동사 ( )입니다. 여기에 참고 인 이항 - 그것은 두 개의 인수가 ( 하고 ). 그래서 우리는 어떻게 행동하는지 살펴 봐야합니다 . 전원 연결 은 동사 와 동사 또는 명사 (명사는 데이터의 일부 임)를 취하여 시간을 적용 합니다. 예를 들어 보자 . 다음과 같은 내용이 유지됩니다.^:(+$:)=fx(g h j) x^:f^:ofof oo = 3

(f^:3) x     ⇔   f (f (f x))
x (f^:3) y   ⇔   x f (x f (x f y))

경우 o동사는, 전원 연결은 단순히 평가합니다 o인수를 통해와 반복 횟수로 명사 결과를 사용합니다.

우리의 동사를 들어, o이다 =, 평등 동사. 0다른 인수와 1동일한 인수로 평가됩니다 . (+$:)동일한 인수에 대해서는 후크를 한 번 반복하고 다른 인수에 대해서는 후크를 반복 하지 않습니다. 설명을 쉽게하기 위해을 보자 y ⇔ ((g h j) x). 초기 후크는 다음과 같습니다.

x   (+$:)^:=   ((g h j) x)
x   (+$:)^:=   y

연결을 확장하면 다음과 같이됩니다.

x ((+$:)^:(x = y)) y

경우 x와 y동일하며,이된다 :

x (+$:)^:1 y   ⇔   x (+$:) y

그렇지 않으면 다음과 같이됩니다.

x (+$:)^:0 y   ⇔   y

이제 모나 딕 포크를 보았습니다. 여기, 우리는 2 단 포크를 가지고 있습니다 :

x (f g) y   ⇔   x f (g y)

따라서 언제 x와 y동일하면 다음을 얻습니다.

x (+$:) y   ⇔   x + ($: y)

무엇입니까 $:? 전체 동사 자체를 나타내며 재귀를 허용합니다. 이것은 언제 x그리고 y are the same, we apply the verb toy and addx` 라는 의미입니다 .

포크 : (g h j) x

이제, 내부 포크는 무엇을합니까? 이것은 y우리의 마지막 예였습니다. 세 가지 동사의 모나드 포크의 경우 인수가 주어지면 x다음과 같은 동등성이 유지됩니다.

(g h j) x   ⇔   (g x) h (j x)

이 다음에 예를 들어, 우리가 동사라는 이름의 한 가정 SUM, DIVIDE그리고 LENGTH당신은 그들이 수도 무엇을 생각 않는. 세 가지를 포크로 연결하면 다음과 같은 결과를 얻습니다.

(SUM DIVIDE LENGTH) x   ⇔   (SUM x) DIVIDE (LENGTH x)

이 포크는 평균으로 평가됩니다 x( x수치 라고 가정 ). J에서는 실제로 이것을 예제로 작성 +/ % #합니다.

포크에 관한 마지막 것. 가장 왼쪽의 "tine"(위의 상징적 인 경우 g)이 명사 인 경우 해당 값을 반환하는 상수 함수로 처리됩니다.

이 모든 것을 갖추면 위의 포크를 이해할 수 있습니다.

(1 + ?) x   ⇔   (1 x) + (? x)
            ⇔   1 + (? x)

?$[0,x)$$[1, x]$

함께 모아서

이 모든 것을 감안할 때 동사는 다음과 같습니다.

((+$:)^:=1+?) x   ⇔   ((+$:)^:= 1 + ?) x
                  ⇔   ((+$:)^:= (1 + ?)) x
                  ⇔   x ((+$:)^:=) (1 + ?) x
                  ⇔   x ((+$:)^:=) (1 + (? x))
                  ⇔   x (+$:)^:(x = (1 + (? x))
(let y = 1 + (? x))
if x = y          ⇒   x + $: y
otherwise         ⇒   y

이것은 원하는 기능을 나타냅니다.

젤리 , 7 바이트

X+ß}¥=¡

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

재귀를 사용합니다. 프로그램을 다시 실행하고 ( ) 난수 ( )가 프로그램 입력 과 같으면 ( ) ß추가합니다 ( +) . 브랜드는 프로그램 입력 및 행동 을 결합 하는 단일 링크로 소비한다.¡X=}ߥ+ß}¡

여기 에이 프로그램을 사용하여 수집 한 n = 6의 1000 출력 분포가 있습니다. python / matplotlib로 플로팅되었습니다.

다음은 (대략?) 지수 분포를 보여주는 세미 로그 플롯의 n = 3에서 5000 개의 데이터 포인트입니다.

Pyth- 12 11 바이트

기능적으로 사용합니다. 분포를 시뮬레이트하는 더 똑똑한 대답이 있어야한다고 생각합니다.

-.W!%HQ+hOQ

-         (Q)         Subtract Q. This is because we start Z at Q to save a char
 .W                   While, functionally
  !                   Logical not. In this case, it checks for 0
   %HQ                Current val mod input
  +     (Z)           Add to current val
   h                  Plus 1
    OQ                Random val in [0, input)

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

파이썬 3 , 80 바이트

import random as r,math
lambda n:int(-math.log(r.random(),n))*n+r.randint(1,n-1)

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

05AB1E , 10 바이트

[ILΩDIÊ#}O

온라인으로 시도 하거나 목록을 확인하십시오 .

10 바이트 대안 :

[LΩDˆÊ#}¯O

온라인으로 시도 하거나 목록을 확인하십시오 .

나는 그것이 '단어' DIÊ를 가지고 있기 때문에 상위 1 개를 더 좋아하지만 도전에 적합합니다.

설명:

[         # Start an infinite loop:
 IL       #  Create a list in the range [1, input]
   Ω      #  Pop and push a random value from this list
    D     #  Duplicate it
     IÊ   #  If it's NOT equal to the input:
       #  #   Stop the infinite loop
}O        # After the loop: sum all values on the stack
          # (which is output implicitly as result)

[         # Start an infinite loop
 L        #  Create a list in the range [1, (implicit) input]
  Ω       #  Pop and push a random value from this list
   Dˆ     #  Add a copy to the global_array
     Ê    #  If it's NOT equal to the (implicit) input:
      #   #   Stop the infinite loop
}¯        # After the loop: push the global_array
  O       # Pop and push its sum
          # (which is output implicitly as result)  

Wolfram Language (Mathematica) , 50 바이트

R@#//.x_/;x~Mod~#==0:>x+R@#&
R=RandomChoice@*Range

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

R , 47 42 바이트

function(n){while(!F%%n)F=F+sample(n,1)
F}

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

ArBo의 접근 방식에 대한 크레딧 .

아직도 Robin Ryder 's 보다 1 바이트 더 길다 .

루비 , 35 바이트

->n,s=0{s+=x=1+rand(n);x<n||redo;s}

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

APL (Dyalog Unicode) , 15 14 바이트

{×r←?⍵:r⋄⍵+∇⍵}

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

하스켈 , 77 76 바이트

import System.Random
f x=randomRIO(1,x)>>=(x!)
x!y|y<x=pure y|0<1=(y+)<$>f x

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

1 바이트에 대한 killmous 덕분입니다.

경우 <|>전주곡에 있었다, 우리는 더 잘 할 수있는 MonadComprehensions:

Haskell , 비경쟁, 66 바이트

import System.Random
f x=do y<-randomRIO(1,x);[y|y<x]<|>(y+)<$>f x

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

파이썬 2 , 53 바이트

f=lambda n:random()*n//1or n+f(n)
from random import*

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

ArBo 's answer의or 단락 아이디어를 사용합니다 . 이 표현식 은에서 롤을 대신 하여 에서 까지 의 숫자를 생성합니다 . 는 제로 (Falsey을)의 경우이에게 계속 제외하고는 그 번호를합니다 .random()*n//10n-10norn+f(n)

Japt , 13 바이트

ö)g@¶°X?X+ß:X

시도 해봐

포트 Arnauld의 대답 . 재귀 호출하는 방법을 알아 냈습니다.)

번역 된 JS :

// U: Implicit input
// ö: generate a random number [0,U)
(U.ö())
  // g: run the result through a function
  .g(function(X, Y, Z) {
    // increment the result and compare to input
    return U === (++X)
      // if they are the same, roll again and add to current roll
      ? (X + rp())
      // if they are different, use current roll
      : X
   })

Japt , 12 바이트

다나의 솔루션보다 짧을 수는 있지만 훨씬 추악합니다. 빈 줄로 시작하는 Japt 솔루션을 가지고 있기 때문에 영원히 보이는 것처럼 보이기 때문에 게시하고 있습니다.

ö
>°V©VªV+ß

시도 해봐

PowerShell , 49 바이트

for($a=$l="$args";$a-eq$l){$o+=$l=1..$a|Random}$o

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

반복적 인 방법. 입력 과 ast 롤 $args을 설정합니다 (최소한 한 번 루프에 들어가도록 완료). 그런 다음 마지막 롤이 입력과 일치하는 한 계속 롤링합니다. 루프 내에서 우리 는 마지막 롤에 누적되며 , 이는 롤 부터 입력 까지 범위를 생성 하고 요소를 선택하여 업데이트됩니다 . (정직하게, 나는 그것이 작동 하는 것에 약간 놀랐습니다 .) 일단 우리가 루프를 벗어나 면 파이프 라인 을 떠나고 출력은 암시 적입니다.$a$l-eq$o1$aRandom$o+=$l=$o

4 번째 (2 번째) , 72 바이트

include random.fs
: f >r 0 begin i random 1+ >r i + r> i < until rdrop ;

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

코드 설명

include random.fs      \ include library file for random
: f                    \ start a new word definition
  >r                   \ stick the input on the return stack (for easy access)
  0                    \ add a counter to hold the sum
  begin                \ start an indefinite loop
    i random 1+        \ generate a random number from 1 to n
    >r i + r>          \ add the result to the counter, use the return stack to save a few bytes
    i <                \ check if result was less than n
  until                \ end the loop if it was, otherwise go back to begin
  rdrop                \ remove n from the return stack
;                      \ end the word definition

배치, 70 바이트

@set t=0
:g
@set/at+=d=%random%%%%1+1
@if %d%==%1 goto g
@echo %t%

입력 n을 명령 행 매개 변수로 사용 %1합니다. d현재 롤, t누적 합계입니다. d같지 않을 때까지 계속 굴 n립니다.

젤리 , 9 바이트

x⁹X€Ä%ƇµḢ

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

$2^{256}$

이 제한이없는 대안은 다음과 같습니다.

젤리 , 10 바이트

X³X¤+¥³ḍ¥¿

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

두 TIO 링크는 400 개의 숫자를 생성하여 분포를 보여줍니다.

파이썬 3 , 81 72 바이트

from random import*
def f(x,a=0):
 while a%x<1:a+=randint(1,x)
 return a

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

ArBo 덕분에 -9 바이트

설명

import random             #load the random module              
def explodeDice(num):     #main function
    ans = 0                     #set answer to 0
    while a % num != 0:         #while a isn't a multiple of the input
        ans += random.randint(1, num) #add the next dice roll to answer
    return ans                  #return the answer

TI-BASIC, 28 23 바이트

이 메타 포스트 덕분에 -5 바이트 !

Ans→N:0:Repeat fPart(Ans/N:Ans+randInt(1,N:End:Ans

입력이입니다 Ans.
출력이 시작 Ans되고 내재적으로 인쇄됩니다.

예 :

4
              4
prgmCDGF11
              5
6
              6
prgmCDGF11
              3

설명:

Ans→N:0:Repeat fPart(Ans/N:Ans+randInt(1,N:End:Ans   ;full logic

Ans→N                                                ;store the input in "N"
      0                                              ;leave 0 in "Ans"
        Repeat fPart(Ans/N                 End       ;loop until the sum
                                                     ; is not a multiple of
                                                     ; the input
                               randInt(1,N           ;generate a random
                                                     ; integer in [1,N]
                           Ans+                      ;then add it to "Ans"
                                               Ans   ;leave the sum in "Ans"
                                                     ;implicitly print "Ans"

노트:

• TI-BASIC은 토큰 화 된 언어입니다. 문자 수는 바이트 수와 같지 않습니다 .

SmileBASIC 3, 49 바이트

이 기능 D N OUT R은 폭발 주사위 롤을 재귀 적으로 구현합니다.

DEF D N OUT R
R=RND(N)+1IF R==N THEN R=R+D(N)
END

언 골프

DEF D N OUT R  'N is sides and R is output param (shorter than using RETURN in this case)
 R=RND(N)+1  'random number in [1, N]
 IF R==N THEN R=R+D(N)  'if roll is same as N then roll again and add
END

SmileBASIC에서 함수는 여러 개의 반환 값을 가질 수 있습니다. 함수는 하나 개의 반환 값이있는 경우 fun in OUT var와 var = fun(in)우리가 기능을 정의 할 수 있습니다 이유입니다 정확히 동일한 OUT형태와도 함수 본문 자체가 표현식에서 호출합니다. 함수 본문에 DEF D(N)명시 적으로 명시 해야하는 것처럼 함수를 정의한 경우 RETURN R; 두 구문을 혼합하면 바이트가 절약되었습니다.

PowerShell , 43 바이트 (반복 방법)

param($n)do{$x+=1..$n|random}until($x%$n)$x

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

PowerShell , 48 바이트 (재귀 방법)

filter f{if($_-eq($x=1..$_|random)){$x+=$_|f}$x}

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

젤리 , 7 바이트

X=п⁸S_

정수를 받아들이는 monadic Link는 정수 n를 산출합니다.

온라인으로 사용해보십시오! 또는 횟수를 봅니다 .$10^5$

방법?

X=п⁸S_ - Link: integer, n
  п    - Collect up while...
 =  ⁸   - ...condition: equal to chain's left argument, n
X       - ...next value: random number in [1..n]
     S  - sum
      _ - subtract n (since the collection starts with [n])

SmileBASIC, 41 바이트

INPUT N@L
S=S+RND(N)+1ON S MOD N GOTO@L?S

읽고 나서:

항상 폭발하므로 n의 배수는 절대로 출력하지 않아야합니다.

주사위 롤이 있는지 확인하는 대신 n합계가 배수 인 동안 반복 할 수 있다는 것을 깨달았습니다 n.

AnyDice , 36 바이트

언어에 거의 내장되어 있습니다 :

function:f I:n{result: [explode dI]}

이것이 정확하기 위해서는 무한 재귀 깊이 가정을 남용해야합니다. AnyDice는 전역 속성 최대 함수 깊이로 재귀 깊이를 제한합니다. 내장 폭발은 자체를 사용합니다. 분해 깊이-기본값은 2입니다.

set "explode depth" to 99

다른 25 바이트를 추가합니다. 이론적으로 주사위가 99 번 이상 폭발 할 수 있기 때문에 요구 사항과 실제로 일치하지 않습니다.

함수의 출력은 다이입니다. 결과에 대한 결과와 확률을 분석하는 AnyDice 내장 유형.

CJam , 19 바이트

qi{__mr)_T+:T;=}g;T

설명:

T is pre-set to 0

qi{__mr)_T+:T;=}g;T - whole code
qi                  - read input as integer (n) | Stack: n
  {            }    - block
   __               - Duplicate twice | Stack: n n n
     mr)            - Choose a random number from 1 to n (r). Since 'mr' picks a
                      number from 0 to n-1, the number has to be incremented with ')' 
                      Stack: n n r
        _           - Duplicate |  Stack: n n r r
         T          - push T | Stack: n n r r T
          +         - add the random number to T (t) | Stack: n n r t
           :T;      - pop the value and store in T | Stack: n n r
              =     - are the top two stack values the same (c) | Stack: n c
               }
                g   - do while loop that pops the condition from the stack after each
                      iteration | Stack: n
                 ;  - pop the top stack element and discard | Stack: T
                  T - push T | Stack: T
                    - implicit output

또는 의사 코드에서 :

input n
var sum = 0
do {
    var random_number = pick random number from 1 to n
    sum = sum + random_number
} while (random_number == n)
output n

순서도로서 :

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

Excel VBA, 46 바이트

@TaylorScott 감사합니다

Do:v=-Int(-[A1]*Rnd):t=t+v:Loop While[A1]=v:?t

명령 창에서 실행됩니다.

사용자 정의 함수로.

Excel VBA, 108 67 바이트

Function z(i)
Do
v=Int((i*Rnd)+1)
z=z+v
Loop While v=i
End Function