Công thức

Lấy ví dụ số 300

• Các thừa số của 300 là [2, 3, 5](các số duy nhất là các thừa số của 300 và số nguyên tố)
• Bình phương mỗi số đó sẽ cung cấp cho bạn [4, 9, 25]
• Tổng hợp danh sách đó sẽ cung cấp cho bạn 4 + 9 + 25 = 38
• Cuối cùng trừ tổng đó (38) khỏi số ban đầu của bạn 300-38 = 262(đây là kết quả)

Đầu vào

Đầu vào của bạn sẽ là số nguyên dương lớn hơn 2. Bạn phải kiểm tra tất cả các số từ 2 đến giá trị đầu vào (đã bao gồm) và tìm số tạo ra kết quả lớn nhất với công thức trên.

Đầu ra của bạn sẽ là hai số được phân tách bằng dấu cách, dấu phẩy, dòng mới hoặc bất kỳ ngôn ngữ nào bạn cho phép (việc phân tách là cần thiết để phân biệt hai số). Đây có thể là đầu ra cho một tập tin, thiết bị xuất chuẩn hoặc bất cứ thứ gì ngôn ngữ của bạn sử dụng. Mục tiêu của bạn là tìm số trong phạm vi tạo ra sản lượng tối đa khi chạy qua công thức trên. Số đầu tiên được hiển thị phải là số bắt đầu (như 300) và số thứ hai phải là đầu ra mà công thức tạo ra (như 262)

Input: 3       Output: 2, -2
Input: 10      Output: 8, 4
Input: 50      Output: 48, 35
Input: 1000    Output: 1000, 971
Input: 9999    Output: 9984, 9802

Hãy xem xét đầu vào của 10, chúng ta phải chạy công thức cho tất cả các số từ 2-10 (đã bao gồm)

Num PrimeFacs PrimeFacs^2 SumPrimeFacs^2 Result
2   [2]       [4]         4              -2
3   [3]       [9]         9              -6
4   [2]       [4]         4               0
5   [5]       [25]        25             -20
6   [2, 3]    [4, 9]      13             -7
7   [7]       [49]        49             -42
8   [2]       [4]         4               4
9   [3]       [9]         9               0
10  [2, 5]    [4, 25]     29             -19

Như bạn có thể thấy kết quả lớn nhất là 4, đó là kết quả của việc nhập giá trị 8vào công thức. Điều đó có nghĩa là đầu ra cho đầu vào 10phải là8, 4

Chấm điểm & nội quy

Các quy tắc mặc định cho đầu vào và đầu ra được áp dụng: Mặc định cho Code Golf: Phương thức nhập / xuất
Các lỗ hổng tiêu chuẩn bị cấm: Các lỗ hổng bị cấm theo mặc định
Đệ trình có thể là các chức năng hoặc chương trình đầy đủ

Mã ngắn nhất tính bằng byte

Bình thường, 17 15 byte

_eSttm,-ds^R2{P

Bộ thử nghiệm.

Java 8 lambda, 247 239 233 225 224 219 198 161 ký tự

Tôi nghĩ rằng phải có thể có dưới 300 ký tự vì ... bạn biết ... Java!

Và nó thực sự có thể ngay cả trong dưới 200 ký tự!

m->{int n=1,u,f,F[],g,G=g=1<<31;for(;++n<=m;){u=n;F=new int[m+1];for(f=1;++f<=u;)u/=u%f<1?(F[f]=f--):1;f=0;for(int p:F)f+=p*p;g=n-f>g?(G=n)-f:g;}return G+","+g;}

Tôi không biết việc sử dụng hàng nhập khẩu này có hợp pháp hay không nhưng tôi cho rằng nó sẽ ổn. Đây là lambda vô dụng thành một lớp:

public class Q80507 {
    static String greatestAfterReduction(int maxNumber) {
        int number = 1, upper, factor, primeFactors[], greatestResult, greatestNumber = greatestResult = 1 << 31; // <-- Integer.MIN_VALUE;
        for (;++number <= maxNumber;) {
            // get unique primefactors
            upper = number;
            primeFactors = new int[maxNumber + 1];
            for (factor = 1; ++factor <= upper;)
                upper /= upper % factor < 1 ? (primeFactors[factor] = factor--) : 1;

            factor = 0;
            for (int prime : primeFactors)
                factor += prime * prime;

            greatestResult = number - factor > greatestResult ? (greatestNumber = number) - factor : greatestResult;
        }
        return greatestNumber + "," + greatestResult;
    }
}

Việc tìm kiếm primefactor dựa trên câu trả lời này . Mã này sử dụng chức năng của các bộ vì chúng chỉ lưu mỗi giá trị một lần, do đó tôi không phải quan tâm đến các bản sao được thêm vào sau này. Phần còn lại của mã là khá thẳng về phía trước, chỉ cần làm theo câu hỏi.

Cập nhật

Đã xóa dòng mới khỏi đầu ra.

Cảm ơn @ogregoire vì đã chơi gôn Integer.MIN_VALUE thành 1 << 31!

Sau khi nhìn vào mã một lần nữa, tôi tìm thấy một số nơi mà mọi thứ có thể được chơi gôn.

Cảm ơn @Blue về thủ thuật == 0 đến <1!

Đã xóa một số khoảng trắng còn sót lại. Ngoài ra để phân tách chỉ cần một char nên không cần lãng phí một char.

Một lần nữa xin cảm ơn @ogregoire vì đã chỉ ra rằng tôi có thể trả lại giá trị thay vì in nó và tập hợp các tờ khai! Điều này tiết kiệm rất nhiều!

Phát hiện ra tôi có thể sử dụng một ternary thay vì thứ hai nếu để lưu thêm một char.

Cảm ơn @AstronDan về cách sử dụng tuyệt vời của một mảng giúp tiết kiệm nhập khẩu. Điều đó cũng cho tôi khả năng rút ngắn lần đầu tiên nếu thành một con chim nhạn.

Trên thực tế, 21 byte

u2x;`;y;*@-`M;M;)@í@E

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

Giải trình:

u2x;`;y;*@-`M;M;)@í@E
u2x;                   push two copies of range(2, n+1) ([2, n])
    `      `M          map:
     ;                   duplicate
      y;                 push two copies of prime divisors
        *                dot product of prime divisors lists (equivalent to sum of squares)
         @-              subtract from n
             ;M;)      duplicate, two copies of max, move one copy to bottom of stack
                 @í    get index of max element
                   @E  get corresponding element from range

MATL , 18 byte

:"@tYfu2^s-]v2#X>w

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

Trường hợp cuối cùng mất quá nhiều thời gian cho trình biên dịch trực tuyến, nhưng nó tạo ra kết quả chính xác (mất khoảng 11 giây trong máy tính của tôi, chạy trên Matlab):

Giải trình

Áp dụng đơn giản các thủ tục được mô tả.

:         % Implicit input n. Range [1 2 ... n]
"         % For each
  @       %   Push that number
  tYfu    %   Duplicate. Prime factors. Unique values
  2^s-    %   Square. Sum of array values. Subtract
]         % End for each
v         % Concatenate stack contents into vertical vector
2#X>      % Max and arg max
w         % Swap. Implicit display         

C #, 194 byte

Mã Golf đầu tiên của tôi :). Tôi đã sử dụng ngôn ngữ yêu thích của tôi mặc dù tính dài dòng của nó. Tôi đã bắt đầu điều này như một cổng chức năng C # của Java @ Frozn nhưng đã tìm thấy một số cách để thu nhỏ mã hơn nữa với tối ưu hóa.

string R(int a){int u,f,g,N=g=1<<31;for(int n=1;++n<=a;){u=n;int[]P=new int[a+1];for(f=1;++f<=u;){if(u%f<1){u/=f;P[f]=f--;}}f=0;foreach(var p in P){f+=p*p;}if(n-f>g){g=(N=n)-f;}}return N+","+g;}

Điều này sử dụng một mảng để lưu trữ các yếu tố chính. Bởi vì nó được lập chỉ mục bởi yếu tố này, nó sẽ thay thế các yếu tố lặp đi lặp lại bằng các bản sao của yếu tố đó. Điều này cho phép các chức năng không có nhập khẩu. Điều này thậm chí không yêu cầu hệ thống.

Tiện ích Bash + GNU, 74

seq 2 $1|factor|sed -r 's/:?( \w+)\1*/-\1*\1/g'|bc|nl -v2|sort -nrk2|sed q

• seq tạo ra tất cả các số nguyên từ 2 đến n
• factorđưa ra số theo sau là dấu hai chấm, sau đó một danh sách được phân tách bằng dấu cách của tất cả các thừa số nguyên tố, bao gồm cả các mục trùng lặp. ví dụ: kết quả cho 12 là12: 2 2 3
• sedloại bỏ các yếu tố dấu hai chấm và trùng lặp, sau đó tạo biểu thức số học cần thiết. ví dụ: 12:12- 2* 2- 3* 3
• bc đánh giá điều này
• nl tiền tố n trở lại (bắt đầu từ 2)
• sort theo cột thứ hai, theo số, theo thứ tự giảm dần
• seq in dòng đầu tiên và thoát.

Ideone.

Brachylog , 48 byte

:2:{eI$pd:{:2^.}a+:I--:I.}fF$\hor:0m:Ir.r~m[F:J]

Giải trình

Main predicate:

:2:{}fF                     Unify F with the list of all binding for which predicate 1 is
                            true, given [Input, 2] as input.
       $\hor:0m             Retrieve the max of F by diagonalizing it, taking the
                            first row, sorting that row and reversing the sorted row.
               :Ir.         Unify the Output with [I, Max],
                   r~m[F:J] [I, Max] is in F at index J (the index is unimportant)


Predicate 1:

eI                          I is an integer in the range given in Input
  $pd                       Get the list of prime factors of I, with no duplicates
     :{:2^.}a               Apply squaring to each element of that list
             +              Sum the list
              :I-           Subtract I from the sum
                 -          Multiply by -1 (let's call it Result)
                  :I.       Unify the Output with [Result, I]

Thạch , 13 byte

ÆfQ²S_@,µ€ḊṀṚ

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

ÆfQ²S_@,µ€ḊṀṚ  Main link. Argument: n

        µ      Combine the chain to the left into a link.
         €     Apply it to each k in [1, ..., n].
Æf               Yield k's prime factors as a list.
  Q              Unique; deduplicate the prime factors.
   ²             Square each unique prime factor.
    S            Compute their sum.
     _@          Subtract the result from k.
       ,         Pair with k, yielding [result(k), k].
          Ḋ    Dequeue; discard the first pair which corresponds to k = 1.
           Ṁ   Get the maximum (lexicographical order).
            Ṛ  Reverse the pair.

05AB1E, 19 17 16 byte

Mã số:

L©f€n€O®-®)ø¦{¤R

Giải trình:

L                    # make a list of 1..input [1,2,3,4,5,6]
 ©                   # save the list for reuse
  f                  # get primefactors of numbers in list [[],[2],[3],[2],[5],[2,3]]
   €n                # square each factor [[],[4],[9],[4],[25],[4,9]]
     €O              # sum the factors [0,4,9,4,25,13]
       ®-            # subtract from saved list [1,-2,-6,0,-20,-7]
         ®)ø         # zip with saved list [[1,1],[-2,2],[-6,3],[0,4],[-20,5],[-7,6]]
            ¦        # drop the first item (n=1) [[-2,2],[-6,3],[0,4],[-20,5],[-7,6]]
             {       # sort [[-20,5],[-7,6],[-6,3],[-2,2],[0,4]]
              ¤      # get last item [0,4]
               R     # reverse [4,0]

Dùng thử trực tuyến

Julia, 56 byte

!n=maximum(k->(k-sumabs2(k|>factor|>keys),k),2:n)[[2,1]]

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

Làm thế nào nó hoạt động

Cho một đầu vào n , với mỗi số nguyên k sao cho 2 ≤ k ≤ n , chúng ta tạo ra tuple (f (k), k) , trong đó f (k) là sự khác biệt giữa k và tổng bình phương của các thừa số nguyên tố của nó .

Bản thân f (k) được tính với k-sumabs2(k|>factor|>keys), yếu tố k thành Dict của các khóa chính và giá trị lũy thừa, trích xuất tất cả các khóa (thừa số nguyên tố), lấy tổng bình phương của chúng và trừ số nguyên kết quả từ k .

Cuối cùng, chúng tôi lấy mức tối đa từ vựng của các bộ dữ liệu được tạo và đảo ngược nó bằng cách tích lũy nó ở các chỉ số 2 và 1 .

Clojure, 215 byte

(fn j[x](apply max-key second(map(fn[w][w(- w(let[y(reduce +(map #(* % %)(set(flatten((fn f[q](let[c(filter(fn[r](=(mod q r)0))(range 2 q))](if(empty? c)q(map f c))))w)))))](if(= y 0)(* w w)y)))])(range 2(inc x)))))

Chỉ cần tuân theo các quy tắc. Tính các thừa số nguyên tố của mỗi số, đặt chúng vào bình phương và tính tổng chúng. Sau đó tạo ra một danh sách các vectơ gồm 2 phần tử: số ban đầu và kết quả của nó và tìm phần tử có giá trị tối đa của phần tử thứ hai.

Bạn có thể thấy nó trực tuyến tại đây: https://ideone.com/1J9i0y

R 109 byte

y=sapply(x<-2:scan(),FUN=function(x)x-sum(unique(as.numeric(gmp::factorize(x))^2)));c(x[which.max(y)],max(y))

Tôi đã lừa dối và sử dụng một gói , gmp.

CJam, 32 byte

ri({))_mf_|2f#:+-}/]_:e>_@#))\]p

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

Pyke, 17 byte

FODP}mXs-)DSei@Oi

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

PowerShell v2 +, 124 120 117 byte

2..$args[0]|%{$y=$z=$_;2..$_|%{$y-=$_*$_*!($z%$_)*('1'*$_-match'^(?!(..+)\1+$)..')};if($y-gt$o){$o=$y;$p=$_}}
"$p $o"

Dòng đầu tiên tính toán các giá trị, dòng thứ hai chỉ là đầu ra.

Chúng tôi bắt đầu với việc tạo một phạm vi từ 2lên đến đối số dòng lệnh $args[0]và lặp vòng đó |%{...}. Mỗi vòng lặp chúng tôi đặt các biến của trình trợ giúp bằng với giá trị hiện tại của chúng tôi với $y=$z=$_. Sau đó chúng tôi lặp qua mọi số từ 2đến số hiện tại của chúng tôi. Mỗi vòng lặp bên trong, chúng tôi kiểm tra xem số đó có phải là ước số !($z%$_)hay không và liệu nó có phải là số nguyên tố ('1'*$_-match'^(?!(..+)\1+$)..') hay không và liệu cả hai chúng tôi có trừ đi bình phương hay không $y(kiểm tra được thực hiện bằng cách nhân Boolean).

Khi chúng ta đã trải qua tất cả các ước số nguyên tố và trừ đi các bình phương, nếu số còn lại là lớn nhất chúng ta đã thấy cho đến nay $y-gt$o, chúng ta đặt các biến đầu ra $o=$y;$p=$_. Sau khi chúng tôi lặp qua toàn bộ phạm vi, chúng tôi chỉ cần xuất ra một khoảng trắng ở giữa.

Haskell, 91 byte

f m=reverse$maximum[[n-sum[p^2|p<-[2..n],mod n p<1,mod(product[1..p-1]^2)p>0],n]|n<-[2..m]]

Ví dụ sử dụng: f 50-> [48,35].

Các hàm nhân tố chính chỉ khả dụng thông qua import Data.Numbers.Primeschi phí quá nhiều byte, vì vậy tôi đang sử dụng trình kiểm tra chính của @ Lynn . Phần còn lại là thẳng về phía trước: cho mvòng lặp đầu vào nthông qua [2..m]và trong một vòng lặp bên trong pthông qua [2..n]. Giữ tất cả những pgì là số nguyên tố và chia n, bình phương và tổng.

Python 2, 108 105 100 byte

f=lambda n,m=2,p=1:m>n or-~f(n,m+1,p*m*m)-(n%m<p%m)*m*m
r=max(range(2,input()+1),key=f)
print r,f(r)

Kiểm tra nó trên Ideone .

JavaScript (ES6), 111 105 byte

f=n=>{r=n<2?[]:f(n-1);for(s=[],j=n,i=2;j>1;k%i?i++:j/s[i]=i);s.map(i=>j-=i*i,j=n);return j<r[1]?r:[n,j]}

Không biết tại sao tôi không nghĩ làm điều này đệ quy trước đây.

J, 44 byte

[:((],.~2+I.@e.)>./)@:}.1(-[:+/*:@~.@q:)@+i.

Phương pháp tiếp cận thẳng. Cũng trả về tất cả các giá trị của nkết quả đó trong một giá trị tối đa.

Sử dụng

   f =: [:((],.~2+I.@e.)>./)@:}.1(-[:+/*:@~.@q:)@+i.
   f 3
2 _2
   f 10
8 4
   f 50
48 35
   f 1000
1000 971
   f 9999
9984 9802
   f 950
900 862
945 862