도전:

의 범위에0 to Infinity 음수가 아닌 정수가 배열되어 있으면 모두 소수인지 확인하십시오. (원하는 경우 문자열로 입력 할 수도 있습니다)

입력:

입력 : 숫자 배열

출력 : 모든 요소가 다음 중 하나로 대체 된 배열 :

-1                 -----> If 0, 1
1                  -----> If it is a prime number greater than 1
the highest factor -----> If that number is not prime

-1 (0, 1), 1 (프라임> = 2) 또는 주어진 숫자의 가장 큰 요소 (프라임이 아닌 경우)를 반환

예 :

[1, 2, 3, 4, 10, 11, 13]                        ---> [-1, 1, 1, 2, 5, 1, 1]
[100, 200, 231321, 12312, 0, 111381209, 123123] ---> [50, 100, 77107, 6156, -1, 1, 41041]

노트 :

입력은 항상 유효합니다. 즉, 숫자로만 구성되고 소수는 테스트되지 않습니다. 배열은 비어있을 수 있습니다. 그렇다면 빈 배열을 반환하십시오.

제한:

이것은 코드 골프 이므로 각 언어 당 승리하는 가장 짧은 코드 (바이트)입니다.

리더 보드 :

다음은 일반 리더 보드와 언어 별 수상자 개요를 생성하는 스택 스 니펫입니다.

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

# Language Name, N bytes

N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :

# Ruby, <s>104</s> <s>101</s> 96 bytes

헤더에 여러 개의 숫자를 포함 시키려면 (예 : 점수가 두 파일의 합이거나 인터프리터 플래그 페널티를 별도로 나열하려는 경우) 실제 점수가 헤더 의 마지막 숫자 인지 확인하십시오 .

# Perl, 43 + 2 (-p flag) = 45 bytes

언어 이름을 링크로 만들어 리더 보드 스 니펫에 표시 될 수도 있습니다.

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=163882,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

젤리 ,  7 6 바이트

ÆḌṪ€o-

음이 아닌 정수 목록을 승인하고 -1 이상의 정수 목록을 다시 작성하는 모나드 링크.

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

어떻게?

참고 :

• 모든 소수는 하나의 적절한 제수를 갖습니다 (하나)
• 모든 합성물에는 여러 개의 적절한 제수가 있습니다 (하나 더하기 다른 것)
• 적절한 제수 로 숫자가 없습니다
• 젤리의 적절한 제수를 얻는 원자 ÆḌ는 오름차순으로 적절한 제수를 나열합니다.
• 0과 1은 적절한 제수를 갖지 않습니다 (프라이머도 합성도 아닙니다)
• Ṫ빈 목록에 젤리의 꼬리 원자를 적용 하면 0이됩니다.
• 숫자의 제수는 0이 아닙니다 (최대 값 만 포함).
• 젤리에서는 0이 아닌 모든 숫자가 진실이고 0은 거짓입니다.

ÆḌṪ€o- | Link: list of integers   e.g. [ 0, 1,  2,  5,     10,    5183]
ÆḌ     | proper divisors (vectorises)  [[],[],[1],[1],[1,2,5],[1,71,73]]
  Ṫ€   | tail €ach                     [ 0, 0,  1,  1,      5,      73]
     - | literal minus one
    o  | logical OR (vectorises)       [-1,-1,  1,  1,      5,      73]

젤리 , 9 8 바이트

@Dennis 덕분에 1 바이트 절약

:ÆfṂ€$~~

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 실행

댓글

우리는 모두 그 사실을 활용 nan하고 inf될 0비트 단위 그들에게 적용되지 때 젤리에.

:ÆfṂ€$~~ - main link, taking the input list
 ÆfṂ€$   - treat these two links as a monad:
 Æf      -   get the lists of prime factors (0 --> 0; 1 --> empty list; prime --> itself)
    €    -   for each list,
   Ṃ     -   isolate the minimum prime factor (turns empty lists into 0)
:        - divide each entry by its minimum prime factor (0/0 --> nan; 1/0 --> inf)
      ~~ - bitwise NOT x2 (nan or inf --> 0 --> -1; other entries are unchanged)

R, 68 62 바이트

Map(function(n,v=rev(which(!n%%1:n)))"if"(n<2,-1,v[2]),scan())

라이브러리가없는 기본 R 만 사용하는 솔루션! 6 바이트를 골라 낸 Giuseppe에게 감사드립니다.

용도는 scan, 숫자의 공백으로 구분 된 목록에서 읽어 %%요인을 식별 할 수 있습니다. v그런 다음 모든 요소의 벡터를 오름차순으로 포함합니다 (1과 n 포함). 이것은 우리가 때 좋은 특성이있다 revERSE v에, 우리가 원하는 숫자가 비싼 전화를 피하고, 두 번째 자리에있을 것 length또는 tail(경우 n주요이었다 v포함 n 1, 그렇지 포함 n (factors in descending order) 1).

출력 예 (TIO 링크는 여기 ) :

> Map(function(n,v=rev(which(!n%%1:n)))"if"(n<2,-1,v[2]),scan())
1: 0 1 2 3 4 5 6 7 8 9
11: 
Read 10 items
[[1]]
[1] -1

[[2]]
[1] -1

[[3]]
[1] 1

[[4]]
[1] 1

[[5]]
[1] 2

[[6]]
[1] 1

[[7]]
[1] 3

[[8]]
[1] 1

[[9]]
[1] 4

[[10]]
[1] 3

당신이 목록이 허용 반환 형식이 아니라고 생각한다면, 스왑 Map을 위해 sapply3 바이트를 추가합니다.

05AB1E , 11 9 8 바이트

Ñε¨àDd<+

@Emigna 덕분에 -3 바이트 ©d1-®+가 Dd<+와 ۬ۈ로 변경 되었습니다 ε¨à.

내 두 번째 05AB1E 답변 만 확실히 골프를 칠 수 있습니다 .

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

설명:

Ñ           # Divisors of each item in the input-list (including itself)
            #  [1,2,10,3] → [[1],[1,2],[1,2,5,10],[1,2,3]]
 ε          # For each:
  ¨         #  Remove last item (so it's now excluding itself)
            #   [[1],[1,2],[1,2,5,10],[1,2,3]] → [[],[1],[1,2,5],[1,2]]
   à        #  And get the max
            #   [[],[1],[1,2,5],[1,2]] → ['',1,5,2]
    D       # Duplicate the list
     d      # Is it a number (1 if it's a number, 0 otherwise)
            #  ['',1,5,2] → [0,1,1,1]
      <     # Subtract 1
            #  [0,1,1,1] → [-1,0,0,0]
       +    # Add both lists together
            #  ['',1,5,2] and [-1,0,0,0] → ['-1',1,5,2]

J , 21 바이트

_1:`(%{.@q:)@.(>&1)"0

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

설명:

(>&1)"0 각 숫자가 1보다 큽니까?

@. 그렇지 않은 경우 반환 _1:

(%{.@q:)2 이상인 경우 %숫자를 {.소인수 의 첫 번째 로 나눕니다 .q:

Japt , 6 바이트

골프 후, Jonathan의 솔루션과 거의 동일하고 짧았습니다.

®â¬ÌªJ

시도 해봐

설명

®          :Map
 ⬠       :  Proper divisors
   Ì       :  Get last element (returns null if the array is empty)
    ª      :  Logical OR
     J     :  -1

파이썬 3 , 62 바이트

lambda l:[max([k for k in range(1,n)if n%k<1]+[-1])for n in l]

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

들어 0및 1 range(1,n)따라서 코드에 빈 평가된다 max([]+[-1]) = -1. 소수의 경우 [1, n)의 유일한 제수 1는 원하는 출력입니다.

코코넛 , 50 바이트

map$(n->max([k for k in range(1,n)if n%k<1]+[-1]))

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

자바 (8), 105 (103) 87 바이트

a->{for(int i=a.length,n,x;i-->0;a[i]=n<2?-1:n/x)for(n=a[i],x=1;++x<n;)if(n%x<1)break;}

바이트를 절약하기 위해 새로운 것을 반환하는 대신 입력 배열을 수정합니다.

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

설명:

a->{                  // Method with integer-array parameter and no return-type
  for(int i=a.length,n,x;i-->0;
                      //  Loop backward over the array
      a[i]=           //    After every iteration: change the current item to:
           n<2?       //     If the current item is 0 or 1:
            -1        //      Change it to -1
           :          //     Else:
            n/x)      //      Change it to `n` divided by `x`
     for(n=a[i],      //   Set `n` to the current item
         x=1;++x<n;)  //   Inner loop `x` in range [2,`n`)
       if(n%x<1)      //    If `n` is divisible by `x`:
         break;}      //     Stop the inner loop (`x` is now the smallest prime-factor)
                      //   (if the loop finishes without hitting the `break`,
                      //    it means `n` is a prime, and `x` and `n` will be the same)

하스켈, 52 49 바이트

map(\x->last$[d|d<-[1..x-1],mod x d<1]++[-1|x<2])

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

map                     -- for each element in the input array
  \x->                  -- apply the lambda function
    last                -- pick the last element of the following list
     [d|d<-[1..x-1]     --  all d from 1 to x-1 
           ,mod x d<1]  --    where d divides x 
     ++[-1|x<2]         --  followed by -1 if x<2

껍질 , 8 바이트

m(|_1→hḊ

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

설명

m(|_1→hḊ  Implicit Input         [1,2,3,4,10]
m(        Map each element
       Ḋ    List of divisors     [[1],[1,2],[1,3],[1,2,4],[1,2,5,10]]
     →h     Penultimate element  [0,1,1,2,5]
  |_1       If falsy then -1     [-1,1,1,2,5]

첨부 , 23 바이트

@{Max&-1!Divisors@_@-2}

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

29 바이트, 포인트 프리 : @(Max&-1@Last@ProperDivisors)

24 바이트, 포인트 프리 : @(Max&-1@`@&-2@Divisors)

이것은 단순히 두 번째-마지막 제수를 얻는 n다음 그것의 최대 값을 취합니다 -1. 이하 두 요소 배열의 마지막에서 두 번째 엘리먼트는 nil및 Max[-1, nil]이다 -1. @이 함수를 벡터화하여 각 원자에 적용합니다.

Wolfram Language (Mathematica) , 33 바이트

Divisors[#][[-2]]/._Part:>-1&/@#&

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

R + numbers, 88 79 바이트

주로 제출 방법에 대한 조언에 대한 의견 덕분입니다.

function(y)sapply(y,function(x)"if"(x<2,-1,prod(numbers::primeFactors(x)[-1])))

가장 작은 것을 제외한 모든 소수의 곱을 사용하고 빈 벡터 요소의 곱이 다음과 같이 정의된다는 사실을 사용합니다. 1 .

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

Brachylog , 10 바이트

{fkt|∧_1}ˢ

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

다음 설명은 간결성을 위해 대부분 필수적으로 표현되며 Brachylog의 선언적 특성을 정확하게 반영하지 않습니다.

{          Start of inline predicate.
           Implicit input to the predicate.
 f         Create a list of all of the input's factors (including itself).
  k        Remove the last item of this list so that it no longer contains the original number.
   t       Take the last item of the list with the last item removed.
           Implicitly unify the output with the aforementioned last item.
    |      If that failed, because one of the lists was empty...
     ∧     discarding the input, (there's probably some obvious reason ∨ won't work here but I don't know what it is)
      _1   unify the output with -1 instead.
        }  End of the inline predicate.
         ˢ For every item of the input, unify it with the predicate's input and get a list of the corresponding outputs.

나는 Brachylog를 배우기로 결정했기 때문에 삼투를 통해 실제 프롤로그의 행동을 배우기를 기대하면서 코드 골프로 재미있게 놀 수 있었고, 지금까지 어떻게하는지 확실하지 않더라도 실제로 그것을 즐기고 있습니다. 실행 제어 문자가 작동합니다.

Stax , 14 13 바이트

ü±p╞Ö*«òτ♀╣â▀

실행 및 디버깅

설명 (포장 풀기) :

m|fc%c{vsH1?}U? Full program, implicit input-parsing
m               Map
 |fc%c            Get factorisation and length of it (0 and 1 yield [])
      {     } ?   If length != 0:
       v            Decrement
           ?        If still != 0:
        sH            Last element of factorisation
           ?        Else:
          1           Push 1
              ?   Else:
             U      Push -1

맵 내부의 의사 코드 :

f = factorisation(i)
l = length(f)
if l:
    if --l:
        return f[-1]
    else:
        return 1
else:
    return -1

Pyth, 12 바이트

me+_1f!%dTSt

여기 사용해보십시오

설명

me+_1f!%dTSt
m            Q    For each number d in the (implicit) input...
          Std     ... get the range [1, ..., d - 1]...
     f!%dT        ... take the ones that are factors of d...
  +_1             ... prepend -1...
 e                ... and take the last.

J , 14 바이트

1(%0{q:,-)@>.]

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

모든 숫자 n에 대해 대신 최대 (n, 1)을 사용하십시오.
부정 된 숫자를 소인수 목록 (1의 빈 목록)에 추가하고 목록의 첫 번째 항목으로 숫자를 나눕니다.

또한 14 바이트

(%0{q:) ::_1"0

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

모든 수를 소인수의 첫 번째 요소로 나눕니다. 0은을 사용하여 도메인 오류를 발생시키고 q:빈 목록에서 1의 0 번째 항목을 찾습니다. 이는 오류이기도합니다. 오류가있는 숫자의 경우 -1을 반환하십시오.

Japt , 14 11 8 바이트

®/k v)ªÉ
®        // For each input number,
 /k v    // return the number divided by it's first prime factor,
     )ªÉ // or -1 if such a number doesn't exist (the previous result is NaN).

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

Shaggy 덕분에이 3 개의 성가신 바이트를 제거했습니다 .

자바 스크립트 (Node.js) , 61 55 바이트

@shaggy 덕분에 -6 바이트

_=>_.map(_=>eval('for(v=_/(d=_>>1);v!=~~v;v=_/--d);d'))

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

설명 :

_ =>                                     // input i.e : the original array
    _.map(                               // map over all elements of the array
        eval('                           // eval a string
            for(v=_/(d=_>>1);            // set v = _ / _ >> 1 and set that to d
                v!=~~v;                  // and keep going until v !== floor(v)
                        v=_/d--);        // to _ / d again (d was changed)
                    d'                   // return d
            ))                           // end eval and map and function

이것은 여전히 ​​이전 코드로 업데이트되지 않았습니다.

ES5 친화적 :

 const primeOrNot = function(input) { // the function with argument input
      return input.map(function(value) { // returns the array after mapping over them
           d = Math.floor(value * 0.5); // multiply each element by 0.5 and floor it 
           for(let v = value / d; v != Math.floor(v);) { // for loop goes until v!=~~v
                d --; // subtract one from d
                v = value / d; // set v again to value / d
           }
           return d; // return d
      })
 };

세게 때리다 + GNU 유틸리티, 49

• @Cowsquack 덕분에 9 바이트 절약

factor|sed '/:$/c-1
/: \w+$/c1
s%: %/%
y/ /#/'|bc

설명

• factor STDIN에서 입력 번호를 한 줄에 하나씩 읽고 형식으로 출력합니다. <input number>: <space-separated list of prime factors (ascending)>
• sed 이를 다음과 같이 처리합니다.
  • /:$/c-1 입력 번호 0과 1에는 소수가 없으며 다음과 같이 바뀝니다. -1
  • /: \w+$/c1소수 (소수)를 가진 숫자는 소수입니다. 이것들로 교체하십시오1
  • s%: %/% 바꾸다 : 로/ . 이것은 (프라임이 아닌) 입력 숫자를 가장 작은 소수로 나누는 가장 큰 인수를 제공하는 산술 식을 만듭니다.
  • y/ /#/ 다른 (필요하지 않은) 요인의 목록을 제거하십시오 (주석을 작성하여)
• bc 산술적으로 평가하고 표시

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

파이썬 2 , 61 59 바이트

lambda x:[max(k for k in[-1]+range(1,n)if n%k<1)for n in x]

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

개량

• Dennis의 61 ~ 59 바이트 .

자바 스크립트 (Node.js) , 37 바이트

x=>x.map(a=>(f=t=>a%--t<1?t:f(t))(a))

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

큰 입력을위한 재귀 적 스택 오버 플로우

자바 스크립트 (Node.js) , 41 바이트

x=>x.map(a=>eval('for(t=a;a%--t!=0;);t'))

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

Pari / GP , 37 바이트

a->[if(x<2,-1,x/divisors(x)[2])|x<-a]

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

라켓 , 105 바이트

(λ(L)(map(λ(n)(if(< n 2)-1(p n(- n 1))))L))(define(p n d)(if(= d 1)1(if(=(modulo n d)0)d(p n(- d 1)))))

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

Befunge-98 (FBBI) , 39 바이트

j&:!+f0p1-1:::' -:!j;3k$.nbj;-\%!!j:1+a

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

&더 이상 숫자가 없으면로 끝납니다 . 이로 인해 TIO가 프로그램을 종료 할 때까지 프로그램이 60 초 동안 정지됩니다. 두 통역사가 모두 이것을 수행하기 때문에 TIO에서는 Befunge-98에는 피할 수 없습니다. 재생을 친 후에는 잠시 후에 프로그램이 출력되는 것을보기 위해 약간 후에 프로그램을 중지 할 수 있습니다.

기본적으로 모든 새 숫자에 대해 0이면 1로 바뀝니다. 그런 다음 스택에 -1을 넣은 다음 1부터 시작하여 입력 숫자에 도달 할 때까지 카운트합니다. 스택에 두 번째 숫자를 인쇄합니다 (0 또는 1의 입력에 대해 -1, 다른 항목에 대한 가장 높은 요소). 루프를 통해 매번 반복자의 값을 if ( input % iterator == 0) 뒤에있는 스택에 추가합니다 . 즉, 입력에 도달하면 반복자를 버리고 인쇄하면됩니다. 그런 다음 스택을 지우십시오.n 읽기 입력 기능으로 돌아갑니다.

나중에 설명을 확장 할 수 있습니다.

레티 나 0.8.2 , 33 바이트

%(`^0|^1$
-1
\d+
$*
^(1+)\1+$
$.1

온라인으로 사용해보십시오! Link는 너무 느리지 않은 테스트 사례를 포함합니다. 설명:

%(`

각 입력 번호를 반복하십시오.

^0|^1$
-1

특수 사례 0과 1

\d+
$*

단항으로 변환합니다 (-1에 영향을 미치지 않음).

^(1+)\1+$
$.1

각 숫자를 10 진수로 된 가장 큰 적절한 인수로 바꿉니다.

tinylisp , 75 바이트

(load library
(q((L)(map(q((N)(i(l N 2)(- 1)(/ N(min(prime-factors N))))))L

온라인으로 사용해보십시오! 익명 함수에 이름을 지정하여 바닥 글에서 호출 할 수 있도록 4 바이트가 추가로 포함됩니다.

언 골프 / 설명

1을 반환하는 소수를 관찰하십시오. $n$ 가장 큰 요소는 $n$ 복합 용 $n$ 귀국으로 결합 가능 $n/p$ 어디 $p$ 가장 작은 주요 요소입니다 $n$.

(load library)               Library gives us map, -, /, min, and prime-factors functions

(lambda (L)                  Anonymous function, takes a list of numbers L
 (map                         Map
  (lambda (N)                  Anonymous function, takes a number N
   (if (less? N 2)              If N < 2
    (- 1)                        -1; else
    (/ N                         N divided by
     (min                        the minimum
      (prime-factors N)))))      of the prime factors of N
  L)))                        ... to L