당신의 도전은 주어진 범위에서 가장 부드러운 숫자를 찾는 것입니다. 즉, 가장 큰 소인수가 가장 작은 수를 찾으십시오.

부드러운 수는 그의 가장 큰 소인수 작은 하나입니다. 이 유형의 숫자는 고속 푸리에 변환 알고리즘, 암호화 분석 및 기타 응용 프로그램에 유용합니다.

예를 들어, 5, 6, 7, 8, 9, 108의 최대 소수는 2 인 반면 다른 모든 숫자의 소수는 3 이상이므로 범위 에서 8은 가장 부드러운 수입니다.

입력 : 입력은 범위를 정의하는 양의 정수입니다. 범위에서 허용되는 최소 정수는 2입니다. 언어의 범위 내에서 임의의 범위를 지정할 수있는 한 범위가 포함, 배타, 반 배타 등인지 선택할 수 있습니다. 함수 입력, stdin, 명령 행 인수 또는 해당 언어의 동등한 방법을 통해 숫자를 사용할 수 있습니다. 입력에 인코딩 추가 정보가 없습니다.

출력 : 입력 범위에서 최대 평활 (최소 최대 계수) 인 하나 이상의 정수를 반환, 인쇄 또는 동등하게합니다. 여러 결과를 반환하는 것은 선택 사항이지만 그렇게하려면 결과를 명확하게 구분해야합니다. 기본 출력 형식은 여러 결과에 적합합니다.

답변을 입력하고 출력하는 방법을 답하십시오.

득점 : 코드 골프. ASCII로 작성된 경우 문자로, ASCII가 아닌 경우 8 * bytes / 7로 계산하십시오.

테스트 사례 :

참고 : 이들은 하이 엔드가 아닌 로우 엔드를 포함하여 Python 스타일 범위입니다. 프로그램에 맞게 변경하십시오. 하나의 결과 만 필요합니다.

smooth_range(5,11)
8
smooth_range(9,16)
9, 12
smooth_range(9,17)
16
smooth_range(157, 249)
162, 192, 216, 243
smooth_range(2001, 2014)
2002

CJam-13

q~,>{mfW=}$0=

http://cjam.aditsu.net/ 에서 시도 하십시오

입력 예 : 2001 2014
출력 예 :2002

설명:

q~입력을 읽고 평가하여 스택에서 2 개의 숫자 (예 : 최소값 및 최대 값)
,를 누르면 배열 [0 1 ... max-1]
>에서 배열이 최소값에서 시작하여 [min ... max-1]이됩니다.
{…}$블록을 사용하여 배열을 정렬하여 정렬 키를 계산하면
mf배열
W=의 마지막 요소 (W = -1)를 얻기 위해 숫자의 모든 소인수를 가진 배열을 가져옵니다. 정렬 키
0=는 (정렬 된) 배열의 첫 번째 요소를 가져옵니다

정규식 ( .NET PCRE 풍미), 183129 바이트

집에서 이것을 시도하지 마십시오!

이것은 실제로 승리의 경쟁자가 아닙니다. 그러나 Eric Tressler는이 문제를 정규 표현식으로 해결할 것을 제안했으며 나는 그것을 포기하는 것을 저항 할 수 없었습니다. 이것은 PCRE에서도 가능할 수도 있지만 (더 짧게는 아래 참조) 솔루션에 임의 길이의 숨김이 필요하기 때문에 .NET을 선택했습니다. 여기 우리는 간다 :

(?<=^(1+),.*)(?=\1)(?=((11+)(?=.*(?=\3$)(?!(11+?)\4+$))(?=\3+$)|(?!(11+)\5+$)1+))(?!.+(?=\1)(?:(?!\2)|(?=((11+)(?=.*(?=\7$)(?!(11+?)\8+$))(?=\7+$)|(?!(11+)\9+$)1+)).*(?=\2$)(?=\6)))1+

입력은 쉼표로 구분 된 범위로 인코딩되며 두 숫자는 모두 1s를 사용하여 단항 표기법으로 표시됩니다 . 일치 하는 범위는 S1에서 S가장 부드러운 숫자입니다. 동점은 가장 작은 숫자를 위해 끊어집니다.

따라서 질문의 두 번째 예는 다음 문자열입니다 (일치하는 밑줄).

111111111,1111111111111111
                 =========

그것은 (지금까지는 잘 알려진) 프라임 검사 정규 표현식을 기반으로하며 그 변형은 무려 6 번 포함됩니다.

다음은 무슨 일이 일어나고 있는지 알고 싶은 사람들을 위해 무료 간격과 주석을 사용하는 버전입니다.

# Note that the beginning of the match we're looking for is somewhere
# in the second part of the input.
(?<=^(1+),.*)          # Pick up the minimum range MIN in group 1
(?=\1)                 # Make sure there are at least MIN 1s ahead

                       # Now there will be N 1s ahead of the cursor
                       # where MIN <= N <= MAX.


(?=(                   # Find the largest prime factor of this number
                       # store it in group 2.
  (11+)                # Capture a potential prime factor P in group 3
  (?=                  # Check that it's prime
    .*(?=\3$)          # Move to a position where there are exactly 
                       # P 1s ahead
    (?!(11+?)\4+$)     # Check that the remaining 1s are not composite
  )
  (?=\3+$)             # Now check that P is a divisor of N.
|                      # This does not work for prime N, so we need a 
                       # separate check
  (?!(11+)\5+$)        # Make sure that N is prime.
  1+                   # Match N
))

(?!                    # Now we need to make sure that here is not 
                       # another (smaller) number M with a smaller 
                       # largest prime factor

  .+                   # Backtrack through all remaining positions
  (?=\1)               # Make sure there are still MIN 1s ahead

  (?:
    (?!\2)             # If M is itself less than P we fail 
                       # unconditionally.
  |                    # Else we compare the largest prime factors.
    (?=(               # This is the same as above, but it puts the
                       # prime factor Q in group 6.
      (11+)
      (?=
        .*(?=\7$)
        (?!(11+?)\8+$)
      )
      (?=\7+$)
    |
      (?!(11+)\9+$)
      1+
    ))
    .*(?=\2$)          # Move to a position where there are exactly 
                       # P 1s ahead
    (?=\6)             # Try to still match Q (which means that Q is
                       # less than P)
  )
)
1+                     # Grab all digits for the match

여기에서 온라인으로 테스트 할 수 있습니다 . 그러나 너무 큰 입력을 시도하지 마십시오. 나는이 괴물의 성능에 대해 보장하지 않습니다.

편집하다:

나는 이것을 PCRE (2 단계 만 필요)로 포팅하고 정규 표현식을 거의 1/3로 단축했습니다. 새 버전은 다음과 같습니다.

^(1+),.*?\K(?=\1)(?=((11+)(?=.*(?=\3$)(?!(11+?)\4+$))(?=\3+$)|(?!(11+)\5+$)1+))(?!.+(?=\1)(?:(?!\2)|(?=((?2))).*(?=\2$)(?=\6)))1+

이것은 본질적으로 동일하며 두 가지 변경 사항이 있습니다.

• PCRE는 임의 길이의 lookbehind를 지원하지 않습니다 ( MIN그룹 으로 가져 오는 데 사용되었습니다 1). 그러나 일치 시작을 현재 커서 위치로 재설정하는 PCRE기능은 지원 \K합니다. 따라서 (?<=^(1+),.*)되고 ^(1+),.*?\K이미 2 바이트를 절약 할 수.
• 실제 절약은 PCRE의 재귀 기능에서 비롯됩니다. 실제로 재귀를 사용하지 않지만 서브 루틴 호출과 마찬가지로 (?n)그룹을 n다시 일치시키는 데 사용할 수 있습니다 . 원래 정규 표현식에는 숫자의 가장 큰 소수를 두 번 찾는 코드가 포함되어 있기 때문에 두 번째 것의 전체 대량을 간단한로 대체 할 수있었습니다 (?2).

정규식 (PCRE 풍미), 66 (65🐌) 바이트

두 정규 표현식 천재 인 Martin Ender 와 jaytea 가이 코드 골프에 대한 정규식 솔루션을 작성 했음을 알면서 영감을 얻어서 처음부터 직접 작성했습니다. 유명한 프라임 검사 정규 표현식이 내 솔루션의 어느 곳에도 나타나지 않습니다.

단항 정규식 마술이 당신을 망치고 싶지 않다면 이것을 읽으십시오. 이 마법을 스스로 알아 내고 싶다면 ECMAScript 정규식에서 몇 가지 문제를 해결하는 것이 좋습니다.

1. _{소수를 일치시킵니다 (정규식 에서이 작업에 익숙하지 않은 경우)}
2. _{2의 거듭 제곱을 맞추십시오 (아직 수행하지 않은 경우). 또는 Prime과 Powers가 포함 된 Regex Golf를 통해 길을 따라 가십시오 . Classic 및 Teukon 문제 세트를 모두 수행하십시오.}

3. _{N이 거듭 제곱 일 수있는 일정한 상수 (즉, 입력이 아닌 정규식에 지정됨) 인 N의 거듭 제곱과 일치하는 가장 짧은 방법을 찾으십시오 (그러나 필수는 아닙니다). 예를 들어, 6의 거듭 제곱을 일치시킵니다.}

4. _{N이 일정한> = 2 인 N 번째 거듭 제곱을 일치시키는 방법을 찾으십시오. 예를 들어 완벽한 정사각형을 찾습니다. (워밍업하려면 프라임 파워 와 일치하십시오 .)}

5. _{올바른 곱셈 문을 찾습니다. 삼각 숫자를 일치시킵니다.}

6. _{피보나치 수를 일치 시키거나 (나보다 미친 경우), 더 짧은 것을 고수하려면 올바른 지수 표현을 일치 시키십시오 (예열의 경우 2의 거듭 제곱 2의 대수와 일치합니다. – 보너스, 원하는 숫자로 반올림, 원하는 숫자로 반올림 또는 팩토리얼 숫자 (예열시 원초 숫자 와 일치 )}

7. _{풍부한 숫자를 일치 시키십시오 (나만큼 미친 사람이라면)}

8. _{요청 된 정밀도로 비이성적 인 숫자를 계산합니다 (예 : 입력을 2의 제곱근으로 나누고 반올림 결과를 일치로 반환)}

_{( 필자가 작성한 정규식 엔진 은 단항 수학 정규 표현식 에서 매우 빠르며 자연수 범위를 테스트 할 수있는 단항 숫자 모드를 포함하지만 단항이 아닌 정규식 또는 단항을 평가할 수있는 문자열 모드도 있기 때문에 도움이 될 수 있습니다 기본적으로 ECMAScript와 호환되지만 선택적 확장 (선택적 확장명 (다른 정규 표현식 엔진이없는 PCRE의 서브 세트 또는 분자식 미리보기를 추가 할 수 있음))이 있습니다.}

그렇지 않으면 이 GitHub Gist (경고, 많은 스포일러)를 읽고 읽어보십시오 .ECMAScript 정규식을 추진하여 난이도가 증가하는 자연수 함수를 다루는 여정을 연대 화합니다 (teukon의 퍼즐 세트부터 시작합니다. 여행).

이 문제에 대한 다른 정규식 솔루션과 마찬가지로 입력 값은 포괄 ​​범위를 나타내는 쉼표로 구분 된 이항 단항으로 두 개의 숫자로 제공됩니다. 하나의 숫자 만 반환됩니다. 정규식은 동일한 가장 큰 소수를 공유하는 모든 숫자를 별도의 일치 항목으로 반환하도록 수정 될 수 있지만 가변 길이 lookbehind가 필요 \K하고 lookahead를 넣거나 일치하는 대신 캡처로 결과를 반환해야합니다.

가장 작은 소수로 반복 암시 적 분할을하는 데 사용 된 기술은 길이가 네 번째 거듭 제곱 한 응답 문자열 인 일치 문자열 에서 사용 된 기술과 동일합니다 .

더 이상 고민하지 않고 : ((.+).*),(?!.*(?=\1)(((?=(..+)(\5+$))\6)*)(?!\2)).*(?=\1)\K(?3)\2$

여기서 시도해 볼 수 있습니다.

그리고 코멘트와 함께 무료 간격 버전 :

                        # No ^ anchor needed, because this algorithm always returns a
                        # match for valid input (in which the first number is less than
                        # or equal to the second number), and even in /g mode only one
                        # match can be returned. You can add an anchor to make it reject
                        # invalid ranges.

((.+).*),               # \1 = low end of range; \2 = conjectured number that is the
                        # smallest number in the set of the largest prime factor of each
                        # number in the range; note, it is only in subsequent tests that
                        # this is implicitly confined to being prime.
                        # We shall do the rest of our work inside the "high end of range"
                        # number.

(?!                     # Assert that there is no number in the range whose largest prime
                        # factor is smaller than \2.
  .*(?=\1)              # Cycle tail through all numbers in the range, starting with \1.

  (                     # Subroutine (?3):
                        # Find the largest prime factor of tail, and leave it in tail.
                        # It will both be evaluated here as-is, and later as an atomic
                        # subroutine call. As used here, it is not wrapped in an atomic
                        # group. Thus after the return from group 3, backtracking back
                        # into it can increase the value of tail – but this won't mess
                        # with the final result, because only making tail smaller could
                        # change a non-match into a match.

    (                   # Repeatedly divide tail by its smallest prime factor, leaving
                        # only the largest prime factor at the end.

      (?=(..+)(\5+$))   # \6 = tool to make tail = \5 = largest nontrivial factor of
                        # current tail, which is implicitly the result of dividing it
                        # by its smallest prime factor.
      \6                # tail = \5
    )*
  )
  (?!\2)                # matches iff tail < \ 2
)

# now, pick a number in the range whose largest prime factor is \2
.*(?=\1)                # Cycle tail through all numbers in the range, starting with \1.
\K                      # Set us up to return tail as the match.
(?3)                    # tail = largest prime factor of tail
\2$                     # Match iff tail == \2, then return the number whose largest
                        # prime factor is \2 as the match.

서브 루틴 호출을 서브 루틴의 사본으로 바꾸고 일치를 \ K 대신 캡처 그룹으로 리턴하여 알고리즘을 ECMAScript로 쉽게 포팅 할 수 있습니다. 결과 길이는 80 바이트입니다.

((x+)x*),(?!.*(?=\1)((?=(xx+)(\4+$))\5)*(?!\2)).*(?=\1)(((?=(xx+)(\8+$))\9)*\2$)

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

참고 ((.+).*)로 변경 될 수있다 ((.+)+)(1 내지 66 바이트 크기를 h, 65 바이트의 올바른 기능의 손실없이) -하지만 정규식 지수 느려짐에 폭발.

온라인으로 사용해보십시오! _{^{(79 바이트 ECMAScript 지수 감속 버전)}}

파이썬 2, 95

i=input()
for a in range(*i):
 s=a;p=2
 while~-a:b=a%p<1;p+=1-b;a/=p**b
 if p<i:i=p;j=s                                        
print j

숫자가 1이 될 때까지 시험 분할로 숫자의 부드러움을 찾습니다. i지금까지 가장 작은 부드러움을 j저장하고 해당 부드러움을 준 숫자를 저장합니다.

골프를위한 @xnor에게 감사합니다.

J, 22 20 19 자

({.@/:{:@q:)@(}.i.)

예 :

   2001 ({.@/: {:@q:)@(}. i.) 2014
2002

(두 개의 인수를 취하는 함수는 J에 삽입되어 있습니다.)

하스켈, 96 94 93 86 80 자

x%y|x<2=y|mod x y<1=div x y%y|0<1=x%(y+1)
a#b=snd$minimum$map(\x->(x%2,x))[a..b]

GHCi (Haskell 쉘)를 통한 사용법 :

>5 # 9
8
>9 # 15
9

편집 : 이제 훨씬 간단한 알고리즘입니다.

이 용액의 범위를 모두 포함 번호 (정도 8 # 9와 7 # 8모두 8이다)

설명:

(%) 함수는 x와 y의 두 매개 변수를 사용합니다. y가 2 인 경우 함수는 x의 부드러움을 반환합니다.

여기의 알고리즘은 간단합니다. 입력에서 모든 평활도의 조합 목록을 각 평활도와 함께 원래 번호에 대한 참조를 저장 한 다음 정렬하여 가장 작은 수를 얻고 참조 된 수를 반환합니다.

다음은 동일한 알고리즘을 사용하는 ungolfed 자바 스크립트 버전입니다.

function smoothness(n,p)
{
    p = p || 2
    if (x == 1)
        return p
    if (x % p == 0)
        return smoothness(x/p, p)
    else
        return smoothness(x,p+1);
}
function smoothnessRange(a, b)
{
    var minSmoothness = smoothness(a);
    var min=a;
    for(var i=a+1;i <= b;i++)
        if(minSmoothness > smoothness(i))
        {
            minSmoothness = smoothness(i)
            min = i
        }
    return min;
}

Mathematica, 61 45 39 자

Range@##~MinimalBy~Last@*FactorInteger&

명명되지 않은 함수로 스펙을 매우 간단하게 구현합니다.

• 범위를 포함하십시오 (포함).
• 모든 정수를 인수 분해하십시오.
• 가장 큰 소수로 정렬 된 최소값을 찾으십시오.

루아-166 자

나는 하지 않습니다 에 대한 언급을 (! 아직) 충분한 명성을하지 않았다 AndoDaan의 솔루션 ,하지만 여기에 자신의 코드에 대한 몇 가지 개선 사항은

a,b=io.read("*n","*n")s=b for i=a,b do f={}n=i d=2 while n>1 do while n%d<1 do f[#f+1]=d n=n/d end d=d+1 end p=math.max(unpack(f))if p<s then s=p c=i end end print(c)

변경 :

• n%d==0의해 n%d<1이 경우에 상당
• 공간을 제거했습니다
• 대체 table.insert(f,d)하여 f[#f+1]=d ( #f(F)의 요소의 수이다)

Bash + coreutils, 56 바이트

seq $@|factor|sed 's/:.* / /'|sort -nk2|sed '1s/ .*//;q'

입력은 정확히 두 개의 명령 행 인수 (감사 @ nyuszika7h !!!)에서 가져옵니다. 출력은 STDOUT에 인쇄 된 단일 결과입니다.

• seq 명령 줄 인수에서 한 줄에 하나씩 숫자의 범위를 제공합니다.
• factor해당 숫자를 읽고 각 숫자 다음에 콜론과 해당 숫자의 소인수로 정렬 된 목록을 출력합니다. 따라서 가장 큰 주요 요소는 각 줄의 끝에 있습니다.
• 첫 번째 sed는 콜론과 마지막 / 가장 큰 소수를 제외한 모든 소수를 제거하므로 각 숫자 (열 1)와 가장 큰 소수 (열 2)의 목록을 남깁니다.
• sort 열 2만큼 숫자 순으로 증가합니다.
• 마지막 sed은 1 행 (목록에서 가장 큰 소수가 가장 작은 수)과 일치하고 첫 번째 공백을 포함하여 그 이후의 모든 항목을 제거한 다음 종료됩니다. sed이 대체 결과를 종료하기 전에 자동으로 인쇄합니다.

산출:

$ ./smooth.sh 9 15
12
$ ./smooth.sh 9 16
16
$ ./smooth.sh 157 249
162
$ ./smooth.sh 2001 2014
2002
$ 

이 컨텍스트의 범위 는 두 끝점을 모두 포함 합니다.

파이썬 2, 67

f=lambda R,F=1,i=2:[n for n in range(*R)if F**n%n<1]or f(R,F*i,i+1)

다른 골프에 대해 생각하면 매끄러움을 확인하는 새로운 알고리즘에 대한 아이디어가 생겼습니다.

계승의 소인수 분해 i!에는 정확히 소인수가 포함됩니다 i. 그래서 경우는 n서로 다른 소수의 제품이, 그 부드러움 (최대 소인수)는 가장 작은 i하는 n의 제수입니다 i!. 의 반복되는 소인수를 설명하기 위해 n대신 충분히 높은 전력을 사용할 수 있습니다 i!. 특히 (i!)**n충분합니다.

코드는 계승 증가를 시도하고 F=i!재귀 적으로 업데이트됩니다. F입력 범위 에있는 제수를 필터링 하고, 존재하는 경우 출력하고 그렇지 않으면로 이동합니다 (i+1)!.

테스트 사례 :

>> f([157, 249])
[162, 192, 216, 243]

C,  149   95

수정 된 답변 :

이 솔루션에 대한 크레딧을 청구 할 수 없습니다. 이 업데이트 된 답변은 isaacg 가 Python 솔루션에서 사용한 아름다운 방법을 차용합니다 . 중괄호없이 중첩 for/ while루프로 C로 작성할 수 있는지 확인하고 싶었습니다 .

R(a,b,n,q,p,m){for(;a<b;m=p<q?a:m,q=p<q?p:q,n=++a,p=2)while(n>1)if(n%p)p++;else n/=p;return m;}

설명:

• 함수 R(a,b,n,q,p,m)는 범위 a를 스캔하고 b-1가장 먼저 찾은 가장 부드러운 숫자를 반환합니다. 호출은 다음 형식을 준수해야합니다. R(a,b,a,b,2,0)따라서 함수 내부의 변수는 다음과 같이 효과적으로 초기화됩니다 n=a;q=b;p=2;m=0;.

원래 답변 :

이것은 내 원래의 대답이었습니다 ...

P(n,f,p){for(;++f<n;)p=p&&n%f;return p;}
G(n,f){for(;--f>1;)if(n%f==0&&P(f,1,1))return f;}
R(a,b,p,n){for(;++p;)for(n=a;n<b;n++)if(G(n,n)==p)return n;}

설명:

• 함수 는 우선 순위 P(n,f,p)값 n을 테스트 하고 n프라임 이면 true (영이 아님) 또는 프라임 이 아닌 경우 false (영)를 리턴합니다 n. f그리고 p모두 1로 전달해야합니다.
• 함수 G(n,f)는의 최대 소수를 반환합니다 n. f로 전달되어야합니다 n.
• 함수 R(a,b,p,n)는 범위 a를 스캔하고 b-1가장 먼저 찾은 가장 부드러운 숫자를 반환합니다. p1로 전달되어야합니다 n. 모든 값이 될 수 있습니다.

테스트 드라이버 :

test(a,b){printf("smooth_range(%d, %d)\n%d\n",a,b,S(a,b,1,0));}
main(){test(5,11);test(9,16);test(9,17);test(157,249);test(2001,2014);}

산출:

smooth_range(5, 11)
8
smooth_range(9, 16)
9
smooth_range(9, 17)
16
smooth_range(157, 249)
162
smooth_range(2001, 2014)
2002

하스켈-120

import Data.List
import Data.Ord
x!y=(minimumBy(comparing(%2)))[x..y]
x%y|x<y=y|x`mod`y==0=(x`div`y)%y|otherwise=x%(y+1)

사용법 예 :

> 5 ! 10
8
> 9 ! 15
9
> 9 ! 16
16
> 157 ! 248
162
> 2001 ! 2013
2002

Q, 91 자 K, 78 자

{(x+{where x=min x}{(-2#{x div 2+(where 0=x mod 2_til x)@0}\[{x>0};x])@0}'[(x)_til y+1])@0}

k는 아마도 12 문자를 면도 할 것입니다

편집 : 실제로, 이번에는 상한을 비 포괄적으로 취급합니다.

{*:x+{&:x=min x}{*:-2#{6h$x%2+*:&:x={y*6h$x%y}[x]'[2_!x]}\[{x>0};x]}'[(x)_!y]}

참고 :이 답변은 허용되지 않습니다.

이 답변은 챌린지 요청 후 추가 된 Pyth의 여러 기능을 사용합니다.

2 요소 튜플에서 단항 범위를 호출하는 또 다른 새로운 기능을 추가하여 솔루션을 두 문자로 단축시킵니다.

피 이스 , 7

hoePNUQ

입력은 이제 쉼표로 구분됩니다. 나머지는 동일합니다.

이 답변은이 질문이 제기 된 후, 특히 @aditsu의 훌륭한 CJam 솔루션을 본 후에 추가 된 Pyth의 기능을 사용합니다. 즉, 그 기능을 추가하면 무엇이 가능해 졌는지 보여주고 싶었습니다. 이 기능은 P정수 입력에서 입력의 모든 주요 요소 목록을 최소에서 최대로 정렬하는 arity-1 함수입니다.

피시스 , 9

hoePNrQvw

STDIN에서 분리 된 파이썬 스타일 범위를 사용합니다. 가장 작은 솔루션을 STDOUT에 출력합니다.

설명:

      Q = eval(input())                         Implicit, because Q is present.
h     head(                                     First element of
 o         order_by(                            Sort, using lambda expression as key.
                    lambda N:                   Implicit in o
  e                          end(               Last element of
   PN                            pfact(N)),     List containing all prime factors of N.
  r                 range(                      Python-style range, lower inc, upper exc.
   Q                      Q,                    A variable, initialized as shown above.
   vw                     eval(input()))))      The second entry of the range, same way.

테스트 :

$ newline='
'

$ echo "9${newline}16" | ./pyth.py -c 'hoePNrQvw'
9

$ echo "9${newline}17" | ./pyth.py -c 'hoePNrQvw'
16

$ echo "157${newline}249" | ./pyth.py -c 'hoePNrQvw'
162

$ echo "2001${newline}2014" | ./pyth.py -c 'hoePNrQvw'
2002

루아-176 자

a,b=io.read("*n","*n")s=b for i=a,b do f={}n=i d=2 while n>1 do while n%d==0 do table.insert(f, d)n=n/d end d=d+1 end p=math.max(unpack(f))if p<s then s=p c=i end end print(c)

루아에서 골프를 멈춰야합니다. 아무 소용이 없다.

Clojure의 - 173 개 170 문자

저는 Clojure 초보자입니다. 골프 :

(defn g[x,d](if(and(= 0(mod x d))(.isProbablePrime(biginteger d) 1))d 0))(defn f[i](apply max-key(partial g i)(range 2(inc i))))(defn s[a,b](first(sort-by f(range a b))))

샘플 실행 :

범위에는 로우 엔드, 하이 엔드 제외가 포함됩니다. [a, b) 여러 개의 경우 가장 부드러운 숫자 중 하나만 인쇄합니다.

(println (s 5 11))
(println (s 9 16))
(println (s 9 17))
(println (s 157, 249))
(println (s 2001, 2014))

수율 :

bash$ java -jar clojure-1.6.0.jar range.clj
8
9
16
192
2002

언 골프 드 :

(defn g [x,d] (if (and (= 0(mod x d)) (.isProbablePrime (biginteger d) 1)) d 0))
(defn f [i] (apply max-key (partial g i) (range 2 (inc i))))
(defn s [a,b] (first (sort-by f (range a b))))

루비, 65 62

require'prime'
s=->a,b{(a..b).min_by{|x|x.prime_division[-1]}}

https://codegolf.stackexchange.com/a/36484/6828 에 대한 사과와 함께 이것은 골프의 (그리고 약간 단순화 된) 버전입니다. 문자가 더 짧기 때문에 포함 범위를 사용합니다.

1.9.3-p327 :004 > s[157,249]
 => 192 
1.9.3-p327 :005 > s[5,11]
 => 8 
1.9.3-p327 :006 > s[9,15]
 => 12 
1.9.3-p327 :007 > s[9,16]
 => 16 

세 문자를 저장해 준 YenTheFirst 덕분에.

C # 1 LINQ : 317 303 289 262

using System.Linq;class P{static void Main(string[]a){System.Console.Write(Enumerable.Range(int.Parse(a[0]),int.Parse(a[1])).Select(i=>new{i,F=F(i)}).Aggregate((i,j)=>i.F<j.F?i:j).i);}static int F(int a){int b=1;for(;a>1;)if(a%++b<1)while(a%b<1)a/=b;return b;}}

언 골프 드 :

using System.Linq;

class P
{
  static void Main(string[]a)
  {
    System.Console.Write(
      Enumerable.Range(int.Parse(a[0]), int.Parse(a[1])) //create an enumerable of numbers containing our range (start, length)
        .Select(i => new { i, F = F(i) }) //make a sort of key value pair, with the key (i) being the number in question and the value (F) being the lowest prime factor
        .Aggregate((i, j) => i.F < j.F ? i : j).i); //somehow sort the array, I'm still not entirely sure how this works
  }
  static int F(int a)
  {
    int b=1;
    for(;a>1;)
      if(a%++b<1)
        while(a%b<1)
          a/=b;
    return b;
  }
}

명령 행에서 시작과 길이를 가져 와서 가장 큰 스무스 숫자를 반환합니다.

나는에서 답변 사용 여기 와 여기를 내 대답을 할 수 있습니다.

이를 조정하고 12 바이트를 줄인 VisualMelon에 감사합니다! 나는 또한 2 바이트를 절약하는 경우 중괄호를 제거했으며 CodeInChaos는 내가 놓친 몇 가지 명백한 것을 지적했습니다 (다시 감사합니다).

제 83 화

library(gmp)
n=a:b
n[which.min(lapply(lapply(lapply(n,factorize),max),as.numeric))]

여기서 입력 범위의 맨 아래가 지정되고 a맨 위 (포함)가에 지정됩니다 b.

gmpCRAN에서 사용 가능한 패키지입니다. mfCJam에서 부조리 한 기능을 볼 때까지 더러워 졌습니다. install.packages("gmp")콘솔 에 입력하여 설치 하십시오.

PowerShell-85

($args[0]..$args[1]|sort{$d=2
while($_-gt1){while(!($_%$d)){$m=$d;$_/=$d}$d++}$m})[0]

각 숫자의 최대 소인수를 기준으로 숫자 범위 (포함)를 정렬합니다. 가장 낮은 정렬 된 요소를 리턴합니다.

> smooth 5 10
8
> smooth 9 15
12
> smooth 9 16
16
> smooth 157 248
243
> smooth 2001 2013
2002

J-16 자

주석에서 허용하는대로 ( start , length ) 스타일 범위를 사용합니다 .

(0{+/:{:@q:@+)i.

dyadic 동사로 사용하려면 왼쪽 인수는 start , right는 length 입니다.

   5 (+)i. 6              NB. range
5 6 7 8 9 10
   5 (q:@+)i. 6           NB. prime factorizations
5 0 0
2 3 0
7 0 0
2 2 2
3 3 0
2 5 0
   5 ({:@q:@+)i. 6        NB. largest prime factors
5 3 7 2 3 5
   5 (+/:{:@q:@+)i. 6     NB. sort range by smallest factors
8 6 9 5 10 7
   5 (0{+/:{:@q:@+)i. 6   NB. take first entry
8
   f=:(0{+/:{:@q:@+)i.    NB. can also be named
   2001 f 13
2002

( start , end ) 솔루션은 +2 자이며 끝을 제외합니다. 끝을 포함하여 +2 이상입니다. 그러나 밝은면에서는 모든 {braces}를 일치시키기 때문에 다소 멋지게 보입니다.

(0{}./:{:@q:@}.)i.    NB. excluding
(0{}./:{:@q:@}.)1+i.  NB. including

진지하게, 8 * 14 / 7 = 16 (비 경쟁적)

,x;`yM`M;m@í@E

이 도전 이후에 심각하게 만들어졌지만, 심각하게 능숙한 도전의 유형을 예시하기 때문에이 답변을 게시하고 싶었습니다.

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

설명:

,x;`yM`M;m@í@E
,x;             make two copies of range(a,b) (a,b = input())
   `  `M;       make two copies of the result of the map:
    yM            push maximum prime factor
         m@í    push index of minimum element from prime factors
            @E  push element from range with given index

Pyth , 7 바이트

.mePbrF

여기 사용해보십시오!

$[a, b)$$[a, b]$}r

.mePbrF – Full program with arguments a and b.
     rF – Fold by half-inclusive range. Yields the integers in [a, b).
.m      – Values b in that list which give minimal results when applied f.
  ePb   – function / block f. 
   Pb   – Prime factors of b.
  e     – Last element. This is guaranteed to yield the largest, as they're sorted.

코브라-150

def f(r as vari int)
    x,y=r
    c,o=y,0
    for n in x:y,for m in n:0:-1
        p=1
        for l in 2:m,if m%l<1,p=0
        if n%m<=0<p
            if m<c,c,o=m,n
            break
    print o

내가 왜 귀찮게했는지 모르겠지만, 코브라는 여기서 경쟁 할 수 없습니다.

루비-113 자

stdlib 사용 하나의 결과를 반환합니다. 루비 2.1.2에서 테스트되었습니다.

require 'prime'
def smooth_range(a,b)
  (a...b).sort_by{|e|e.prime_division.flat_map{|f,p|[f]*p}.uniq.max}[0]
end

펄 (5.10+), 83

for(<>..<>){$n=$_;$p=2;$_%$p&&$p++or$_/=$p while$_>1;$m=$p,$r=$n if$p<$m||!$m}
say$r

(줄 바꿈을 제거 할 수 있습니다). 두 줄의 stdin에서 포괄적 인 범위의 두 끝점을 가져 오고 ( <>액세스하는 것보다 저렴 하기 때문에 ARGV) stdout에서 가장 매끄러운 출력을합니다. 가장 매끈한 넥타이가 있으면 가장 작은 것을 인쇄합니다. 한 문자를 대가로 가장 큰 것을 인쇄 할 수 있습니다.

알고리즘은 기본적으로 isaacg의 가장 큰 주요 요소를 찾는 방법이지만 독립적으로 생각해 냈습니다. 그 부분은 펄에서 하나의 문장으로 아름답게 골프를 치고 나머지는 내가 원하는 것보다 더 많은 오버 헤드를 가지고 있습니다.

프리앰블 아래 perl -E또는 use 5.012프리앰블 과 함께 실행해야합니다 . 당신이 할 수없는 경우, 대체 say$r와 함께 print$r,$/.

파이썬 2 (84)

f=lambda n,p=2:n>1and f(n/p**(n%p<1),p+(n%p>0))or p
print min(range(*input()),key=f)

@isaacg의 솔루션 이지만 min명시 적 최소 찾기 대신 기능 키를 사용하고 반복 기능을 수행하는 재귀 함수를 사용합니다.

재귀 제한을 피하기 위해 스택리스 파이썬 에서 실행하십시오 .

paranthesized 조건을 사용하고, parantheses (n%p<1)에서도 그 부정을 반복 하는 것은 낭비 적 인 것처럼 보이지만 그것이 (n%p>0)내가 얻은 최선이었습니다. 나는 많은 것들을 시도했지만 더 나빴습니다.

f(n/p**(n%p<1),p+(n%p>0))     # Current for comparison
f(*[n/p,n,p,p+1][n%p>0::2])
n%p and f(n,p+1)or f(n/p,p)
f(*n%p and[n,p+1]or[n/p,p])

당신이 생각할 수있는 개선을 환영합니다.

Java 8-422454 자

Java 8을 배우고 있으며 Java (또는 Java 8 스트림)와 관련 하여이 장면을 제공하고 싶었습니다.

다른 언어와 비교할 때 이것은 잔인하지만 재미있는 운동입니다.

골프 :

import java.util.stream.*;import java.math.*;
class F{int v;int i;public int getV() { return v; }
F(int i){this.i = i;v=IntStream.range(2,i+1).map(j->((i%j==0)&&new BigInteger(""+j).isProbablePrime(1))?j:0).max().getAsInt();}}
public class T{
int s(int a, int b){return IntStream.range(a,b+1).boxed().map(F::new).sorted(java.util.Comparator.comparingInt(F::getV)).collect(java.util.stream.Collectors.toList()).get(0).i;}}

언 골프 드 :

import java.util.stream.*;
import java.math.*;

class F {
    int v;
    int i;
    public int getV() { return v; }
    F (int i) { 
        this.i = i;
        v = IntStream.range(2,i+1)
                     .map( j -> ((i%j==0) && 
                           new BigInteger(""+j).isProbablePrime(1))?j:0)
                     .max()
                     .getAsInt();
    }
}

public class T {
    int s(int a, int b) {
        return IntStream.range(a,b+1)
                    .boxed()
                    .map(F::new)
                    .sorted(java.util.Comparator.comparingInt(F::getV))
                    .collect(java.util.stream.Collectors.toList())
                    .get(0).i;
    }
}

다음을 사용하여 실행 예 :

public static void main(String[] s) {
    System.out.println(new T().s(157,249));
}

192

MATL ( 비경쟁 ), 20 바이트

이 언어는 도전 후에 디자인되었습니다

범위는 양쪽 끝에 포함됩니다. 숫자는 두 개의 개별 입력으로 간주됩니다.

2$:t[]w"@YfX>v]4#X<)

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

설명

2$:          % implicitly input two numbers. Inclusive range
t            % duplicate                      
[]           % empty array
w            % swap elements in stack         
"            % for each                  
  @          %   push loop variable
  Yf         %   prime factors                  
  X>         %   maximum value
  v          %   vertical concatenation         
]            % end for each                         
4#X<         % arg min 
)            % index with this arg min into initial range of numbers

젤리 , 7 바이트, 점수 = 7 ÷ 7 × 8 = 8, 언어 사후 도전

rÆfṀ$ÐṂ

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

하위 및 상위 범위 끝점을 두 개의 개별 인수로 사용합니다. 범위에서 모든 가장 부드러운 숫자의 목록을 출력합니다. (이것은 함수로 볼 수 있으며,이 경우 출력은 젤리 목록이거나 전체 프로그램으로 볼 수 있습니다.이 경우 출력은 JSON과 동일한 목록 표현을 사용합니다.

설명

Jelly 프로그램이 스펙의 문자 그대로의 번역 일 때…

rÆfṀ$ÐṂ
r        Range from {first argument} to {second argument}
     ÐṂ  Return the elements which have the minimum
   Ṁ$      largest
 Æf          prime factor