[Question]
  [
Your challenge is to find the smoothest number over a given range. In other words, find the number whose greatest prime factor is the smallest.
A [smooth number](http://en.wikipedia.org/wiki/Smooth_number) is one whose largest prime factor is small. Numbers of this type are useful for the fast Fourier transform algorithm, cryptanalysis, and other applications.
For instance, over the range `5, 6, 7, 8, 9, 10`, 8 is the smoothest number, because 8's greatest prime factor is 2, whereas all of the other numbers have a prime factor of 3 or greater.
**Input:** The input will be two positive integers, which define a range. The minimum allowable integer in the range is 2. You may choose whether the range is inclusive, exclusive, semi-exclusive, etc, as long as an arbitrary range can be specified within the bounds of your language. You may take the numbers via function input, stdin, command line argument, or any equivalent method for your language. No encoding extra information in the input.
**Output:** Return, print or equivalent one or more integers in the input range which are maximally smooth (minimal greatest factor). Returning multiple results is optional, but if you choose to do so the results must be clearly delimited. Native output format is fine for multiple results.
Please state in your answer how you are taking input and giving output.
**Scoring:** Code golf. Count by characters if written in ASCII, or 8\*bytes/7 if not in ASCII.
**Test cases:** 
Note: These are Python-style ranges, including the low end but not the high end. Change as appropriate to your program. Only one result is necessary.
```
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
```
  
[Answer]
# CJam - 13
```
q~,>{mfW=}$0=
```
Try it at <http://cjam.aditsu.net/>
Example input: `2001 2014`  
Example output: `2002`
**Explanation:**
`q~` reads and evaluates the input, pushing the 2 numbers on the stack (say min and max)  
`,` makes an array [0 1 ... max-1]  
`>` slices the array starting at min, resulting in [min ... max-1]  
`{‚Ä¶}$` sorts the array using the block to calculate the sorting key  
`mf` gets an array with all the prime factors of a number, in order  
`W=` gets the last element of the array (W=-1), thus obtaining the largest prime factor to be used as a sorting key  
`0=` gets the first element of the (sorted) array
[Answer]
## Regex (~~.NET~~ PCRE flavour), ~~183~~ 129 bytes
Don't try this at home!
This is not really a contender for the win. But Eric Tressler suggested solving this problem with nothing but a regex, and I couldn't resist giving it a go. This ~~might be~~ is possible in PCRE as well (and even shorter, see below), but I chose .NET because my solution needs arbitrary-length lookbehinds. Here we go:
```
(?<=^(1+),.*)(?=\1)(?=((11+)(?=.*(?=\3$)(?!(11+?)\4+$))(?=\3+$)|(?!(11+)\5+$)1+))(?!.+(?=\1)(?:(?!\2)|(?=((11+)(?=.*(?=\7$)(?!(11+?)\8+$))(?=\7+$)|(?!(11+)\9+$)1+)).*(?=\2$)(?=\6)))1+
```
The input is encoded as an inclusive comma-separated range, where both numbers are given in unary notation using `1`s. The match will be the trailing `S` 1s where `S` is the smoothest number in the range. Ties are broken in favour of the smallest number.
So the second example from the question would be the following string (match underlined)
```
111111111,1111111111111111
                 =========
```
It is based on the (by now rather well-known) [prime-checking regex](https://stackoverflow.com/questions/2795065/how-to-determine-if-a-number-is-a-prime-with-regex), variations of which are embedded in there a whopping 6 times.
Here is a version using free-spacing and comments for those who want to know what's going on.
```
# 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
```
You can test it online [over here](http://regexhero.net/tester/?id=c01109dc-6236-4f04-a8dd-02d6a1f9b0b4). Don't try too large inputs though, I make no guarantees about the performance of this monster.
**Edit:**
I ended up porting this to PCRE (which only requires two steps), and shortening the regex by almost a third. Here is the new version:
```
^(1+),.*?\K(?=\1)(?=((11+)(?=.*(?=\3$)(?!(11+?)\4+$))(?=\3+$)|(?!(11+)\5+$)1+))(?!.+(?=\1)(?:(?!\2)|(?=((?2))).*(?=\2$)(?=\6)))1+
```
This is essentially the same, with two changes:
* PCRE does not support arbitrary-length lookbehind (which I used to get the `MIN` into group `1`). However, `PCRE` does support `\K` which resets the beginning of the match to the current cursor position. Hence `(?<=^(1+),.*)` becomes `^(1+),.*?\K`, which already saves two bytes.
* The real savings come from PCRE's recursion feature. I'm not actually using recursion, but you can use `(?n)` to match group `n` again, similar to a subroutine call. Since the original regex contained the code for finding a number's largest prime factor twice, I was able to replace the whole bulk of the second one with a simple `(?2)`.
[Answer]
# Regex (Perl / PCRE), ~~66~~ 65 (64üêå) bytes
Inspired by seeing that both [Martin Ender](https://codegolf.stackexchange.com/users/8478/martin-ender) and [jaytea](https://codegolf.stackexchange.com/users/75057/jaytea), two regex geniuses, wrote regex solutions to this code golf, I wrote my own from scratch. The famous prime-checking regex does not appear anywhere in my solution.
Do not read this if you don't want some unary regex magic spoiled for you. If you do want to take a shot at figuring out this magic yourself, I highly recommend starting by solving some problems in ECMAScript regex:
1. Match prime numbers (if you aren't already familiar with doing this in regex)
2. Match powers of 2 (if you haven't already done so). Or just work your way through [Regex Golf](https://alf.nu/RegexGolf), which includes Prime and Powers. Make sure to do both the Classic and Teukon problem sets.
3. > 
>  Find the shortest way to match powers of N where N is some constant (i.e. specified in the regex, not the input) which can be composite (but is not required to be). For example, match powers of 6.
> 
> 
>
4. > 
>  Find a way of matching Nth powers, where N is some constant >=2. For example, match perfect squares. (For a warmup, match [prime powers](https://oeis.org/A000961).)
> 
> 
>
5. > 
>  Match correct multiplication statements. Match triangular numbers.
> 
> 
>
6. > 
>  Match Fibonacci numbers (if you're as crazy as I am), or if you want to stick to something shorter, match correct statements of exponentiation (for a warmup, return as a match the logarithm in base 2 of a power of 2 ‚Äì bonus, do the same for any number, rounding it however you like), or factorial numbers (for a warmup, match [primorial numbers](https://oeis.org/A002110)).
> 
> 
>
7. > 
>  Match abundant numbers (if you're as crazy as I am)
> 
> 
>
8. > 
>  Calculate an irrational number to requested precision (e.g. divide the input by the square root of 2, returning the rounded result as a match)
> 
> 
>
(The [regex engine I wrote](https://github.com/Davidebyzero/RegexMathEngine) may be of help, as it is very fast at unary math regexes and includes a unary numerical mode which can test ranges of natural numbers (but also has a strings mode which can evaluate non-unary regexes, or unary with delimiters). By default it is ECMAScript compatible, but has optional extensions (which can selectively add subsets of PCRE, or even molecular lookahead, something that no other regex engine has).)
Otherwise, read on, and also read [this GitHub Gist](https://gist.github.com/Davidebyzero/9090628) (warning, many spoilers) which chronicles the journey of pushing ECMAScript regex to tackle natural number functions of increasing difficulty (starting with teukon's set of puzzles, not all of them mathematical, which sparked this journey).
As with the other regex solutions to this problem, the input is given as two numbers in bijective unary, separated by a comma, representing an inclusive range. Only one number is returned. The regex could be modified to return all of the numbers that share the same smallest largest prime factor, as separate matches, but that would require variable-length lookbehind and either putting `\K` in a lookahead or returning the result as a capture instead of a match.
The technique used here of repeated implicit division by smallest prime factor is identical to that used in the [Match strings whose length is a fourth power](https://codegolf.stackexchange.com/a/21951/17216) answer I posted a while back.
With no further ado:
```
((.+).*),(?!.*(?=\1)((?=(..+)(\4+$))\5)*(?!\2)).*(?=\1)\K(?3)*\2$
```
[Try it online!](https://tio.run/##RZDfasIwFMbv@xSxBHOOpjWpdn@MtZU5GIy5G@8WKduoIHTqWgcO6S73AHvEvUiXRmU3@c73nV8@QrZZkYf12yehhSKHfPP6nBPaU8ZGo@lkPhlXznJTEKBlJNRorJAcHEKSPCq3@WoHjDNefryUuwJoyj3JJWbvrl678X8qTI5DmqIyN7fFar0DUxc31NB10U/yJ7HwTVMzSTOR3@8fwiy@WgIA27O9hdBSZy8XiNFXjxY9PNjaxDPMKLJou510jYyticGKZ4FTiV17x9w872QboMryMjs2stkjeZjMb@5aTFXmC6Sq0vR2Nk3TGsDvot9BDnHL70AcaYlgBHyTgx50KaIO0WxaOkA8I/oe4j52dEDrOuRSONdchs1x4cjwkgeDKycQQvJAyP4f "Perl 5 ‚Äì Try It Online") - Perl  
[Try it online!](https://tio.run/##XVBfa9swEH/3p3CEIXepolhO3Db1jBnrxsLaDta@VUG4rhKb2Y6QNSiUve4D7CPui2TnQF/6cjp@/@50trbHD4WtbRi5nC2YsM7stTO2LSsD04WYFVrXZet1dehs0xqnQGGmfiyGKZ9O@Y4gvTcj3XvT@wG0/rK5@aw1comCErOg6Rs9GA/MVs6Ip7L66R0V3TZd4xlnq2S9Wp9fJOuUYRbsDg6iIY@zqM13lDzA/cP15g4zAiW@BmHY7CBqHwfvWtNTh3O5zXOmeoZkGX49EUMwj/lcYhYSZl5se3g2QLM46TPKMFV9oDHFaLtiDAUlxltBirGT1IX//vwNmYDTQbrSVzVEjlP2eB1TepD85MGT6T0ut8ijDou3LbtRecXuvoe3Hx8@fZ3QT3@/OyxgdgQQZyhmyKGYiBkUuZII9IAgHNTqLEJUKRIzUQnim0R9g2KJM5VEx2PKZRysuUzHch7I9IInq8sgiWPJk1gu/wM "PHP ‚Äì Try It Online") - PCRE  
[Try it on regex101](https://regex101.com/r/BmJzgw/2)
And the free-spacing version, with comments:
```
                        # 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 call (?3) - defines one loop iteration, and needs to be called as (?3)*
  # Finds the largest prime factor of tail, and leaves it in tail. It will both be
  # evaluated here as-is, and later as a subroutine call. Here, it's followed by an
  # assertion that tail is less than something; if this fails to match, the regex
  # engine will try to backtrack, but that will never result in a match because
  # backtracking will only make tail larger.
  (                     # Repeatedly divide tail by its smallest prime factor, leaving
                        # only the largest prime factor at the end.
    (?=(..+)(\4+$))     # \5 = tool to make tail = \4 = largest nontrivial factor of
                        # current tail, which is implicitly the result of dividing it
                        # by its smallest prime factor.
    \5                  # tail = \4
  )*
  (?!\2)                # matches iff tail < \ 2
)
# At this point, \2 is guaranteed to be less than or equal to the smallest number in the
# set containing the largest prime factor of each of the numbers in the inputted range.
# The first time the regex engine reaches this point, \2 will be equal to the smallest
# number in that set, but if it backtracks, \2 will become smaller.
# 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. If this fails to match, the
                        # regex engine will try to backtrack, but that will never result
                        # in a match, because backtracking makes tail a composite number
                        # that is larger than the largest prime factor of the currently
                        # marked return value, which makes it larger than any value \2
                        # can have.
```
Note that `((.+).*)` can be changed to `((.+)+)`, dropping the size by 1 byte (from 65 to **64 bytes**) with no loss of correct functionality ‚Äì but the regex exponentially explodes in üêå slowness:
```
((.+)+),(?!.*(?=\1)((?=(..+)(\4+$))\5)*(?!\2)).*(?=\1)\K(?3)*\2$
```
[Try it online!](https://tio.run/##RZDfSsMwFMbv9xRZCcs5a9o10wou65/hBEGcN7szo6h0UIjbbCtMRr30AXxEX6Sm2YY3@c73nV8@QnZ5qcP27ZPQUpKD3r4@a0JH0thoOp8tZ3HTW29LArSKAjmNJZJDj5BUR9VOFzUwznj18VLVJdCMe4ILzN8dtXGS/zQwOU5ohtLc3JXFpgZTl3TUxHHQT/VTsPJNUzcJM5Hf7x/CLF6sAYDt2d5CaKmzFyvE6GtEyxEebG3qGWYaWXQwSF0jsTUJWPEscCqxa@@Ym@edbAc0ua7yYyNbPJKH2fLmrs9kY75AyCbLbhfzLGsBfBdd5JD0/SEkkRIIRsA3MahLlyKqEM2mr8aIZ0TdQ3KBQzWmbRtyEfSuuQi74@oP "Perl 5 ‚Äì Try It Online") - Perl  
[Try it online!](https://tio.run/##XVDNSsNAEL73KdIl0Jl23XZrq9QYgviDxT9Qb25ZYtw2wSRdNisI4tUH8BF9kTop9NLL7PD9zezY3G5OE5vbIHQxGzJhnVlpZ2yZZgZ6Q9FPtM7T0utsXdmiNE6Bwkg9Dpse7/X4kiC9Mi1de1P7BrS@mt9eao1coqDEqFPUhW6MB2YzZ8Rrmr17R0WXRVV4xtlkPJvMjo7HsynDqLNcOwibeBSFZbyk5Aaeni/m9xgRKPGrEwTFEsLypfGuNDV1eCAXccxUzZAszccrMQTzET@QGAWEmU9brt8M0CxO@ogyTJavaUzS2k4YQ0GJo4UgRdtJ6oK/n9@ACdgepEp9lkPoOGW31zGpB8m3Htya9nG5QB5WmOy2rFrlCbt/CO7Ons@vu/TT773DAkYbADHAAXJIuqIPSawkAj0gCAY1GYSIaorEdNUYcSdRN5AcYl@Nw81myuWoM@Ny2pajfw "PHP ‚Äì Try It Online") - PCRE
# Regex (ECMAScript), 80 (79üêå) bytes
The algorithm can be easily ported to ECMAScript by replacing the subroutine call with a copy of the subroutine, and returning the match as capture group `\6` instead of using `\K`. The result is **80 bytes** in length:
```
((x+)x*),(?!.*(?=\1)((?=(xx+)(\4+$))\5)*(?!\2)).*(?=\1)(((?=(xx+)(\8+$))\9)*\2$)
```
[Try it online!](https://tio.run/##TU/dTsIwFL7fU2yGZOeMObcJCDaVGGOiF2Ki3jEvKnSj2pWlKzoRbn0AH9EXwaoYvDk9/X5Ovu@RPbN6okVl9utKTLku5@qJv240VfzFveHFeVMBLOnJQbABaNrYBBjC0IsCGNIsQbAPNBaHrNNuIWZdtIyXpYg7yU7T/9EMMMjSFm6CgyVGZn5rtFAFYFRLMeHQC/c7iCSfa8hpQkBSzdlUCsUB0aNqISXJaYxvIgcvx8qaDSBx7BcKKqO6ksKAH/o2guSqMDOPpquVqEdsBIxWTNf80lqKcXyP@Ec8/CcSS@BbtTC10bB3qZ6ZFFNXKIsc7yHZEhLJZK6MUAtO1k5JwW/8SPOKMwMM2zZB@x/yYOOUzExmoG3Y3YntVtKfZkPf/Xz/cEfX7tXp3dmF5x//Aj4S26/8rY9/nnHvflsRyXrTDZPYGYRJ93v0nKR7FKadvpPGcRKmcXL4BQ "JavaScript (SpiderMonkey) ‚Äì Try It Online") - **80 byte** version  
[Try it online!](https://tio.run/##TU9LTsMwEN3nFEmFlJkmhCQ0hWKZCiEkWFAkYEdYmNZJDY4TOS4UClsOwBG5SDGlqN2Mx@8zeu@RPbN2rEVjdttGTLiuavXEX5eaKv7iXvPybN4AvNHjve4SYB5ggCEMvagLQ5onCPaBuYUh7wU7iHmGlvHyFHEj2WgOV5oBdvN0B5fdvTeMTH1jtFAlYNRKMebQD3d7iKSoNRQ0ISCp5mwiheKA6FE1k5IUNMaFKMArsLFmA0gc@4WSyqhtpDDgh76NILkqzdSj6fu7aEdsBIw2TLf8wlrKu/ge8Z942CYSS@CimZnWaOhcqGcmxcQVyiJHHSRrQiIZ18oINePkw6ko@HM/0rzhzADDwCYItpAHG6diZjwFbcNuTqy3iq6aDX33@/PLHV25lye3p@eef/QH@Ehsv@qvPv577vr364pIPpZZmMTOIEyy39F3kuwgTHuHThrHSZjGyf4P "JavaScript (SpiderMonkey) ‚Äì Try It Online") - **79 byte** exponential-slowdown üêå version (amazingly, this can handle all the test cases in 49 seconds)
[Answer]
# 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
```
Finds the smoothness of the the numbers by trial division until the number is 1. `i` stores the smallest smoothness so far, `j` stores the number that gave that smoothness.
Thanks to @xnor for the golfs.
[Answer]
## Mathematica, ~~61~~ ~~45~~ 39 characters
```
Range@##~MinimalBy~Last@*FactorInteger&
```
Very straightforward implementation of the spec as an unnamed function.
* Get the range (inclusive).
* Factor all integers.
* Find the minimum, sorted by largest prime factor.
[Answer]
## J, ~~22 20~~ 19 chars
```
({.@/:{:@q:)@(}.i.)
```
E.g.
```
   2001 ({.@/: {:@q:)@(}. i.) 2014
2002
```
(Functions taking two arguments are infix in J.)
[Answer]
# Haskell, ~~96~~ ~~94~~ ~~93~~ ~~86~~ 80 characters
```
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]
```
usage via GHCi (a Haskell shell):
```
>5 # 9
8
>9 # 15
9
```
**EDIT:** now a much simpler algorithm.
this solution includes both numbers in the range (so `8 # 9` and `7 # 8` are both 8)
explanation:
the (%) function takes two parameters, x and y. when y is 2, the function returns the smoothness of x.
the algorithm from here is simple - get the combined list of all smoothnesses of numbers in the input with each smoothness storing a reference to it's original number, sort then to get the smallest, and return it's referenced number.
  
here is an ungolfed javascript version with the same algorithm:
```
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;
}
```
[Answer]
# Lua - 166 chars
*I ~~don't~~didn't have (yet!) enough reputation to comment on [AndoDaan's solution](https://codegolf.stackexchange.com/a/36392/30855), but here are some improvements on his code*
```
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)
```
Changes :
* The `n%d==0` by `n%d<1` which is equivalent in this case
* Removed a space
* Replaced `table.insert(f,d)` by `f[#f+1]=d` (`#f` is the number of elements of f)
[Answer]
# Bash+coreutils, 56 bytes
```
seq $@|factor|sed 's/:.* / /'|sort -nk2|sed '1s/ .*//;q'
```
Input is from from exactly two command-line arguments (Thanks @nyuszika7h !!!). Output is a singular result printed to STDOUT.
* `seq` provides the range of numbers, one per line, from the command-line arguments.
* `factor` reads those numbers and outputs each number followed by a colon and the sorted list of prime factors of that number. So the largest prime factor is at the end of each line.
* The first `sed` removes the colon and all but the last/largest prime factor, so leaves a list of each number (column 1) and its largest prime factor (column 2).
* `sort` numerically in increasing order by the column 2.
* The final `sed` matches line 1 (number whose largest prime factor is the smallest in the list), removes everything including and after the first space, then quits. `sed` automatically prints the result of this substitution before quitting.
### Output:
```
$ ./smooth.sh 9 15
12
$ ./smooth.sh 9 16
16
$ ./smooth.sh 157 249
162
$ ./smooth.sh 2001 2014
2002
$ 
```
Note ranges in this context are *inclusive* of both endpoints.
[Answer]
# 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)
```
Thinking about another golf gave me an idea for a new algorithm to check smoothness, hence the late answer. 
The prime factorization of the factorial `i!` includes exactly the primes at most `i`. So, if `n` is a product of distinct primes, its smoothness (largest prime factor) is the smallest `i` for which `n` is a divisor of `i!`. To account for repeated prime factors in `n`, we can instead use a sufficiently high power of `i!`. In particular, `(i!)**n` suffices.
The code tries increasing factorials `F=i!`, updated recursively. We filter for the divisors of `F` in the input range, and output them if there are any, and otherwise move on to `(i+1)!`.
Test case:
```
>> f([157, 249])
[162, 192, 216, 243]
```
[Answer]
## C, ~~149~~  95
**Edited answer:**
I cannot claim credit for this solution. This updated answer borrows the beautiful method used by *isaacg* in his Python solution. I wanted to see if it was possible to write it in C as a nested `for`/`while` loop with no curly braces, and it is!
```
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;}
```
**Explanation:**
* Function `R(a,b,n,q,p,m)` scans the range `a` to `b-1` and returns the first smoothest number found. Invocation requires adherence to the following form: `R(a,b,a,b,2,0)` so that variables inside the function are effectively initialized as follows: `n=a;q=b;p=2;m=0;`.
---
**Original answer**:
This was my original answer...
```
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;}
```
**Explanation:**
* Function `P(n,f,p)` tests value `n` for primality and returns true (nonzero) if `n` is prime or false (zero) if `n` is non-prime. `f` and `p` must both be passed as 1.
* Function `G(n,f)` returns the greatest prime factor of `n`. `f` must be passed as `n`.
* Function `R(a,b,p,n)` scans the range `a` to `b-1` and returns the first smoothest number found. `p` must be passed as 1. `n` can be any value.
**Test driver:**
```
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);}
```
**Output:**
```
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
```
[Answer]
# Haskell - 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)
```
Example usage:
```
> 5 ! 10
8
> 9 ! 15
9
> 9 ! 16
16
> 157 ! 248
162
> 2001 ! 2013
2002
```
[Answer]
## Q, 91 characters K, 78 characters
```
{(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 would probably shave a dozen characters
edit:
indeed, treating the upper bound as non inclusive this time
```
{*:x+{&:x=min x}{*:-2#{6h$x%2+*:&:x={y*6h$x%y}[x]'[2_!x]}\[{x>0};x]}'[(x)_!y]}
```
[Answer]
# Note: This answer is not allowable.
This answer uses multiple features of Pyth added after the challenge was asked.
I added another new feature, calling unary range on a 2 element tuple, which shortens the solution by two characters, to this:
# [Pyth](https://github.com/isaacg1), 7
```
hoePNUQ
```
Input is now taken comma separated. The rest is the same.
---
This answer uses a feature of Pyth that was added after this question was asked, specifically after seeing @aditsu's wonderful CJam solution. That being said, I wanted to demonstrate what adding that feature has made possible. The feature is `P`, which is an arity-1 function which on integer input returns a list of all prime factors of the input, sorted smallest to largest.
# [Pyth](https://github.com/isaacg1), 9
```
hoePNrQvw
```
Uses Python-style ranges, newline separated on STDIN. Outputs smallest solution to STDOUT.
**Explanation:**
```
      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.
```
**Tests:**
```
$ 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
```
[Answer]
# Lua - 176 characters
```
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)
```
I really should stop golfing in Lua. There's no point.
[Answer]
## Clojure - 173 170 chars
I'm a Clojure newbie. Golfed:
```
(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))))
```
Sample runs:
Ranges include low-end, exclude high-end: [a,b)
Only prints one of the smoothest numbers, if multiple occur.
```
(println (s 5 11))
(println (s 9 16))
(println (s 9 17))
(println (s 157, 249))
(println (s 2001, 2014))
```
yields:
```
bash$ java -jar clojure-1.6.0.jar range.clj
8
9
16
192
2002
```
Ungolfed:
```
(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))))
```
[Answer]
# Ruby, ~~65~~ 62
```
require'prime'
s=->a,b{(a..b).min_by{|x|x.prime_division[-1]}}
```
With apologies to <https://codegolf.stackexchange.com/a/36484/6828>, this is the golfed (and slightly simplified) version of that. Uses an inclusive range since it's a character shorter.
```
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 
```
And thanks to YenTheFirst for saving three characters.
[Answer]
## 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;}}
```
Ungolfed:
```
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;
  }
}
```
It takes in the start and the length from the command line and will return the largest smooth number.
I used answers from [here](https://stackoverflow.com/a/2736385/1492861) and [here](https://stackoverflow.com/a/5873129/1492861) to make my answer.
Thanks to VisualMelon for tweaking it and shaving 12 bytes off! I also got rid of the braces in the if saving 2 bytes, and CodeInChaos pointed out some obvious stuff I missed (thanks again).
[Answer]
## R, 83
```
library(gmp)
n=a:b
n[which.min(lapply(lapply(lapply(n,factorize),max),as.numeric))]
```
where the bottom of the input range is assigned to `a` and the top (inclusive) is assigned to `b`.
`gmp` is a package that is available on CRAN. It felt dirty until I saw that absurd `mf` function in CJam. Install by typing `install.packages("gmp")` in the console.
[Answer]
## PowerShell - 85
```
($args[0]..$args[1]|sort{$d=2
while($_-gt1){while(!($_%$d)){$m=$d;$_/=$d}$d++}$m})[0]
```
This will sort a range of numbers (inclusive) based on each number's max prime factor. It returns the lowest sorted element.
```
> smooth 5 10
8
> smooth 9 15
12
> smooth 9 16
16
> smooth 157 248
243
> smooth 2001 2013
2002
```
[Answer]
# J - 16 char
Using the (*start*, *length*) style of range, as allowed by the comments.
```
(0{+/:{:@q:@+)i.
```
To be used as a dyadic verb: left argument is *start*, right is *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
```
A (*start*, *end*) solution is +2 chars, and excludes the end; including the end is +2 more. But on the bright side, it looks rather nice since we match up all the {braces}.
```
(0{}./:{:@q:@}.)i.    NB. excluding
(0{}./:{:@q:@}.)1+i.  NB. including
```
[Answer]
## Seriously, 8\*14/7 = 16 (non-competitive)
```
,x;`yM`M;m@√≠@E
```
Seriously was created after this challenge, but I wanted to post this answer because it exemplifies the type of challenges Seriously is good at.
[Try it online!](http://seriously.tryitonline.net/#code=LHg7YHlNYE07bUDDrUBF&input=NSwxMQ)
Explanation:
```
,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
```
[Answer]
# [Pyth](https://pyth.readthedocs.io), 7 bytes
```
.mePbrF
```
[Try it here!](https://pyth.herokuapp.com/?code=.mePbrF&input=9%2C+16&debug=0)
Outputs all smooth integers in the range \$[a, b)\$. For the smooth integers in \$[a, b]\$, just use `}` in place of `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.
```
[Answer]
# [Whispers v2](https://github.com/cairdcoinheringaahing/Whispers), 183 bytes
```
> Input
> Input
>> 1‚Ä¶2
>> ‚à§L
>> L‚Äô
>> Each 4 3
>> Select‚àß 5 L
>> Each 7 6
>> L‚Åø10
> -1
>> Each 9 8
>> L‚ÄñR
>> Each 12 11 3
>> 13·¥∫
>> Each 9 14
> 0
>> 15‚Åø16
>> Output 17
```
[Try it online!](https://tio.run/##K8/ILC5ILSo2@v/fTsEzr6C0hAtO2ykYPmpYZgRiPOpY4gOifR41zATRronJGQomCsYgdnBqTmpyyaOO5QqmCj5wSXMFM4iGxv2GBkAzdQ3hUpYKFlCzpgXBBQ2NFAwNIQYaGj/csgtJtaEJUL8BWMYUZBzYYP/SEqAjFQzN//83NDXnMjKxAAA "Whispers v2 ‚Äì Try It Online")
Aside from revamping the algorithm, the only real golfing opportunity can be found on lines **9** and **10**, but swapping them. When they're the other way round, the code is [1 byte longer](https://tio.run/##K8/ILC5ILSo2@v/fTsEzr6C0hAtO2ykYPmpYZgRiPOpY4gOifR41zATRronJGQomCsYgdnBqTmpyyaOO5QqmCj5wSXMFM6BJuoYQXY37LeEyhgYKFlCzpgUhRI0UDA0hBhoaP9yyC1m5oQnQKAOwlCnQKEMzENO/tAToSgVD8///DU3NuYxMLAA), due to the repeated use of `9` or `10`.
The structure tree for this program is:
[![tree](https://i.stack.imgur.com/Y6FuS.png)](https://i.stack.imgur.com/Y6FuS.png)
Red represents nilad lines, green represents function arguments. Arrows from \$a \to b\$ show the use of line \$a\$ as an argument for line \$b\$.
## How it works.
We start at lines **1**, **2** and **3**. The first two simply take and store the inputs \$\alpha\$ and \$\beta\$ on lines **1** and **2** respectively. There two values are then passed to line **3**, `1‚Ä¶2`, which form the range 
$$R := [\alpha, \alpha+1, ..., \beta-1, \beta]$$
As you can see from the tree above, \$R\$ is used in two places: line **6** and line **13**. As line **6** eventually leads to line **13**, we'll take the path down **6**.
Line **6** is an `Each` statement, that maps a function (the first line reference) over an array (the second line reference). Here, the function is defined on line **4** as \$f(x) = \{i \: | \: (i | x), (i \le x), i \in \mathbb{N}\}\$ i.e. the array of \$x\$'s divisors. The array is \$R\$, so line **6** iterates over \$R\$, returning the divisors of each integer, forming a new array
$$D := [f(\alpha), f(\alpha+1), ..., f(\beta-1), f(\beta)]$$
We then get more complicated as we skip down to line **8**. Line **8** is also an `Each` statement, but its function argument, line **7** is split over two lines, **7** and **5**:
```
>> L‚Äô
>> Select‚àß 5 L
```
Mathematically, this is the function \$g(A) = \{i \: | \: (i \in \mathbb{P}), (i \in A)\}\$, that takes a set \$A\$ and returns all the primes in \$A\$. Line **8** is iterating over \$D\$, essentially filtering all composite numbers from each subarray in \$D\$, to form
$$A := [g(f(\alpha)), g(f(\alpha+1)), ..., g(f(\beta-1)), g(f(\beta))]$$
Then, we encounter yet another `Each` statement on line **11**, which iterates line **9** over \$A\$. Line **9** takes an array and returns the final element of that array. As \$g(A)\$ returns the array sorted, this is equivalent to return the largest value in that array. At this point, we remember that \$g(f(x))\$ returns the list of prime factors of \$x\$, so line **9** maps each \$x\$ to its largest prime factor, returning
$$B := [\max(g(f(\alpha))), \max(g(f(\alpha+1))), ..., \max(g(f(\beta-1))), \max(g(f(\beta)))]$$
Once we have \$B\$, we now have an array we can sort \$R\$ by, e.g. we sort each value \$x\$ in \$R\$ by the resulting value of \$\max(g(f(x)))\$. However, we do not have a sort-by command in Whispers, only the simple Python `sort(list)`. Luckily, due to how `sort` sorts lists of lists, we can concatenate each \$x\$ with \$\max(g(f(x))\$ and sort by the first element, what Python does naturally.
Lines **12** and **13** perform this concatenation, by iterating a concatenate function (line **12**) over \$B\$ and \$R\$. This forms an array of pairs of numbers, in the form \$[\max(g(f(x))), x]\$. Next, we sort this array on line **14**, which, due to the way Python compares lists, places the numbers with the lowest largest prime factor towards the end.
Almost finished. The only things left to do are to extract \$R\$, sorted by \$B\$ (we'll call this array \$R\_B\$. This is done simply by taking the last element of each subarray (line **9** already does this for us, so we simply need `Each 9 14` on line **15**, rather than defining a new function). Once that's done, we simply take the first element in \$R\_B\$, which will be (one of) the number with the lowest largest prime factor i.e. the smoothest number.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 5 bytes
```
‚ü¶‚ÇÉ·∏ã·µíh
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/qG3Do6bGh1snlP9/NH/Zo6bmhzu6H26dlPH/f3S0qY6hYaxOtKWOoRmEMgdShqbmOkYmlkCWkYGBoY6RgaFJbCwA "Brachylog ‚Äì Try It Online")
Takes input as a list of two (or more, actually) values in no particular order, and outputs a single value through the output variable of the predicate (if you try to run it as a full program, it'll just print `true.` at you, unless you stick a `w` on the end). The input is interpreted as a Python-style range because to feed `‚ü¶` multiple values I need to give it a subscript no matter whether it's `‚ÇÇ`, `‚ÇÉ`, or `‚ÇÑ` so I may as well choose the one that matches the test cases.
```
    h The first item of
‚ü¶‚ÇÉ    the range represented by the input
   ·µí  after it's been sorted by
  ·∏ã   prime factorization.
```
Saves three bytes over the more obvious `‚ü¶‚ÇÉ{·∏ãh}·µíh` by taking advantage of that Brachylog sorts its lists by elements first rather than lengths, such that the first step of sorting by prime factorizations is sorting by largest prime factors.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 5 bytes = 5.71 characters
```
‚óÑo‚ñ≤p‚Ä¶
```
[Try it online!](https://tio.run/##yygtzv6f@6ip8f@j6S35j6ZtKnjUsOz////R0aY6hgaxOtGWOoamEMoMSBmamusYmVgAWUYGBoY6RgaGxrGxAA "Husk ‚Äì Try It Online")
**How?**
```
‚óÑ       # element that minimizes result of
 o      # combining these 2 functions:
  ‚ñ≤     # maximum of
   p    # prime factors
    ‚Ä¶   # for the range from arg 1 ... arg 2
```
[Answer]
# Cobra - 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
```
Not even sure why I bothered, cobra just can't compete here.
[Answer]
# Ruby - 113 chars
Using the stdlib. Returns one result. Tested on 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
```
[Answer]
## Perl (5.10+), 83
```
for(<>..<>){$n=$_;$p=2;$_%$p&&$p++or$_/=$p while$_>1;$m=$p,$r=$n if$p<$m||!$m}
say$r
```
(linebreak can be removed). Takes two endpoints of an inclusive range on two lines of stdin (because `<>` is cheaper than accessing `ARGV`) and outputs the smoothest to stdout. If there's a tie for smoothest, prints the smallest. Could print the biggest at the cost of one character.
The algorithm is basically isaacg's way of finding the greatest prime factor, although we came up with it independently. That part golfs down beautifully to a single statement in perl, the rest has more overhead than I'd like though.
Should be run under `perl -E` or with a `use 5.012` preamble. If you can't do that, replace `say$r` with `print$r,$/`.
[Answer]
# Python 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's solution](https://codegolf.stackexchange.com/a/36391/20260), but with a `min` by function key in place of explicit min-finding, and a recursive function playing the role of the iteration.
Run in [Stackless Python](http://www.stackless.com/) to avoid recursion limits.
It looks wasteful to use the paranthesized condition `(n%p<1)`, then repeat its negation also in parantheses `(n%p>0)`, but that was the best I got. I tried things a bunch of things, but they turned out worse.
```
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])
```
I welcome any improvements you can think of.
]