공식

숫자 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

점수 및 규칙

입력 및 출력의 기본 규칙이 적용됩니다. 코드 골프의 기본값 : 입력 / 출력 방법
표준 허점 은 금지됩니다. 기본적으로 금지 된 허점은
기능 또는 전체 프로그램 일 수 있습니다.

바이트 단위의 최단 코드 승리

Pyth, 17 15 바이트

_eSttm,-ds^R2{P

테스트 스위트.

자바 8 람다 247 239 233 225 224 219 198 161 문자

나는 당신이 알고있는 자바 때문에!

그리고 실제로 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;}

이 수입품의 사용이 합법적인지 잘 모르겠지만 괜찮다고 생각합니다. 다음은 클래스로 뭉친 람다입니다.

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

주요 요인 찾기는 이 답변을 기반으로 합니다 . 이 코드는 각 값을 한 번만 저장하므로 집합의 기능을 사용하므로 나중에 중복 항목을 추가 할 필요가 없습니다. 코드의 나머지 부분은 질문에 따라 매우 간단합니다.

업데이트

출력에서 개행을 제거했습니다.

Integer를 골프로 만든 @ogregoire에게 감사합니다 .MIN_VALUE to 1 << 31!

코드를 다시 살펴본 후 골프를 칠 수있는 곳을 더 발견했습니다.

== 0에서 <1까지의 트릭을위한 @Blue에 감사합니다!

남은 공백을 제거했습니다. 또한 분리를 위해 하나의 문자 만 필요하므로 하나의 문자를 낭비 할 필요가 없습니다.

인쇄하고 선언을 작성하는 대신 값을 반환 할 수 있음을 지적한 @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 바이트

내 첫 번째 코드 골프 :). 나는 자세한 표현에도 불구하고 내가 좋아하는 언어를 사용했다. 나는 이것을 @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;}

이것은 배열을 사용하여 소인수를 저장합니다. 요인에 의해 색인화되기 때문에 반복되는 요인을 요인의 사본으로 대체합니다. 이를 통해 함수에 가져 오기를 수행 할 수 없습니다. 이것은 심지어 시스템이 필요하지 않습니다.

배쉬 + 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이 주어지면 2 ≤ k ≤ n 과 같은 각 정수 k 에 대해 튜플 (f (k), k) 을 생성합니다 . 여기서 f (k) 는 k 와 소수의 제곱의 합의 차이입니다. .

F (k)를 자신이 계산된다 k-sumabs2(k|>factor|>keys)인자 (k)를 주요 키 및 지수 값에 딕셔너리는 모든 키 (소인수)을 추출하고 그 사각형 및 감산 결과로부터 정수의 합을 얻어 k .

마지막으로, 생성 된 튜플의 사전 사전 최대 값을 가져 와서 인덱스 2 및 1 에 액세스하여 뒤집습니다 .

클로저, 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)))))

규칙을 따르십시오. 각 숫자의 소인수를 계산하여 제곱하여 합합니다. 그런 다음 두 요소의 벡터 목록을 생성하십시오 : 초기 번호 및 결과 및 최대 값이 두 번째 요소 인 요소를 찾으십시오.

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

온라인으로 사용해보십시오!

파이크, 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=$_. 전체 범위를 반복 한 후에는 단순히 공백 사이에 출력합니다.

하스켈, 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, 제곱 및 합계를 모두 유지하십시오 .

파이썬 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에서 .

자바 스크립트 (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