あなたの課題は、与えられた範囲で最も滑らかな数を見つけることです。言い換えれば、最大の素因数が最小の数を見つけます。

なめらかな数は、その最大の素因数に小さいものです。このタイプの数値は、高速フーリエ変換アルゴリズム、暗号解読、およびその他のアプリケーションに役立ちます。

たとえば、範囲5, 6, 7, 8, 9, 108では、8が最大の素因数であるので8が最も滑らかな数値であり、他の数値はすべて3以上の素因数を持っています。

入力：入力は、範囲を定義する2つの正の整数になります。範囲の最小許容整数は2です。言語の範囲内で任意の範囲を指定できる限り、範囲が包括的、排他的、半排他的などであるかどうかを選択できます。関数入力、標準入力、コマンドライン引数、または言語の同等の方法で数値を取得できます。入力に追加情報をエンコードしません。

出力：入力範囲内で最大に滑らかな（最小の最大係数）1つ以上の整数を返すか、印刷するか、同等にします。複数の結果を返すことはオプションですが、そうすることを選択した場合は、結果を明確に区切る必要があります。ネイティブ出力形式は、複数の結果に適しています。

回答の中で、どのように入力を取り、出力を行っているかを説明してください。

スコアリング：コードゴルフ。ASCIIで記述されている場合は文字でカウントし、ASCIIで記述されていない場合は8 * bytes / 7でカウントします。

テストケース：

注：これらは、ローエンドを含むがハイエンドを含まないPythonスタイルの範囲です。プログラムに応じて変更します。必要な結果は1つだけです。

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つの数値（minとmaxなど）
,をプッシュすると、配列[0 1 ... max-1]
>が配列をminからスライスし、[min ... max-1]になります。
{…}$ブロックを使用して配列を並べ替え、並べ替えキーを計算して
mf、数値のすべての素因数を含む配列を取得し、配列
W=の最後の要素（W = -1）を取得して、最大の素因数を取得します。ソートキー
0=は、（ソートされた）配列の最初の要素を取得します

正規表現（.NET PCREフレーバー）、183 129バイト

自宅でこれを試さないでください！

これは実際には勝利の候補ではありません。しかし、エリック・トレスラーは正規表現だけでこの問題を解決することを提案しました、そして、私はそれに挑戦することを抵抗することができませんでした。これは 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になります。ネクタイは、最小の数を優先して壊れます。

したがって、質問の2番目の例は、次の文字列になります（下線付きの一致）

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つの手順のみを必要とする）に移植し、正規表現をほぼ3分の1に短縮しました。新しいバージョンは次のとおりです。

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

これは基本的に同じですが、2つの変更点があります。

• PCREは、任意の長さの後読みをサポートしていません（これをMINグループに入れるために使用していました1）。ただし、一致の開始を現在のカーソル位置にリセットするPCREサポート\Kは行います。したがって、はに(?<=^(1+),.*)なり^(1+),.*?\K、すでに2バイトが節約されます。
• 本当に節約できるのは、PCREの再帰機能です。実際には再帰を使用していませんが、サブルーチン呼び出しと同様に、(?n)グループをn再度一致させるために使用できます。元の正規表現には、数値の最大の素因数を2回見つけるためのコードが含まれていたため、2番目の大部分を単純なに置き換えることができました(?2)。

正規表現（PCREフレーバー）、66（65🐌）バイト

正規表現の天才であるMartin Enderとjayteaの両方がこのコードゴルフの正規表現ソリューションを書いたことに触発されて、私はゼロから自分自身を書きました。有名な素数チェック正規表現は、私のソリューションのどこにも現れません。

単項正規表現の魔法を台無しにしたくない場合は、これを読んではいけません。この魔法を自分で理解するためにショットを撮りたい場合は、ECMAScript正規表現のいくつかの問題を解決することから始めることを強くお勧めします。

1. _{素数に一致します（正規表現でこれを行うことに慣れていない場合）}
2. _{2のべき乗を一致させます（まだ一致していない場合）。または、PrimeおよびPowersを含むRegex Golfを使用してください。ClassicとTeukonの両方の問題セットを必ず実行してください。}

3. _{Nの累乗に一致する最短の方法を見つけます。ここで、Nは合成可能な（ただし、入力でなく正規表現で指定された）定数です（ただし、必須ではありません）。たとえば、6のべき乗に一致します。}

4. _{Nの累乗を一致させる方法を見つけます。ここで、Nは2以上の定数です。たとえば、完全な正方形に一致します。（ウォームアップのために、プライムパワーと一致します。）}

5. _{正しい乗算ステートメントに一致します。三角数字に一致します。}

6. _{フィボナッチ数と一致する場合（あなたが私と同じくらいクレイジーな場合）、またはより短いものに固執したい場合は、べき乗の正しいステートメントに一致します（ウォームアップの場合、2の底の2の対数に一致するように戻ります）ボーナス、好きなように丸めて任意の数で同じことを行います）、または階乗数（ウォームアップの場合は、原数に一致します）。}

7. _{豊富な数字に一致する（あなたが私と同じくらいクレイジーな場合）}

8. _{要求された精度まで無理数を計算します（たとえば、入力を2の平方根で除算し、丸めた結果を一致として返します）}

_{（私が書いた正規表現エンジンは、単項数学正規表現で非常に高速で、自然数の範囲をテストできる単項数値モードが含まれていますが、非単項正規表現または単項を評価できる文字列モードもありますので、役立つかもしれませんデフォルトではECMAScriptと互換性がありますが、オプションの拡張機能があります（PCREのサブセット、または他の正規表現エンジンにはない分子先読みを選択的に追加できます）。}

それ以外の場合は、このGitHub Gist（警告、多くのネタバレ）を読んでください旅）。

この問題に対する他の正規表現ソリューションと同様に、入力は、全範囲を表すコンマで区切られた全単射の2つの数値として与えられます。1つの数値のみが返されます。正規表現は、同じ最小の最大素数を共有するすべての数値を個別の一致として返すように変更できますが、可変長の後読みが必要\Kであり、先読みを行うか、一致ではなくキャプチャとして結果を返す必要があります。

ここで使用されている最小の素因数による暗黙の除算の繰り返しの手法は、長さの4乗の答えであるMatch文字列で使用されている手法と同じです。

これ以上苦労せずに： ((.+).*),(?!.*(?=\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から65バイト）落としますが、正規表現は指数関数的にスローダウンします。

オンラインでお試しください！ _{^{（79バイトECMAScript指数関数的スローダウンバージョン）}}

Python 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

（2つの引数を取る関数は、Jの挿入記号です。）

Haskell、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の2つのパラメーターを取ります。yが2の場合、関数はxの滑らかさを返します。

ここからのアルゴリズムは単純です-入力内の数値のすべての滑らかさの組み合わせリストを取得し、各滑らかさは元の番号への参照を保存し、ソートしてから最小のものを取得し、その参照番号を返します。

同じアルゴリズムを使用したJavaScriptなしのJavaScriptバージョンを次に示します。

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==0n%d<1
• スペースを削除しました
• に置き換えtable.insert(f,d)られますf[#f+1]=d （#fはfの要素の数です）

Bash + coreutils、56バイト

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

入力は、正確に2つのコマンドライン引数からのものです（ありがとう@ nyuszika7h !!!）。出力は、STDOUTに出力される特異な結果です。

• seq コマンドライン引数から、1行に1つずつ数値の範囲を提供します。
• 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
$ 

この文脈での注意の範囲は包括的両方のエンドポイントの。

Python 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はおそらく十ダースの文字を剃るだろう

編集：確かに、今回は上限を非包括的として扱います

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

注：この回答は許可されていません。

この回答では、チャレンジの依頼後に追加されたPythの複数の機能を使用しています。

2要素タプルの単項範囲を呼び出す別の新しい機能を追加しました。これにより、ソリューションが2文字短くなります。

パイス、7

hoePNUQ

入力はカンマ区切りになりました。残りは同じです。

この回答では、特に@aditsuのすばらしいCJamソリューションを見た後に、この質問が行われた後に追加されたPythの機能を使用しています。そうは言っても、その機能を追加することで何が可能になったかを示したかったのです。この機能はP、整数入力で入力のすべての素因数のリストを返すアリティ-1関数で、最小から最大にソートされます。

パイス、9

hoePNrQvw

Pythonスタイルの範囲、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）複数の場合、最も滑らかな数字の1つのみを印刷します。

(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、これはそのgolfed（及びわずかに単純化された）バージョンです。文字が短いため、包括的範囲を使用します。

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 

また、3文字を保存してくれたYenTheFirstに感謝します。

C＃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;
  }
}

コマンドラインから開始点と長さを取得し、最大の滑らかな数値を返します。

私はから回答使用こことここを私の答えを作ること。

VisualMelonを微調整して12バイト削り取ってくれてありがとう！また、2バイトを節約する場合は中括弧を削除し、CodeInChaosは私が見逃した明らかなものを指摘しました（再度ありがとう）。

R、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.

二項動詞として使用する場合：左引数はstart、右引数は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文字で、endを除外します。終わりを含めてさらに+2です。しかし、明るい面では、すべての{括弧}を一致させるため、かなり見栄えがよくなります。

(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を使用します。1つの結果を返します。ruby 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

Perl（5.10以降）、83

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

（改行は削除できます）。stdinの2行の包括的範囲の2つのエンドポイントを取得し（<>アクセスするよりも安いためARGV）、最も滑らかなものをstdoutに出力します。最も滑らかなネクタイがある場合、最も小さいものを印刷します。1文字のコストで最大のものを印刷できます。

アルゴリズムは基本的に最大の素因数を見つけるisaacgの方法ですが、独自に考え出したものです。その部分はperlの1つのステートメントに美しく下がっていますが、残りは私が望むよりもオーバーヘッドが多くなっています。

プリアンブルの下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、明示的な最小値検出の代わりにbyファンクションキーを使用し、反復の役割を果たす再帰関数を使用します。

Stackless Pythonで実行して、再帰の制限を回避します。

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-422 454文字

私は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つの個別の入力として取得されます。

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Ṁ$ÐṂ

オンラインでお試しください！

下限と上限のエンドポイントを2つの別個の引数として受け取ります。範囲内のすべての最も滑らかな数値のリストを出力します。（これは関数として表示できます。この場合、出力はJellyリスト、または完全なプログラムとして表示します。この場合、出力はたまたまJSONと同じリスト表現を使用します。）

説明

Jellyプログラムが仕様の文字通りの翻訳である場合…

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