公式

以数字300为例

• 300的素数是[2, 3, 5]（作为300和素数的唯一数）
• 对这些数字进行平方会给你 [4, 9, 25]
• 汇总清单将为您提供 4 + 9 + 25 = 38
• 最后从原始数字中减去该总和（38）300-38 = 262（这是结果）

输入项

您的输入将是一个大于2的正整数。您必须检查从2到输入值（包括该值）的所有数字，并使用上述公式找到产生最大结果的数字。

您的输出将是两个数字，中间用空格，逗号，换行符或任何您允许的语言分隔（必须分开才能区分这两个数字）。这些可以输出到文件，stdout或任何您使用的语言。您的目标是找到在通过上述公式运行时产生最大输出的范围内的数字。显示的第一个数字应该是起始数字（例如300），第二个数字应该是公式生成的输出（例如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

考虑输入10，我们必须为2-10（含）之间的所有数字运行公式

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

如您所见，最大的结果是4，这是将值输入8公式的结果。这意味着输入的输出10应为8, 4

计分与规则

输入和输出的默认规则适用：Code Golf 的默认规则：输入/输出方法
禁止标准漏洞：默认情况下 禁止的漏洞
提交可以是函数或完整程序

以字节为单位的最短代码获胜

Pyth，17 15字节

_eSttm,-ds^R2{P

测试套件。

爪哇8拉姆达，247 239 233 225 224 219 198 161字符

我认为这必须在300个字符以内，因为...您知道... Java！

甚至不到200个字符的确有可能！

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

我不知道这种进口使用是否合法，但我认为应该没问题。这是未分类的lambda：

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

质因数查找基于此答案。该代码使用集合的功能，因为它们仅将每个值保存一次，因此以后不必担心添加重复项。紧随问题之后，其余代码非常简单。

更新

从输出中删除了换行符。

感谢@ogregoire将Integer.MIN_VALUE打到1 << 31！

再次查看代码后，我发现了一些可以打高尔夫球的地方。

感谢@Blue == 0到<1技巧！

删除了一些剩余的空格。同样，对于分离，仅需要一个字符，因此无需浪费一个字符。

再次感谢@ogregoire指出我可以返回值，而不必打印它并将声明放在一起！这节省了很多！

发现如果要多保存一个字符，我可以使用三进制而不是第二个。

由于@AstronDan的真棒节省进口阵列的使用。这也使我有可能缩短第一个三元组。

其实是21个位元组

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

在线尝试！

说明：

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字节

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

在线尝试！

对于在线编译器，最后一种情况花费的时间太长，但是会产生正确的结果（在我的计算机上（在Matlab上运行）大约需要11秒）：

说明

所描述程序的直接应用。

:         % 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个字节

我的第一个Code Golf :)。尽管语言冗长，但我还是使用了我最喜欢的语言。我以@Frozn Java的C＃函数端口开始的，但是发现了几种通过优化进一步缩小代码的方法。

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

这使用数组存储主要因子。因为它由因子索引，所以它将用因子的副本替换重复的因子。这使该函数没有导入。这甚至不需要系统。

Bash + GNU实用程序，74

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

• seq 生成所有2到n的整数
• factor给出数字，后跟冒号，然后是所有主要因子（包括重复项）的空格分隔列表。例如12的结果是12: 2 2 3
• sed删除冒号和重复因子，然后生成所需的算术表达式。例如12：12- 2* 2- 3* 3
• bc 评价这个
• nl 前缀n返回（从2开始）
• sort 在第二列中按数字降序排列
• seq 打印第一行并退出。

伊迪恩

Brachylog，48个字节

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

说明

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]

果冻，13 个字节

ÆfQ²S_@,µ€ḊṀṚ

在线尝试！或验证所有测试用例。

怎么运行的

Æ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字节

码：

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

说明：

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]

在线尝试

朱莉娅56字节

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

在线尝试！

怎么运行的

给定输入n，对于每个整数k，使得2≤k≤n，我们生成元组（f（k），k），其中f（k）是k及其素数平方和之和。 。

f（k）本身用计算k-sumabs2(k|>factor|>keys)，将k分解为素数键和指数值的Dict，提取所有键（素数因子），取其平方和，然后从中减去结果整数 k。

最后，我们采用生成的元组的字典最大法，并通过在索引2和1处对其进行逆转。

Clojure，215个字节

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

只要遵守规则。计算每个数字的素因子，将它们平方和求和。之后，生成一个包含2个元素的向量的列表：初始编号及其结果，并找到第二个元素具有最大值的元素。

您可以在此处在线查看：https：//ideone.com/1J9i0y

R 109字节

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

我作弊并使用了一个包装gmp。

CJam，32个字节

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

在线尝试！

Pyke，17个字节

FODP}mXs-)DSei@Oi

在这里尝试！

PowerShell的V2 +，124个 120 117字节

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

第一行计算值，第二行仅输出。

我们首先创建一个范围，2直到命令行参数，$args[0]然后循环该范围|%{...}。在每个循环中，我们使用设置辅助变量等于我们的当前值$y=$z=$_。然后，我们遍历每个数字，2直到当前的数字。在每个内部循环中，我们检查该数字是否为除数!($z%$_)，是否为质数 ('1'*$_-match'^(?!(..+)\1+$)..')，如果两者均是，则减去平方$y（检查使用布尔乘法完成）。

遍历所有主除数并减去平方后，如果剩余数是到目前为止所看到的最大数$y-gt$o，则设置输出变量$o=$y;$p=$_。遍历整个范围后，我们只需在两者之间留一个空格即可。

Haskell，91字节

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

用法示例：f 50-> [48,35]。

质因数函数仅通过import Data.Numbers.Primes花费太多字节才可用，因此我正在使用@Lynn的质数检查器。其余部分是直的正向：用于输入m循环n通过[2..m]并且在内环p通过[2..n]。保留所有p素数和除法n，平方和。

Python 2中，108个 105 100字节

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)

在Ideone上进行测试。

的JavaScript（ES6），111个 105字节

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

不知道为什么我以前不这么认为。

J，44个字节

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

直截了当的方法。还返回n该结果的所有值以得到最大值。

用法

   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