이 답변 연쇄 도전은 공식적으로 끝났으며, 결과적으로 밀 마법사 의 승리를 거두었 으며 총 7 개의 답변이 있습니다. 다른 답변은 환영하지만이 도전에 대한 승인 된 답변이나 승자에게는 영향을 미치지 않습니다.

직무:

x입력 한 숫자의 양의 제수를 모두 인쇄하십시오 .

입력:

단수 x긍정적 약수 계산한다 (10 진수)의 수이다.

산출:

의 모든 양의 제수입니다 x. 모든 형식을 포함하여, 허용 \n, ,, ;한이 이해할으로, 구분 기호로 및 공백. 출력도 정수 또는 문자열의 배열 일 수 있습니다 (예 :) [1, 2, 3, 5, 30]. 제수를 stdout, 콘솔 또는 해당 언어의 동등한 것으로 출력 하거나 함수에서 반환 할 수 있습니다 .

규칙

• 사용자가 연속으로 두 번 대답 할 수 없음
• 답변은 이전 답변 에서 최대 15 자를 제거, 추가 또는 교체 할 수 있으며 (공백은 포함되지 않음), 답변 2 는 최대 20 자를 "변환하여" 작업을 시작할 수 있습니다.
• 이미 답변이있는 프로그래밍 언어로 답변을 게시 할 수 없습니다. 예외 는 해당 언어와 완전히 다른 버전입니다 (예 :에 답변을 게시하면에 답변을 Python 2.7제출할 수 Python 3있지만에는 제출할 수 없음 Python 2.6).
• 표준 허점 은 허용되지 않습니다
• 이 도전을 위해 제수를 얻는 데 내장 기능을 사용할 수 없습니다.
• 질문 제목에 답변 번호와 언어 이름을 포함하고 이전 답변에서 변경된 문자 수 를 포함 해야합니다.

채점

일단 제출이 완료되면 가장 많이 제출 한 사용자가 승리합니다. 동점 인 경우, 답변 중 하나에서 가장 높은 점수를받은 사용자가 승리합니다. 점수에 동점이 있으면 가장 오래된 제출 (가장 오래된 최고 점수 답변)을 가진 사용자가 승자로 선언됩니다.

참고 : " 최종 답변 "<=> 7 마지막 답변이 제출 된 후 3 일 이 지났습니다.

예 :

Input, Output:

14 => [1, 2, 7, 14]
25 => [1, 5, 25]
65 => [1, 5, 13, 65]
114 => [1, 2, 3, 6, 19, 38, 57, 114]

또는 언급 된 조건을 만족하는 다른 동등한 출력.

최종 참고 사항 :이 질문은 가장 오래된 답변을 정렬하면 좋습니다. 파이썬 2.7에서 첫 번째 답변을 게시 할 것이므로 그 답변에 따라 두 번째 답변을 게시해야합니다. 행운을 빌고 재미있게 보내!

리더 보드 :

이 목록은 오래되어 편집 할 수 있습니다.

1) 밀 마법사 [현재 리더 🏆] : 7 개 답변 - 파이썬 1.6 , 05AB1E , 사실 , 델 | m | t , WSF , 뇌 - 플랙 , Lenguage

2) 라일리 : 3 답변 - 진심으로 , CJam , 2sable

3) 조나단 앨런 : 2 개 답변 - 파이썬 3 , 젤리

3) ETHproductions : 2 개 답변 - JAPT , Pyth

3) Mistah 피긴스 : 2 개 답변 - 비 펀지-98 , 뇌 - 플랙 클래식

6) 라이 커 : 1 대답 - MATL

6) dzaima : 1 대답 - SOGL 0.8.2

6) LegionMammal978 : 1 답변 - 공백

6) Nick Clifford : 1 답변 - 옴

6) 린 : 1 대답 - GolfScript

6) MickyT : 1 대답 - Cubix

거리 계산기

이 스 니펫을 사용하여 두 항목 사이의 거리를 계산할 수 있습니다.

function L(s,t){if(s===t)return 0;var S=s.length,T=t.length;if(S*T===0)return S+T;for(var i=0,v0=[],v1=[];i<=T;i++)v0[i]=i;for(i=0;i<S;i++){v1[0]=i+1;for(var j=0;j<T;j++)v1[j+1]=Math.min(v1[j]+1,v0[j+1]+1,v0[j]+(s[i]!=t[j]));for(j=0;j<=T;j++)v0[j]=v1[j]}return v1[T]}

<textarea id=A rows=10></textarea><textarea id=B rows=10></textarea><br>
Distance: <span id=O>0</span> <button onclick="O.innerHTML=L(A.value.replace(/\s/g,''),B.value.replace(/\s/g,''))">Run</button>

답변 20, Brain-Flak , 11

이 목표를 달성하는 데 도움을 주신 모든 분들께 감사의 말씀을 전합니다.

• 라일리, 20 바이트

• LegionMammal, 15 바이트

• ETH 프로덕션, 11 바이트

• 린, 1 바이트

다음 사용자는 바이트를 직접 제공 할 수 없었지만 다른 방법으로 도움을 받았습니다.

• 미스타 피겨

• DJMcMayhem

• 페어 섬

이것을 가능하게 해주셔서 감사합니다!

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw
)((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}
#R
{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

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

답 3 : MATL, 거리 15

:tGw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)

답변 7, apt, 15

ò f!vU"Gw\((()<>))
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)#Rḍ⁸T”

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

변경된 #b∫I:b;\?t로 ò f!vU(10 점)과 바꿈으로써 좀 더 뇌 플랙 코드를 추가 ~(()로 ((()<>))(5 점). 우리가 노력하고있는 코드는

((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

설명

ò           Generate the range [0...input].
  f         Filter to only items Z where
   !vU        U.v(Z) returns truthily. (`fvU` would be Z.v(U))
              This returns true if U is divisible by Z, false otherwise.
      "...  The rest of the program is enclosed in this string, which is passed as an extra
            argument to `f`. Fortunately, `f` ignores it.
            Implicit: output result of last expression

답변 8, 05AB1E , 14

"'ò f!vUGw\((()<>)){((({'
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)
'#Rḍ⁸T”'".e

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

설명

운 좋게도 05AB1E에는 내장 파이썬 인터프리터가 있습니다. 이 실행을 위해 우리는

'ò f!vUGw\((()<>)){((({'
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)
'#Rḍ⁸T”'

스택 맨 위에 문자열로. 05AB1E는 실제로 파이썬 코드의 주석을 좋아하지 않기 때문에 주석 대신 문자열 리터럴을 사용해야합니다. 또한 "원래 코드에서 문자열을 조기에 종료시키기 때문에 코드를 제거해야합니다 .

문자열이 푸시되면 .e파이썬 코드로 실행하는 데 사용 됩니다.

Brain-Flak을 향한 노력

Brain-Flak 답변을 목표로 5 명의 캐릭터를 추가 할 수있었습니다. 6을 추가 할 수 있었지만 공백을 잊어 버린 점은 포인트 점수에 포함되지 않습니다.

지금까지 우리는 :

((({})<>)){((({}     ((  )   )       (              <              )           (          )   )
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

답변 13, Pyth , 15

f!%QTS|Q"@░┼_¥
f!vUGw((({})<>)){((({}[()]n=int(input({})(<>))i=1div=while((<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.eX
╜R;`;╜%Y*`M∩

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

설명

그래서 나는 Pyth를 많이 알지 못하지만, 내가 아는 것은 소스 코드가 트리 형태이며 각 명령은 오른쪽에 특정 수의 인수를 취한다는 것입니다. 내가 쓴 제수 프로그램의 트리는 다음과 같습니다.

     f
    / \
   !   S
   |   |
   %   Q
  / \
 Q   T

Q입력입니다. f두 개의 인수를 사용 F하고 true 값을 반환하는 위치 A의 항목 T을 반환합니다. 이 경우, NOT의 논리를 반환하는 함수 , 및 인 범위를 생성하는 . 이 단지 정수로 필터링의 효과가 에서 어디 .AF(T)FQ%TASQ[1...Q]T[1...Q]Q%T == 0

나머지 코드를 구문 분석하지 않으려면 전체 내용을 문자열로 |Q"...묶은 다음 논리 OR Q및 문자열 을 반환 합니다. Q항상 긍정적 이기 때문에 항상 진실이므로 논리 OR에서 항상 반환됩니다.

Brain-Flak을 향한 노력

((({})<>)){((({}[()] (({})(<>))      ((             <>                 )   )  {(          )  })}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

답변 16, GolfScript, 15

~:
),(;{
\%!},p#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}<>)){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

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

~:␤),(;{␤\%!},p#크기 제약 조건에 맞게 개행을 변수 이름으로 사용하여을 추가 하고 전체 프로그램을 한 줄로 다시 작성하여 주석 처리했습니다. 이것은 내가 추가, 그리고 거리 (14)이었다 {전에 }printdiv뇌 - 플랙을 위해.

~:␤                    Read input, store as NL
   ),(;                Range [1, 2... NL]
       {␤\%!},         Filter elements that divide NL
              p#       Print and comment everything else out

Brain-Flak을 향한 노력

((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}     <>                 )   )  {(          ) {})}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

답변 17, CJam , 15

qd:A
),(;
{A\%!},p
e#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{)){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

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

qd:A     # Get input as decimal and store it in A
),(;     # range [0..A]
{    },  # Filter where
 A\%!    # A mod this value == 0
       p # print 
e#...    # comment

Brain-Flak을 향한 노력

)({}((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{            )   )  {(          ) {})}{}
 (  (( {})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

답변 4- 젤리 , 4

:tGw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)Rḍ⁸T

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

관련 코드 :

Rḍ⁸T

는 )지금까지 파서가 (내가 믿는)에 관한 한 링크 사이의 휴식 역할을합니다.

내장은 것 ÆD대신은 범위를 생성 1하여 입력을 R갖는 입력에 의한 정제를 검사, ḍ⁸다음과 truthy 하나 기반 인덱스의리스트를 반환한다 T.

답 9, 공백, 15

f!vUGw((({})<>)){((({}n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e<SPACES>

여기서 <SPACES>다음 문자열로 대체됩니다. 여기서 T0x09 L는 0x0A S이며 0x20입니다.

SSSLSLSTLTTTTTSSSLLSSSLSTSSTLSTSSTLTSSTLTSSSLSSSTLTSSSSTSSTLSTSSTLTSTTLTSTLLSLSL
LSSTLSLSTLSTSSSTSTSLTLSSLSLSLLSSSSLLLL

명확성을 위해 리터럴 줄 바꿈이 추가되었습니다. 규칙은 공백이 아닌 문자 만 지정합니다. 아니, 나 자신을 도울 수 없었다.

Brain-Flak을 향한 노력

나는 이전에 무슨 일이 있었는지 전혀 모른다.

((({})<>)){((({}     ((  )   )       (              <              )           (          )   )}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

답변 18, WSF , 15

q   

































































    d:A(),(;{A\%!},pe#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw)(({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

(이는 문자 코드를 통해 입력 및 출력을 취합니다)

설명

WSF는 brainfuck의 일반적인 연산자 세트 대신 공백을 사용하는 것을 제외하고는 본질적으로 brainfuck입니다. 다음은 brainfuck로 디 컴파일 된 코드입니다.

,
[->+>>>>+<<<<<]>

[
[-<+>>>>+<<<]<[->+<]
>>>>>[-<<+>>]<[->+<]<
[>+>->+<[>]>[<+>-]<<[<]>-]
>>[-]+>[<->[-]]
<
[<<<<.>>>>-]<[->+<]<<<
-
]

Brain-Flak을 향한 진전

WSF는 공백 일 뿐이므로 Brain-Flak 코드에 15자를 더 추가 할 수있었습니다. 이로 인해 답변이 15에서 멀어 지므로 자유롭게 게시하십시오.

()({})(({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})>  )  {(          ) {})}{}
()({})(({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

Brain-flak 답변을 직접 게시하지 않기 때문에이 목표에 기여한 모든 사람에게 감사의 말을 전합니다.

• 라일리, 16 바이트

• LegionMammal, 15 바이트

• ETH 프로덕션, 11 바이트

• 린, 1 바이트

다음 사용자는 바이트를 직접 제공 할 수 없었지만 다른 방법으로 도움을 받았습니다.

• 미스타 피겨

이것을 가능하게 해주셔서 감사합니다!

답변 19, 2sable , 15

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>){ifn%i==g00div.append(>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"
ILD¹s%_Ï,

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

여분의 공백을 제거하고 이전에 존재했던 모든 것을 문자열로 감싼 다음 :

IL        # Push [1 .. input]
  D       # Duplicate
   ¹s%    # For each element: input % element
      _   # Logical not
       Ï  # Keep the values from [1 .. input] where this is 1
        , # print

답변 21, Cubix , 15

고맙게도 그것은 내가 방해했을 것이라고 생각하기 때문에 Brain-Flak 답변이 끝난 후입니다. 구현하려면 전체 15 개가 필요했습니다.

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw
)(Is{})%?;ONou{((({}[()]<n=int(inpu;<@!-;<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}
#R
{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

이것은 다음 큐브에 매핑됩니다

              " q d : A ( )
              , ( ; { A \ %
              ! } , p e # &
              f ! 0 p v ' %
              Q T S | Q @ ░
              ┼ _ ¥ f : : +
              ! v U G w ) (
I s { } ) % ? ; O N o u { ( ( ( { } [ ( ) ] < n = i n t
( i n p u ; < @ ! - ; < > ) ) > < > ) < { i = 1 d i v =
w v h i l e ( ( { } ) ) { ( { } [ ( ) ] ) < > } { } } {
} < > ( [ { } ( ) ] { } ) > < > ) < > { i f n % i = = g
0 0 d i v . a p p e n d ( < { } < > { } < > > i ) i = i
+ 1 } { } p r i n t d i v ) } # R { } T : . e X ╜ R ; j
` ; ╜ 0 % Y * ` M ∩ \ " I L D ¹ s % _ Ï , . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .

여기 에서 시도해 볼 수는 있지만 붙여 넣어야합니다. 일부 스페셜이 퍼머 링크에 문제를 일으키는 것으로 의심됩니다.

코드는 본질적으로 2 줄 이상입니다. 중요한 부분은 다음과 같습니다.

I s     ) % ? ; O N o u 
        u ; < @ ! - ; 

I s )이것은 입력을 얻고 스택의 상단을 바꾸고 (0도 작동했을 것입니다) 증가시킵니다
% ?. mod와 test를 얻습니다. 0이 리디렉션으로 전달 또는 드롭 다운되는 경우
; O N o모드 결과를 삭제하고 숫자와 줄 바꿈을
u차례로 출력합니다. 아래 라인을 켭니다.
다음은 순서대로 실행
; - ! @ 됩니다. 스택에서 10을 제거하고 입력에서 숫자를 빼고 0이면 테스트를 종료합니다
< ; u첫 번째 테스트를 위해 대상을 리디렉션하십시오. 스택 상단을 제거하고 (mod 또는 빼기 결과) u를 돌려 다시 증가시킵니다

답 6, 파이썬 1.6, 15

#b∫I:b;\?t"Gw\~(()
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)#Rḍ⁸T”

%기호를 제거하고 첫 번째 줄과 마지막 줄을 주석 처리했습니다. 이것만으로도 15 포인트 중 10 포인트가 듭니다. 그러나 나는 아직 끝나지 않았다. 파이썬 (1)이 없기 때문에 +=나는 대체했다 i+=1로 i=i+1나에게 추가로 3 점을 요. 내가 2 남았으므로 ((시작 에도 추가 했습니다. 나중에 Brain-Flak에 제출할 계획이며 Parens가 필요합니다.

답변 10, 옴 , 거리 5

@░┼_¥
f!vUGw((({})<>)){((({}n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e<SPACES>

... 여기서 공백 응답의 <SPACES>괴물 문자열로 대체됩니다 .

다른 모든 것은 실행되지 않은 와이어이기 때문에 약간 건방진 대답입니다.

답변 12, 진지하게 , 15

╩"@░┼_¥
f!vUGw((({})<>)){((({}[()]n=int(input())i=1div=while((<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.e"X
╜R;`;╜%Y*`M∩

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

로부터 유일한 차이점 사실 대답은 진심으로 실제로 사용하는 기능을 표시하는 역 따옴표를 사용한다는 것입니다 ⌠및 ⌡문자열로 우리는 단지 추가 문자를 확인 후 팝업 및 폐기합니다.

Brain-Flak을 향한 노력

((({})<>)){((({}[()] ((  )   )       ((             <>                 )   )  {(          )  })}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

답변 14, Del | m | t , 15

                                                f!%QTS|Q"@░┼_¥f!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=while(({})){({}<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.eX╜R;`;╜%Y*`M∩

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

설명

공백이 여기의 차이로 계산되지 않는다는 사실을 실제로 악용하기 시작했습니다. Del | m | t는 여러분이 어떤 문자를 사용하든 신경 쓰지 않으므로 대부분의 코드는 프로그램 시작 부분의 공백과 캐리지 리턴입니다. 코드의 실제 보이는 부분은 전혀 실행되지 않습니다.

보다 "합리적인"형식으로 작성된 코드는 다음과 같습니다.

O R ^ V O @ A K T A J O @ A K U N R O @ B K U @ A K T Q ^ X @ B K T R ^ P O @ A K T K R ^ _ @ ^ @

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

저수준에서 작동하는 방법

시작 O R ^ V 하기 위해 첫 번째 루프에서 입력을 받고 다른 모든 시간에는 no-op로 작동합니다.

그런 다음 O나중에 입력 사본을 만드는 데 사용 합니다.

@ A K T메모리 위치 -1 (프로그램 시작시 0)에 저장된 변수를 불러 A J와서 증가시킵니다. O @ A K U다음 증가하는 루프를 위해 이제 증가 된 값을 메모리 위치 -1에 다시 저장합니다.

N우리는 잠시 뒤로 단지 메모리로부터 리콜 값 이루어지는 입력 복사본의 개조 계산 R을 Negate 그것을.

함께 N R입력을 TOS로 나눌 수 있는지 여부를 나타내는 부울을 작성하십시오.

이 부울 사본을 사용하여 메모리 공간 -2에 저장하고를 사용하여 메모리 공간 -2 O @ B K U에서 값을 호출합니다 @ A K T.

Qboolean이 맨 위에 있는지 확인하고 boolean이 true를 사용하여 값을 출력하도록 상위 두 요소를 바꿉니다 ^ X.

부울이 거짓이면 추가 값이 제거되어 공간 -2에 저장된 부울을 기억 @ B K T하고 값이 false 인 경우 값을 팝합니다 R ^ P.

입력 값을 복제하고 O메모리 -1에서 값을 빼십시오 @ A K T K. 이것이 0이면 종료 R ^ _합니다.

마지막으로 @ ^다음 값이 무엇이든 건너 뜁니다. @코드의 보이는 부분에 의해 생성 된 정크 (실제로는 심볼 만)가 있기 때문에 이것이 필요 합니다.

일단 끝에 도달하면 시작으로 되돌아갑니다.

높은 수준에서 작동하는 방법

기본 아이디어는 루프 할 때마다 증가하는 값을 메모리 위치 -1에 주로 저장한다는 것입니다. 그 값이 입력을 나누면 출력하고 두 값이 같으면 실행을 종료합니다.

Brain-Flak을 향한 진전

공백이 차이로 계산되지 않기 때문에 15 점을 사용하지 않고 코드를 변경할 수 있었으므로 모든 것이 Brain-Flak 코드에 투자되었습니다.

여기 우리의 현재 상태가 있습니다.

((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}     <>                 )   )  {(          )  })}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

답변 15, Befunge-98, 15

&f!0pv
'         %QTS|Q" @ ░┼_¥f
:
:      
+      
!         vUGw(((   {})<>)){((({}[()
]    <    n=int(i   nput({})(<>))><>)
<      {i=1di     v
  =
w    v  
       hile(({      })){({}<>)){ifn%i==
g
0
0    div.app   en   d(i)i=i+1}printdiv)}#R{}T
:      
.    eX╜R;
j      
`      ;╜
0      
%  Y*`M∩
\

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

(아마도 불필요한 공백이 많을 수도 있지만 지금 당장 골프를 칠 필요는 없습니다)

나는 Befunge 프로그램에 15 개를 모두 사용 했으므로 이번에는 Brain-flak를 변경하지 않았다.

이것에 대한 나의 주요 전략은 IP를 수직으로 보내고 공백을 사용하여 기존 코드에서 특정 문자를 실행하는 것이 었습니다.

설명:

Befunge 프로그램에 중요한 코드는 다음과 같습니다.

&f!0pv
'                 @
:
:
+
!
]    <
<                 v
w    v
g
0
0    d
:
.    e
j
`
0
%    `
\

다음과 같습니다.

&f!0pv   Gets input, and stores it at (0, 0) (where the & is)
         The v goes down, hits the < and ], which turns the IP up along the first line

!+::'&   There is a 0 at the bottom of the stack, so ! changes it to a 1 and + increments
         :: duplicates twice, and '& gets the input value

\%       swaps the input and iterator mods them
  0`j.   Checks if input mod iterator is 0 - if it is, print iterator

:00gw    gets the input again, and compares it to the iterator.
         If they are different, the IP travels right to the v
         Otherwise, it continues straight, and hits arrows leading to the end (@)

de`      pushes 0, to be used in the increment line

답변 2- Python 3 , 5

n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i+=1
print(div)

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

답변 5- SOGL 0.8.2 , 9

b∫I:b;\?t"Gw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)Rḍ⁸T”

설명:

b∫              repeat input times                [0]
  I             increment (the loop is 0-based)   [1]
   :b           duplicate                         [1, 1]
     ;          put the input one under the stack [1, 114, 1]
      \?        if divides                        [1, 1]
        t        output                           [1, 1]
         "...”   push that long string            [1, 1, "Gw\~...Rḍ⁸T"]

참고 : 인터프리터는 현재 입력으로 계산하지 않기 위해 \ns를 대체 해야 ¶하지만 파서 자체는 둘 다 교환 가능하다고 간주합니다.

답변 11, 실제로 , 15

╩@░┼_¥
f!vUGw((({})<>)){((({}]n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e
╜R;⌠;╜%Y*⌡M∩

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

설명

실제로 ÷여러 가지 요인을 찾기에 좋은 내장 기능 이 있지만 이러한 내장 기능을 사용할 수는 없습니다.

나는 입력을 레지스터에 저장하는 것으로 시작하여 앞으로 올 일에 의해 피해를 입지 않도록합니다. 나는 이것을 사용하여 수행 ╩하지만 사용 가능한 다른 명령 중 하나를 쉽게 사용할 수 있습니다.

그런 다음 이미 가지고있는 코드를 붙여 넣습니다 (공백하기 때문에 모든 공백을 제거했습니다. "공백이 포함되지 않기 때문에"). 운 좋게 이것은 스택이 비어있을 때 아무것도하지 않습니다.

그런 다음 나머지 프로그램이 있습니다

╜   Pull our input from the register
R   Create the range of n
;   Duplicate the range
⌠   Declare a function
 ;  Duplicate n
 ╜  Pull from register
 %  Mod
 Y  Logical not
 *  Multiply by n
⌡   End Function
M   Map the function across the range
∩   Remove the zeros with a Intersection

Brain-Flak을 향한 노력

그 모든 일과 나는 하나의 여분의 paren을 얻을 수있었습니다.

((({})<>)){((({}   ] ((  )   )       (              <              )           (          )   )}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

23, 브레인 플락 클래식, 13

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(Is(({})<>))%?;ONou{((({}[]<n=int(inpu;({})(@!-;<>))><>)<{i=1div=wvhile(({})){({}[])<>}{}}{}<>({<({}[])>[]}[]{}{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

원래 @Wheat Wizard 는 답변 22와 같이 두뇌 고전 코드를 게시했습니다.

()({})((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>({<({}[]{})           ><>)<>{(<{}<>{}<>>)}{})}{}
()({})((({})<>)){((({}[  ]<(({})(<>))><>)<{(({})){({}[  ])<>}{}}{}<>({<({}[]  )>[]}[]{}{})><>)<>{(<{}<>{}<>>)}{})}{}

이것은 17 문자입니다. 그러나 {})제안 된 코드에서 더 오른쪽으로 이동하여이를 압축 할 수있었습니다.

()({})((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>({<({}[]         {})><>)<>{(<{}<>{}<>>)}{})}{}
()({})((({})<>)){((({}[  ]<(({})(<>))><>)<{(({})){({}[  ])<>}{}}{}<>({<({}[])>[]}[]{}{})><>)<>{(<{}<>{}<>>)}{})}{}

13 글자 만 남았습니다! 그래서 내가 한 것은 제안 된 코드를 얻기 위해 대괄호를 추가 / 제거하는 것입니다.

내가 게시 한 원래 코드에는 오타가 있었으며 이제 수정되었습니다. ( 감사합니다 @WheatWizard! )

답변 1- Python 2.7

n=input()
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i+=1
print(div)

거리 : NA- 첫 번째 답변

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

22, 언어 , 15

Lenguage는 프로그램의 내용에 대한 기간이 아닌 시간에만 관심을 두는 esolang입니다. 따라서 마지막 프로그램에 적절한 양의 공백을 채워서 원하는 언어 프로그램을 만들 수 있습니다. Lenguage는 brainfuck로 컴파일되어서 얼마 전에 작성한 brainfuck 프로그램을 재사용 할 것입니다

,[->+>>>>+<<<<<]>[[-<+>>>>+<<<]<[->+<]>>>>>[-<<+>>]<[->+<]<[>+>->+<[>]>[<+>-]<<[<]>-]>>[-]+>[<->[-]]<[<<<<.>>>>-]<[->+<]<<<-]

나중에 답할 수 있도록 주 프로그램을 약간 변경했지만 최종 결과는 다음과 같습니다.

<SPACES>"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(Is(({})<>))%?;ONou{((({}[()]<n=int(inpu;({})(@!-;<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>({<[{}[]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

여기서 55501429195173976989402130752788553046280971902194531020486729504671367937656404963353269263683332162717880399306 공백 문자를 <SPACES>나타냅니다 .

공백을 남용하는 것이 규칙을 세지 않습니까? 혹시.

Brain-Flak Classic을 향한 노력

우리는 그 모든 parens를 이미 가지고 있었기 때문에 Brain-Flak Classic으로가는 길에 우리를 시작할 것이라고 생각했습니다.

()({})((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>({<({}[]         {})><>)<>{(<{}<>{}<>>)}{})}{}
()({})((({})<>)){((({}[  ]<(({})(<>))><>)<{(({})){({}[  ])<>}{}}{}<>({<({}[])>[]}[]{}{})><>)<>{(<{}<>{}<>>)}{})}{}