Tìm số mượt nhất


59

Thử thách của bạn là tìm ra con số mượt mà nhất trong một phạm vi nhất định. Nói cách khác, tìm số có hệ số nguyên tố lớn nhất là nhỏ nhất.

Một số mịn là một số có hệ số nguyên tố lớn nhất là nhỏ. Các số loại này hữu ích cho thuật toán biến đổi Fourier nhanh, phân tích mật mã và các ứng dụng khác.

Chẳng hạn, trong phạm vi 5, 6, 7, 8, 9, 10, 8 là số mịn nhất, bởi vì hệ số nguyên tố lớn nhất của 8 là 2, trong khi tất cả các số khác có hệ số nguyên tố là 3 hoặc lớn hơn.

Đầu vào: Đầu vào sẽ là hai số nguyên dương, xác định một phạm vi. Số nguyên tối thiểu cho phép trong phạm vi là 2. Bạn có thể chọn xem phạm vi đó có bao gồm, độc quyền, bán độc quyền hay không, miễn là phạm vi tùy ý có thể được chỉ định trong giới hạn ngôn ngữ của bạn. Bạn có thể lấy số thông qua đầu vào hàm, stdin, đối số dòng lệnh hoặc bất kỳ phương thức tương đương nào cho ngôn ngữ của bạn. Không mã hóa thông tin thêm trong đầu vào.

Đầu ra: Trả về, in hoặc tương đương một hoặc nhiều số nguyên trong phạm vi đầu vào mượt mà tối đa (hệ số lớn nhất tối thiểu). Trả về nhiều kết quả là tùy chọn, nhưng nếu bạn chọn làm như vậy thì kết quả phải được phân tách rõ ràng. Định dạng đầu ra gốc là tốt cho nhiều kết quả.

Vui lòng nêu trong câu trả lời của bạn về cách bạn lấy đầu vào và đưa ra đầu ra.

Chấm điểm: Mã golf. Đếm theo các ký tự nếu được viết bằng ASCII hoặc 8 * byte / 7 nếu không phải bằng ASCII.

Các trường hợp thử nghiệm:

Lưu ý: Đây là các phạm vi kiểu Python, bao gồm cấp thấp nhưng không phải cấp cao. Thay đổi khi thích hợp với chương trình của bạn. Chỉ có một kết quả là cần thiết.

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

Các phạm vi được chỉ định là (bắt đầu, độ dài) thay vì (bắt đầu, kết thúc) có được chấp nhận không?
CodeInChaos

1
@CodesInChaos Chắc chắn. Nó được bảo vệ theo điều khoản "hoặc bất cứ điều gì".
isaacg

3
Tôi không thấy vấn đề trong việc xử phạt các câu trả lời không phải của ASCII. Sẽ đơn giản hơn khi chỉ đếm byte trong mọi trường hợp.
nyuszika7h

1
@ nyuszika7h Ascii nhỏ hơn đáng kể so với một byte - nó chỉ sử dụng 7 bit. Do đó, tôi biểu thị một ký tự bằng 7 bit và chia tỷ lệ các ngôn ngữ khác tương ứng. Tuy nhiên, nếu ngôn ngữ không phải là ASCII nhưng có thể đóng gói tất cả các ký tự của nó thành 7 bit, tôi sẽ không áp dụng phụ phí. Xem J / K so với APL. tl; dr Bytes đơn giản hơn, nhưng cung cấp cho APL et. al. một lợi thế tinh tế nhưng không công bằng.
isaacg

3
@isaacg bạn đang khuyến khích việc tạo ngôn ngữ giả bằng các bộ ký tự nhỏ hơn. nếu chúng tôi chấm điểm các bộ ký tự 7 bit khác với các bộ ký tự 8 bit, ai đó có thể đóng gói hầu hết các ngôn ngữ hiện đại thành 6 bit (64 ký tự giúp chúng tôi AZ, 0-9, một số khoảng trắng, 20 dấu chấm câu và một số ít để dự phòng) .
Sparr

Câu trả lời:


99

CJam - 13

q~,>{mfW=}$0=

Dùng thử tại http://cjam.aditsu.net/

Ví dụ đầu vào: 2001 2014
Đầu ra ví dụ:2002

Giải trình:

q~đọc và đánh giá đầu vào, đẩy 2 số trên ngăn xếp (giả sử min và max)
,tạo ra một mảng [0 1 ... max-1]
>cắt mảng bắt đầu từ min, dẫn đến [min ... max-1]
{…}$sắp xếp mảng bằng cách sử dụng khối để tính toán khóa sắp xếp
mflấy một mảng với tất cả các thừa số nguyên tố của một số, để
W=lấy phần tử cuối cùng của mảng (W = -1), do đó có được hệ số nguyên tố lớn nhất được sử dụng làm a khóa sắp xếp
0=lấy phần tử đầu tiên của mảng (được sắp xếp)


38
Chà, tôi đoán là vậy.
Eric Tressler

5
Tôi cần thêm một hàm nhân tố vào pyth.
isaacg

6
Ngôn ngữ này là phù thủy.
Brobin

8
Điều này gần giống như chỉ cần kéo một số HQ9 + s ** t như có thể mà không trở thành một lỗ hổng. Tuyệt vời!
Ingo Bürk

25
༼ fant ノmfWai đó đã giải quyết nó trong 13 ký tự.
teh internets được làm bằng catz

66

Regex ( hương vị .NET PCRE), 183 129 byte

Đừng thử điều này ở nhà!

Đây không thực sự là một ứng cử viên cho chiến thắng. Nhưng Eric Tressler đề nghị giải quyết vấn đề này không có gì ngoài một bản regex và tôi không thể cưỡng lại được. Đây có thể là có thể trong PCRE cũng (và thậm chí ngắn hơn, xem dưới đây), nhưng tôi đã chọn .NET bởi vì giải pháp của tôi cần lookbehinds tùy ý dài. Ở đây chúng tôi đi:

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

Đầu vào được mã hóa dưới dạng phạm vi được phân tách bằng dấu phẩy, trong đó cả hai số được đưa ra trong ký hiệu đơn nhất sử dụng 1s. Trận đấu sẽ là các Ssố 1 ​​trong đó số Slà số mịn nhất trong phạm vi. Ties bị phá vỡ có lợi cho số lượng nhỏ nhất.

Vì vậy, ví dụ thứ hai từ câu hỏi sẽ là chuỗi sau (khớp với gạch chân)

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

Nó dựa trên biểu thức kiểm tra chính (hiện tại khá nổi tiếng) , các biến thể của chúng được nhúng trong đó một con số khổng lồ 6 lần.

Đây là một phiên bản sử dụng khoảng cách và bình luận miễn phí cho những ai muốn biết chuyện gì đang xảy ra.

# 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

Bạn có thể kiểm tra nó trực tuyến ở đây . Đừng thử đầu vào quá lớn, tôi không đảm bảo về hiệu suất của con quái vật này.

Biên tập:

Cuối cùng tôi đã chuyển cái này sang PCRE (chỉ cần hai bước) và rút ngắn regex gần một phần ba. Đây là phiên bản mới:

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

Điều này về cơ bản là giống nhau, với hai thay đổi:

  • PCRE không hỗ trợ giao diện có độ dài tùy ý (mà tôi đã sử dụng để đưa MINvào nhóm 1). Tuy nhiên, PCREkhông hỗ trợ \Kmà đặt lại bắt đầu của trận đấu với vị trí con trỏ hiện tại. Do đó (?<=^(1+),.*)trở thành ^(1+),.*?\K, mà đã lưu hai byte.
  • Các khoản tiết kiệm thực sự đến từ tính năng đệ quy của PCRE. Tôi thực sự không sử dụng đệ quy, nhưng bạn có thể sử dụng (?n)để khớp nhóm nmột lần nữa, tương tự như một cuộc gọi chương trình con. Vì regex ban đầu chứa mã để tìm số nguyên tố lớn nhất của một số hai lần, tôi có thể thay thế toàn bộ phần lớn của số thứ hai bằng một đơn giản (?2).

37
Mẹ thánh của chúa
Newb

1
@Timwi Tôi cần kiểm tra xem yếu tố nguyên tố lớn nhất (nhóm 3hay 7) có thực sự là số nguyên tố không. Điều này đòi hỏi phải có một bản sao khác của yếu tố sau lần đầu tiên nắm bắt nó, điều này sẽ không xảy ra đối với các số nguyên tố. Trong khi tôi xử lý vấn đề đó bằng .NET bằng cách đặt một cái nhìn ở đâu đó để tôi có thể quay lại một chút để kiểm tra, điều này sẽ không thể thực hiện được trong phiên bản PCRE ngắn hơn do không có giao diện có độ dài thay đổi. Nó có lẽ có thể rút ngắn mà chút, nhưng tôi không nghĩ rằng chỉ cần thay đổi +để *công trình.
Martin Ender

2
@MartinEnder Xin chào! Tôi tưởng tượng bạn đã vượt qua thử thách này từ lâu, nhưng tôi chỉ lướt qua, thấy một giải pháp regex và không thể không bỏ qua cảnh báo của bạn ở đầu bài này :) Tôi cảm thấy khó khăn khi đánh golf mã của người khác, Vì vậy, sau khi nhìn vào regex của bạn và bị lẫn lộn, tôi đã thử nó từ đầu và nghĩ ra điều này: (.*),.*?\K(?=(..+)((?=((?(R)\6|\2))*$).*(?=\4$)(?!(..+)\5+$)))(?!.+(?=\1)(?=(..+)(?3)).*(?!\2)\6).+ 99 byte trong PCRE. Ngoài ra, tôi đã bắt gặp rất nhiều công việc của bạn trên trang web này và tôi là một fan hâm mộ lớn: D Mong chờ một trận chiến regex trong tương lai!
jaytea

1
Tôi đã chơi golf code với nhận xét đó vì vậy tôi sẽ chỉ đưa phần phụ lục vào đây: bạn có thể loại bỏ 4b bằng cách lấy \4$ra khỏi cái nhìn và dán nó sau cái nhìn tiêu cực, nhưng điều này ảnh hưởng nghiêm trọng đến hiệu suất (mọi nhóm chữ số <= \ 4 được kiểm tra tính đồng bộ thay vì chỉ \ 4) và thất bại ở các đầu vào dài hơn.
jaytea

1
@jaytea Xin lỗi vì đã mất mãi mãi để quay lại với bạn về điều này. Vì bạn đã viết điều đó từ đầu, tôi nghĩ bạn nên đăng một câu trả lời riêng. Đó là một điểm số tuyệt vời và bạn xứng đáng nhận được tín dụng cho nó. :)
Martin Ender

16

Regex (hương vị PCRE), 66 (65🐌) byte

Lấy cảm hứng khi thấy cả Martin Enderjaytea , hai thiên tài regex, đã viết các giải pháp regex cho mã golf này, tôi đã tự viết từ đầu. Regex kiểm tra chính nổi tiếng không xuất hiện bất cứ nơi nào trong giải pháp của tôi.

Đừng đọc nó nếu bạn không muốn một số ma thuật regex đơn phương hư hỏng cho bạn. Nếu bạn muốn tự mình tìm ra phép thuật này, tôi khuyên bạn nên bắt đầu bằng cách giải quyết một số vấn đề trong biểu thức chính của ECMAScript:

  1. Khớp các số nguyên tố (nếu bạn chưa quen với việc này trong regex)
  2. Kết hợp sức mạnh của 2 (nếu bạn chưa làm như vậy). Hoặc chỉ cần làm việc theo cách của bạn thông qua Regex Golf , bao gồm Prime và Powers. Đảm bảo thực hiện cả bộ bài toán Cổ điển và Teukon.
  3. Tìm cách ngắn nhất để khớp với các lũy thừa của N trong đó N là một hằng số (nghĩa là được chỉ định trong biểu thức chính quy, không phải đầu vào) có thể là tổng hợp (nhưng không bắt buộc phải có). Ví dụ, quyền hạn của 6.

  4. Tìm cách khớp các lũy thừa Nth, trong đó N là hằng số> = 2. Ví dụ, phù hợp với hình vuông hoàn hảo. (Đối với khởi động, phù hợp với quyền hạn chính .)

  5. Nối các câu lệnh nhân đúng. Ghép các số tam giác.

  6. Khớp các số Fibonacci (nếu bạn điên như tôi) hoặc nếu bạn muốn bám vào thứ gì đó ngắn hơn, khớp với các tuyên bố lũy thừa chính xác (đối với sự khởi động, trở lại như một logarit trong cơ sở 2 của lũy thừa 2 - phần thưởng, làm tương tự cho bất kỳ số nào, làm tròn số đó theo cách bạn muốn) hoặc số giai thừa (để khởi động, khớp với số nguyên thủy ).

  7. Ghép các số phong phú (nếu bạn điên như tôi)

  8. Tính một số vô tỷ cho độ chính xác được yêu cầu (ví dụ: chia đầu vào cho căn bậc hai của 2, trả về kết quả làm tròn dưới dạng khớp)

(Công cụ regex mà tôi đã viết có thể giúp ích, vì nó rất nhanh trong các biểu thức toán học đơn phương và bao gồm một chế độ số đơn phương có thể kiểm tra phạm vi của các số tự nhiên (nhưng cũng có chế độ chuỗi có thể đánh giá các biểu thức không đơn nhất hoặc đơn phương với các dấu phân cách). Theo mặc định, nó tương thích với ECMAScript, nhưng có các phần mở rộng tùy chọn (có thể thêm một cách chọn lọc các tập hợp con của PCRE, hoặc thậm chí là tìm kiếm phân tử, thứ mà không có công cụ regex nào khác có).)

Mặt khác, hãy đọc và cũng đọc GitHub Gist này (cảnh báo, nhiều kẻ phá hoại) ghi lại hành trình đẩy regex ECMAScript để giải quyết các hàm số tự nhiên tăng độ khó (bắt đầu bằng bộ câu đố của teukon, không phải tất cả đều là toán học, điều này đã gây ra điều này hành trình).

Cũng như các giải pháp regex khác cho vấn đề này, đầu vào được đưa ra dưới dạng hai số trong đơn vị thống kê, được phân tách bằng dấu phẩy, thể hiện phạm vi bao gồm. Chỉ có một số được trả lại. Regex có thể được sửa đổi để trả về tất cả các số có chung một thừa số nguyên tố lớn nhất nhỏ nhất, như các kết quả khớp riêng biệt, nhưng điều đó sẽ yêu cầu giao diện có độ dài thay đổi và đặt \Ktrong một cái nhìn hoặc trả về kết quả dưới dạng bắt thay vì khớp.

Kỹ thuật được sử dụng ở đây của phép chia ẩn lặp đi lặp lại theo thừa số nguyên tố nhỏ nhất giống hệt với kỹ thuật được sử dụng trong chuỗi Kết hợp có độ dài là câu trả lời sức mạnh thứ tư mà tôi đã đăng một lúc trước.

Không có thêm rắc rối: ((.+).*),(?!.*(?=\1)(((?=(..+)(\5+$))\6)*)(?!\2)).*(?=\1)\K(?3)\2$

Bạn có thể thử nó ở đây.

Và phiên bản khoảng cách miễn phí, với các bình luận:

                        # 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.

Thuật toán có thể dễ dàng được chuyển sang ECMAScript bằng cách thay thế lệnh gọi chương trình con bằng một bản sao của chương trình con và trả lại kết quả khớp như một nhóm chụp thay vì sử dụng \ K. Kết quả có độ dài 80 byte:

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

Hãy thử trực tuyến!

Lưu ý rằng ((.+).*)có thể thay đổi thành ((.+)+), giảm kích thước 1 byte (từ 66 xuống còn 65 byte ) mà không mất chức năng chính xác - nhưng biểu thức chính thức bùng nổ theo cấp số nhân trong sự chậm chạp.

Hãy thử trực tuyến! (Phiên bản làm chậm theo cấp số nhân ECMAScript 79 byte)


11

Con trăn 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

Tìm độ mịn của các số bằng cách chia thử nghiệm cho đến khi số đó là 1. ilưu trữ độ mịn nhỏ nhất cho đến nay, jlưu trữ số đã cho độ mịn đó.

Cảm ơn @xnor cho các sân golf.


1
Điều đó if/elseđã được rút ngắn. Suy nghĩ đầu tiên của tôi là b=a%p<1;p+=1-b;a/=p**b. Hoặc một thực thi chạy một trong hai trong một chuỗi xen kẽ. Ngoài ra, có thể while~-alàm việc.
xnor

isaacg - Tôi thích câu trả lời này! Thật là một cách tuyệt vời mà bạn tìm thấy để tìm kiếm yếu tố chính lớn nhất! Tôi đã cập nhật câu trả lời của mình để mượn phương thức của bạn, với tín dụng cho bạn về phương thức này.
Todd Lehman

Giải pháp tuyệt vời! Sử dụng s,p=a,2, i,j=p,sý tưởng của @ xnor, loại bỏ thụt lề dư thừa và đặt khối while thành một dòng mang lại 95 ký tự. Không chắc chắn làm thế nào bạn đến với 98 ...
Falko

mã này chứa đầy biểu tượng cảm xúc, :)
Rosenthal

@Falko hai thay đổi đó không lưu ký tự. 7-> 7.
isaacg

10

J, 22 20 19 ký tự

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

Ví dụ

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

(Hàm lấy hai đối số là infix trong J.)


Tôi cũng có một vết nứt tại nó, đã không nhận được nó ngắn như câu trả lời này. Tuy nhiên:(#~ (= <./)@:(i:"1&1)@:*@:(_&q:))@:([ + i.@-~)
ɐɔıʇǝɥʇuʎs

Đây {:là giống như >./và tiết kiệm 1 byte.
ngẫu nhiên

@randomra Bạn gọi điện đúng cách!
FireFly

Đẹp. TIO nếu bạn muốn thêm nó: Hãy thử trực tuyến!
Giô-na

9

Haskell, 96 94 93 86 80 ký tự

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]

sử dụng thông qua GHCi (vỏ Haskell):

>5 # 9
8
>9 # 15
9

EDIT: bây giờ là một thuật toán đơn giản hơn nhiều.

giải pháp này bao gồm cả hai số trong phạm vi ( 8 # 97 # 8cả 8)

giải trình:

hàm (%) có hai tham số là x và y. khi y bằng 2, hàm trả về độ mịn của x.

thuật toán từ đây rất đơn giản - lấy danh sách kết hợp tất cả độ mịn của các số trong đầu vào với mỗi độ mịn lưu trữ một tham chiếu đến số gốc của nó, sắp xếp sau đó để lấy số nhỏ nhất và trả về số được tham chiếu.


đây là một phiên bản javascript không có thuật toán với cùng một thuật toán:

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

Nó sẽ có thể bí danh tối thiểu để một cái gì đó ngắn hơn? Có vẻ như nó sẽ cứu một số nhân vật.
isaacg

Tôi đã thử nó, nhưng vì sự hạn chế của sự đơn hình, nó thực sự có giá một nhân vật
tự hào

Bạn không thể làm m = tối thiểu? Haskell vẫn là một bí ẩn.
isaacg

1
@isaacg Để vượt qua giới hạn đơn hình người ta sẽ phải viếtm l=minimum l
tự hào

2
Tôi sẽ đăng một giải pháp Haskell, cho đến khi tôi thấy giải pháp của bạn vượt qua cả phiên bản chưa hoàn chỉnh của tôi ... +1
nyuszika7h

9

Toán học, 61 45 39 ký tự

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

Rất đơn giản thực hiện các thông số kỹ thuật như là một chức năng không tên.

  • Lấy phạm vi (bao gồm).
  • Yếu tố tất cả các số nguyên.
  • Tìm mức tối thiểu, được sắp xếp theo hệ số nguyên tố lớn nhất.

8

Lua - 166 ký tự

Tôi không không có (chưa!) Đủ uy tín để nhận xét về giải pháp AndoDaan của , nhưng đây là một số cải tiến trên mã của mình

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)

Thay đổi:

  • Các n%d==0bằng n%d<1tương đương trong trường hợp này
  • Đã xóa một khoảng trắng
  • Thay thế table.insert(f,d)bởi f[#f+1]=d ( #flà số phần tử của f)

Ah, rất vui vì tôi đã liếc nhìn ở đây. À, hai cái đầu tiên tôi nên kiểm tra và bắt, nhưng cải tiến thứ ba của bạn là mới đối với tôi (ý tôi là chỉ khác với những gì tôi đã từng làm). Điều đó sẽ giúp tôi rất nhiều ở đây và hơn tại golf.shinh.com. Cảm ơn!
AndoDaan

8

Bash + coreutils, 56 byte

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

Đầu vào là từ chính xác hai đối số dòng lệnh (Cảm ơn @ nyuszika7h !!!). Đầu ra là một kết quả số ít được in thành STDOUT.

  • seq cung cấp phạm vi số, một số trên mỗi dòng, từ các đối số dòng lệnh.
  • factorđọc các số đó và xuất ra mỗi số theo sau dấu hai chấm và danh sách sắp xếp các thừa số nguyên tố của số đó. Vì vậy, yếu tố chính lớn nhất là ở cuối mỗi dòng.
  • Đầu tiên sedloại bỏ dấu hai chấm và tất cả trừ yếu tố nguyên tố cuối cùng / lớn nhất, vì vậy hãy để lại danh sách mỗi số (cột 1) và hệ số nguyên tố lớn nhất của nó (cột 2).
  • sort số lượng theo thứ tự tăng dần theo cột 2.
  • Dòng cuối cùng sedkhớp với dòng 1 (số có hệ số nguyên tố lớn nhất là nhỏ nhất trong danh sách), loại bỏ mọi thứ bao gồm và sau khoảng trắng đầu tiên, sau đó thoát. sedtự động in kết quả của sự thay thế này trước khi bỏ.

Đầu ra:

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

Lưu ý phạm vi trong bối cảnh này bao gồm cả hai điểm cuối.


1
seq $@ngắn hơn 3 byte, nếu bạn có thể giả sử rằng chỉ có hai đối số.
nyuszika7h

@ nyuszika7h Ý kiến ​​hay - cảm ơn!
Chấn thương kỹ thuật số

5

Con trăn 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)

Suy nghĩ về một sân golf khác đã cho tôi một ý tưởng cho một thuật toán mới để kiểm tra độ trơn tru, do đó câu trả lời muộn.

Các yếu tố chính của giai thừa i!bao gồm chính xác các số nguyên tố nhiều nhất i. Vì vậy, nếu nlà một sản phẩm của các số nguyên tố riêng biệt, thì độ mịn của nó (hệ số nguyên tố lớn nhất) là nhỏ nhất inlà một ước của i!. Để tính toán các yếu tố nguyên tố lặp đi lặp lại n, thay vào đó chúng ta có thể sử dụng công suất đủ cao i!. Đặc biệt, (i!)**nđủ.

Các mã cố gắng tăng giai thừa F=i!, cập nhật đệ quy. Chúng tôi lọc các ước số Ftrong phạm vi đầu vào và xuất chúng nếu có, và nếu không thì chuyển sang (i+1)!.

Trường hợp thử nghiệm:

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

4

C,  149   95

Chỉnh sửa câu trả lời:

Tôi không thể yêu cầu tín dụng cho giải pháp này. Câu trả lời cập nhật này mượn phương thức tuyệt đẹp được sử dụng bởi isaacg trong giải pháp Python của anh ấy. Tôi muốn xem liệu có thể viết nó bằng C như một vòng lặp lồng for/ whilekhông có dấu ngoặc nhọn hay không, và đó là!

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

Giải trình:

  • Hàm R(a,b,n,q,p,m)quét phạm vi ađến b-1và trả về số mịn nhất đầu tiên được tìm thấy. Yêu cầu yêu cầu tuân thủ hình thức sau: R(a,b,a,b,2,0)để các biến bên trong hàm được khởi tạo hiệu quả như sau : n=a;q=b;p=2;m=0;.

Câu trả lời gốc :

Đây là câu trả lời ban đầu của tôi ...

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

Giải trình:

  • Hàm P(n,f,p)kiểm tra giá trị nnguyên thủy và trả về true (nonzero) nếu nlà số nguyên tố hoặc sai (không) nếu nkhông phải là số nguyên tố. fpcả hai phải được thông qua là 1.
  • Hàm G(n,f)trả về thừa số nguyên tố lớn nhất của n. fphải được thông qua như n.
  • Hàm R(a,b,p,n)quét phạm vi ađến b-1và trả về số mịn nhất đầu tiên được tìm thấy. pphải được thông qua là 1. ncó thể là bất kỳ giá trị.

Lái thử:

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

Đầu ra:

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

Tôi sẽ lập luận rằng điều này không phù hợp với điều khoản "Không mã hóa thêm thông tin trong mệnh đề".
Alchymist

@ Alchymist - Bạn có thể đúng ... nhưng tôi không nghĩ có bất kỳ thông tin bổ sung thực tế nào trong các đối số giả. Ít nhất không có bất kỳ thông tin nào là bất kỳ đầu mối nào cho câu trả lời.
Todd Lehman

4

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)

Ví dụ sử dụng:

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

1
Bạn không thể sử dụng <1thay vì ==0?
dfeuer

Vâng, đó sẽ là một cải tiến tốt đẹp. Có rất nhiều điều nhỏ có thể được thực hiện tốt hơn. May mắn thay, câu trả lời này đã làm tất cả trong số họ: codegolf.stackexchange.com/a/36461
Taylor Fausak

4

Q, 91 ký tự K, 78 ký tự

{(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 có lẽ sẽ cạo một tá ký tự

chỉnh sửa: thực sự, coi giới hạn trên là không bao gồm lần này

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

4

Lưu ý: Câu trả lời này không được phép.

Câu trả lời này sử dụng nhiều tính năng của Pyth được thêm vào sau khi thử thách được hỏi.

Tôi đã thêm một tính năng mới, gọi phạm vi đơn nguyên trên bộ dữ liệu 2 phần tử, rút ​​ngắn giải pháp bằng hai ký tự, vào đây:

Bình 7, 7

hoePNUQ

Đầu vào bây giờ được phân tách bằng dấu phẩy. Phần còn lại là như nhau.


Câu trả lời này sử dụng một tính năng của Pyth đã được thêm vào sau khi câu hỏi này được hỏi, đặc biệt sau khi xem giải pháp CJam tuyệt vời của @ aditsu. Điều đó đang được nói, tôi muốn chứng minh những gì thêm tính năng đó đã làm được. Tính năng này P, là một hàm arity-1 mà trên đầu vào số nguyên trả về một danh sách tất cả các thừa số nguyên tố của đầu vào, được sắp xếp từ nhỏ nhất đến lớn nhất.

Bình thường , 9

hoePNrQvw

Sử dụng phạm vi kiểu Python, dòng mới được phân tách trên STDIN. Đưa ra giải pháp nhỏ nhất cho STDOUT.

Giải trình:

      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.

Các xét nghiệm:

$ 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

@ MartinBüttner Yep, như được đề xuất bởi nhận xét của anh ấy về giải pháp
CJam

@ MartinBüttner Vâng, P, là tính năng mới. Tôi sẽ đặt nó trong câu trả lời.
isaacg

1
Cho phép hay không, không chỉ tôi thích nó, mà tôi cũng nghĩ rằng những "macro" ngắn đó có thể đọc được nếu bạn chú ý - sau tất cả chúng chuyển đổi thành Python đơn giản. Một cái gì đó phải được nói cho một ngôn ngữ golf tốt cho golf nhưng không nhất thiết phải gây khó chịu.
Kuba Ober

@KubaOber Cảm ơn, Kuba. Đó luôn là ý định của tôi khi viết Pyth, để làm cho nó trở nên golf và dễ đọc nhất có thể. Tôi rất vui vì nó hoạt động.
isaacg

3

Lua - 176 ký tự

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)

Tôi thực sự nên dừng chơi golf ở Lua. Không có điểm nào.


14
IMHO, chơi golf mã giống như quyền anh: có các hạng cân. Một ngôn ngữ nhất định có thể không thắng hoàn toàn, nhưng đó là niềm vui và chiếu sáng cho golf trong lớp / ngôn ngữ đó.
Michael Easter

3

Clojure - 173 170 ký tự

Tôi là người mới chơi Clojure. Chơi gôn

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

Chạy mẫu:

Phạm vi bao gồm cấp thấp, loại trừ cao cấp: [a, b) Chỉ in một trong những số mịn nhất, nếu nhiều số xảy ra.

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

sản lượng:

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

Ung dung:

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

1
Một phạm vi bao gồm cấp thấp và loại trừ cấp cao thường được viết [a, b).
murgatroid99

vâng, cảm ơn bạn đã ghi chú
Michael Easter

3

Ruby, 65 62

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

Với lời xin lỗi tới https://codegolf.stackexchange.com/a/36484/6828 , đây là phiên bản được đánh gôn (và hơi đơn giản hóa). Sử dụng một phạm vi bao gồm vì nó là một nhân vật ngắn hơn.

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 

Và cảm ơn YenTheFirst đã cứu ba nhân vật.


1
Bạn thực sự có thể thoát khỏi mà không có [0], vì so sánh mảng sẽ ưu tiên phần tử đầu tiên. Điều này sẽ cho kết quả khác nhau, nhưng vẫn chính xác.
YenTheFirst

3

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

Ung dung:

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

Nó bắt đầu và độ dài từ dòng lệnh và sẽ trả về số mịn lớn nhất.

Tôi đã sử dụng câu trả lời từ đâyđây để đưa ra câu trả lời của mình.

Cảm ơn VisualMelon đã tinh chỉnh nó và cạo 12 byte! Tôi cũng đã thoát khỏi dấu ngoặc nhọn nếu lưu 2 byte và CodeInChaos đã chỉ ra một số nội dung rõ ràng mà tôi đã bỏ lỡ (cảm ơn lần nữa).


Vài mục đích chung nhỏ, bạn có thể lưu 4 byte Fbằng cách xác định int bbên cạnh m. Trong một vài nơi bạn thực hiện việc so sánh a%b==0, và abluôn tích cực bạn có thể cắt một byte cho mỗi bằng cách kiểm tra nếu nó nhỏ hơn 1 a%b<1. Bạn cũng có thể lưu một byte bằng cách tăng btrong điều kiện if a%++b<0thay vì khởi tạo nó thành 1. Tôi cũng nghĩ trong trường hợp này sẽ rẻ hơn nếu chỉ đủ điều kiện System.Console.WriteLinevà tránh namespaceđiều khoản.
VisualMelon

@VisualMelon Cảm ơn, đã cập nhật ý tưởng của bạn :)
ldam

Các điều m=...:m;rơi ra bên ngoài vòng lặp while. Do đó, bạn có thể thả m=0,và thay thế return m;bằng return m=b>m?b:m;. Sau đó, bạn có thể thả m=...:m;hoàn toàn.
tomsmeding

Nghe có vẻ lạ, nhưng điều này - đối với tôi - ít khả thi hơn so với CJam và J. Tôi đoán C # được thiết kế để dài dòng và cố gắng làm cho nó ít hơn để khiến nó không thể đọc được? Hmm ....
Kuba Ober

Không, tôi đồng ý, LINQ trông giống như một con quỷ khi bạn chỉ nhìn thấy nó ở đây và ở đó và không bao giờ thực sự chơi với chính nó. Mặc dù bạn đã nắm bắt được nó, nhưng nó thực sự rất tuyệt :) Nói như vậy, tôi vẫn không hiểu hết về cách thức Aggregatehoạt động, tôi chỉ thử nó sau khi thấy nó trong một câu trả lời khác để đến với đối tượng mới của tôi thay vì chỉ một lĩnh vực trong đó, và nó chỉ hoạt động hoàn hảo :)
ldam

2

R, 83

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

trong đó đáy của phạm vi đầu vào được gán cho avà đỉnh (bao gồm) được gán cho b.

gmplà một gói có sẵn trên CRAN. Nó cảm thấy bẩn cho đến khi tôi thấy mfchức năng vô lý đó trong CJam. Cài đặt bằng cách gõ install.packages("gmp")vào bàn điều khiển.


1
Nếu bạn đang sử dụng lapply3 lần, bạn có thể muốn đặt bí danh cho nó (nghĩa là l=lapplysau đó sử dụng l(...). Tương tự như vậy factorizelà chức năng duy nhất bạn sử dụng từ gói gmpbạn có thể sử dụng gmp::factorizethay vì tải thư viện và sau đó sử dụng factorize. Do đó, mã của bạn sẽ trở thành l=lapply;n=a:b;n[which.min(l(l(l(n,gmp::factorize),max),as.numeric))]69 byte.
plannapus

2

PowerShell - 85

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

Điều này sẽ sắp xếp một phạm vi số (bao gồm) dựa trên hệ số nguyên tố tối đa của mỗi số. Nó trả về phần tử được sắp xếp thấp nhất.

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

2

J - 16 char

Sử dụng kiểu ( bắt đầu , độ dài ) của phạm vi, theo sự cho phép của các bình luận.

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

Được sử dụng như một động từ dyadic: đối số bên trái là bắt đầu , bên phải là chiều dài .

   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

Một giải pháp ( bắt đầu , kết thúc ) là +2 ký tự và không bao gồm kết thúc; bao gồm cả kết thúc là +2. Nhưng về mặt tươi sáng, nó trông khá đẹp vì chúng tôi phù hợp với tất cả {niềng răng}.

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

2

Nghiêm túc, 8 * 14/7 = 16 (không cạnh tranh)

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

Nghiêm túc được tạo ra sau thử thách này, nhưng tôi muốn đăng câu trả lời này vì nó minh họa cho loại thử thách Nghiêm túc là tốt.

Hãy thử trực tuyến!

Giải trình:

,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

2

Bình thường , 7 byte

.mePbrF

Hãy thử nó ở đây!

[một,b)[một,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.

1

Rắn hổ mang - 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

Thậm chí không chắc chắn tại sao tôi làm phiền, rắn hổ mang không thể cạnh tranh ở đây.


1
Rắn hổ mang trông giống hệt trăn ... Sự khác biệt là gì?
Beta Decay

@BetaDecay Cobra là những gì xảy ra khi bạn đưa C # cú pháp của Python. Trang web Cobra
Οurous

1

Ruby - 113 ký tự

Sử dụng stdlib. Trả về một kết quả. Thử nghiệm trên 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

1
Chào mừng bạn đến với chương trình Câu đố và trao đổi mã Golf Stack. Cảm ơn đã đăng kết quả của bạn. Vì đây là câu hỏi về môn đánh gôn, vui lòng bao gồm số lượng nhân vật của bạn trong câu trả lời của bạn. Bạn có thể sử dụng một công cụ như công cụ này: javascriptkit.com/script/script2/charcount.shtml
isaacg

1

Perl (5.10+), 83

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

(ngắt dòng có thể được gỡ bỏ). Có hai điểm cuối của một phạm vi bao gồm trên hai dòng stdin (vì <>rẻ hơn so với truy cập ARGV) và đưa ra kết quả tốt nhất cho thiết bị xuất chuẩn. Nếu có một chiếc cà vạt cho mịn nhất, hãy in nhỏ nhất. Có thể in lớn nhất với chi phí của một ký tự.

Thuật toán về cơ bản là cách tìm kiếm yếu tố chính lớn nhất của isaacg, mặc dù chúng tôi đã đưa ra nó một cách độc lập. Đó là phần chơi golf đẹp mắt với một tuyên bố duy nhất trong perl, phần còn lại có nhiều chi phí hơn tôi muốn.

Nên chạy dưới perl -Ehoặc với một use 5.012lời mở đầu. Nếu bạn không thể làm điều đó, thay thế say$rbằng print$r,$/.


1

Con trăn 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)

Giải pháp của @ isaacg , nhưng với một minphím chức năng thay cho tìm kiếm tối thiểu rõ ràng và một hàm đệ quy đóng vai trò của phép lặp.

Chạy trong Stackless Python để tránh giới hạn đệ quy.

Có vẻ lãng phí khi sử dụng điều kiện parantated (n%p<1), sau đó lặp lại phủ định của nó trong parantant (n%p>0), nhưng đó là điều tốt nhất tôi có. Tôi đã thử mọi thứ một loạt, nhưng chúng trở nên tồi tệ hơn.

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

Tôi hoan nghênh bất kỳ cải tiến bạn có thể nghĩ đến.


1

Java 8 - 422 454 ký tự

Tôi đang học Java 8 và muốn đưa ra một cú đánh liên quan đến Java (hoặc thậm chí các luồng Java 8).

So với các ngôn ngữ khác, đây là tàn bạo nhưng là một bài tập thú vị.

Chơi gôn

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

Ung dung:

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

chạy ví dụ bằng cách sử dụng:

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

192

1

MATL ( không cạnh tranh ), 20 byte

Ngôn ngữ này được thiết kế sau thử thách

Phạm vi được bao gồm ở cả hai đầu. Các số được lấy làm hai đầu vào riêng biệt.

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

Hãy thử trực tuyến!

Giải trình

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

Tôi đoán hôm nay sẽ là 17 byte &:[]y"@YfX>h]&X<)hoặc có lẽ là 16 :[]y"@YfX>h]&X<). Đó &thực sự là một ý tưởng tuyệt vời (và tôi đoán ylúc đó không có sẵn?).
Sundar

Và có vẻ như phát sóng Yfvới tiền tố 1 cũng có ích ở đây, nhưng nói chung có lẽ không đủ để quyết định đó là một ý tưởng hay. :)
Sundar

Vâng, đây là sự khởi đầu, vì vậy không yhoặc &. Tín dụng cho Suever cho các ngữ nghĩa rất hữu ích sau này (ý tưởng ban đầu của tôi là làm cho nó có nghĩa là "một đầu vào nhiều hơn mặc định"). Nếu chúng ta thấy nhiều trường hợp có thêm các trường hợp Yfhữu ích, thì thực sự đáng để thêm tính năng đó. Vấn đề là, có khoảng 34 câu trả lời được sử dụng Yf(theo kịch bản này ), vì vậy thật khó để nói
Luis Mendo

1

Jelly , 7 byte, điểm = 7 7 × 8 = 8, thử thách hoãn ngôn ngữ

rÆfṀ$ÐṂ

Hãy thử trực tuyến!

Lấy các điểm cuối phạm vi thấp hơn và trên là hai đối số riêng biệt. Xuất ra một danh sách tất cả các số mịn nhất trong phạm vi. (Điều này có thể được xem như là một hàm, trong trường hợp đầu ra là danh sách Jelly hoặc là một chương trình đầy đủ, trong trường hợp đó, đầu ra xảy ra để sử dụng cùng một biểu diễn danh sách mà JSON thực hiện.)

Giải trình

Những lúc chương trình Jelly của bạn chỉ là bản dịch nghĩa đen của spec spec

rÆfṀ$ÐṂ
r        Range from {first argument} to {second argument}
     ÐṂ  Return the elements which have the minimum
   Ṁ$      largest
 Æf          prime factor
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.