소스 코드를 두 배로 늘리는 데는 몇 가지 문제가 있습니다 . here 및 here . 우리가 여기서하는 일은 조금 어렵지만 거의 모든 언어로 수행 할 수 있어야합니다.

이 도전에서는 임의의 양의 정수를 사용합니다. 프로그램은 정수를 두 배로 출력해야합니다 . 소스 코드가 두 배가되면 양의 정수를 받아 squared로 출력합니다 .

소스 코드는 어떻게 두 배입니까? 글쎄, 당신은 당신의 방법을 가질 수 있습니다 . 말을하는 것입니다, 당신은 바이트 또는 문자의 문자열로 소스 코드를 분할 할 수 있습니다 (또는 토큰 화 된 랭 가문에서 토큰)의 어떤 동일한 원하는 길이 , 그리고 두 번 연속으로 각 청크를 반복합니다.

ABCDEFGHIJKL(길이 12) 의 초기 프로그램의 경우 가능한 모든 이중 프로그램은 다음과 같습니다.

Chunk length |   Doubled source code
-------------+-------------------------
           1 | AABBCCDDEEFFGGHHIIJJKKLL
           2 | ABABCDCDEFEFGHGHIJIJKLKL
           3 | ABCABCDEFDEFGHIGHIJKLJKL
           4 | ABCDABCDEFGHEFGHIJKLIJKL
           6 | ABCDEFABCDEFGHIJKLGHIJKL
          12 | ABCDEFGHIJKLABCDEFGHIJKL

이는 소수 길이의 프로그램은 두 가지 방식으로 만 두 배가 될 수 있음을 의미합니다. 모든 문자가 두 배로 또는 전체 프로그램이 두 번 반복됩니다.

규칙 :

• 코드는 완전한 프로그램 또는 기능이어야합니다.
• 표준 허점은 금지되어 있습니다.
• 표준 I / O 방법이 허용됩니다.
• 공백과 줄 바꿈을 포함한 모든 문자 / 바이트는 코드 길이로 계산되며 청크에 기여합니다.
• 당신은 할 수 입력과 광장이 언어의 INT / 정수형으로 표현 될 수 있다고 가정합니다.
• 당신은 하지 않을 수 있습니다 뒤에 줄 바꿈 또는 다른 문자를 가정합니다.
• 바이트 수 다음에 제목에 청크 크기를 제공하십시오.
• 이것은 code-golf 이므로 짧은 프로그램 일수록 좋습니다! 두 프로그램의 길이가 같은 경우 더 작은 청크 길이를 사용하는 프로그램이 우선합니다. (더 작은 청크 길이를 사용하는 더 긴 프로그램이 있다면, 게시 할 가치가 있습니다!)
• 프로그램에 두 번째 입력 / 라인이 필요한 경우 해당 값을 가정하지 않아도됩니다. 특히, 두 번째 입력이 비어 있거나 첫 번째 입력과 같거나 다른 정수인 경우 프로그램이 작동해야합니다. 프로그램에 두 번째 입력 / 라인이 필요하지 않으면이 제한을 무시해도됩니다.

샌드 박스 링크

Perl 5 , 8 바이트 (청크 크기 4)

$_*=~~+2

온라인 그것을 시도 , 또는 배가 된 버전을 사용해 .

단항 ~은 비트 단위의 부정이므로, 두 번 적용하면 쓸모가 없습니다. 따라서 기본 프로그램은 단순히 $_암시 적 입출력 변수에 2 를 곱 합니다.

이진 ~~은 스마트 매치로 불리언을 반환합니다. ~~+2~~+2로 구문 분석합니다 (~~+2) ~~ (+2). 2는 2와 같으므로 true (1)가됩니다. 따라서 배가 된 프로그램은 먼저 1을 곱한 $_다음 $_자체 를 곱 합니다.

05AB1E , 4 바이트 (청크 크기 2 또는 4)

·Inr

온라인으로 시도 하거나 단일 4 바이트 청크 로 두 배로 또는 2 바이트 청크 로 두 배로 사용해보십시오 .

·        # double the implicit input
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 2]
         # if we stop here: implicitly output the top of the stack (input * 2)
·        # double the top of the stack (giving input * 4, not that it matters)
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 4, input ** 2]
         # implicitly the top of the stack (input ** 2)

Python 3 , 26 바이트 (청크 크기 13)

lambda n:"and n*n#"and 2*n

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

배가 :

lambda n:"andlambda d:"and n*n#"and 2*n n*n#"and 2*n

이 솔루션은 @Grimy에서 제공합니다.

Python 3 , 32 30 28 바이트 (청크 크기 16 15 14)

lambda n:bool(0)*n*n or  2*n

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

@negativeSeven 덕분에 -4 바이트

배가 :

lambda n:bool(lambda n:bool(0)*n*n or  2*n0)*n*n or  2*n

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

함수는이 도전의 고유 한 청크 규칙을 이용합니다.

Befunge-98 (FBBI) , 8 바이트 (청크 길이 2)

;&:#* +q

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

;&;&:#:#* * +q+q

온라인으로 사용해보십시오! (두 배)

제어 흐름을 제외하고 첫 번째 프로그램은 실행 &:+q(입력, 스택 상단 복제, 추가, 리턴 코드로 종료)을 실행하고, 두 번째 실행 &:*+q(입력, 스택 상단 복제, 곱하기, 암시 적 0으로 합산), 리턴으로 종료 암호)

Hexagony , 14 바이트 (청크 크기 14)

?"+==*/}=+!@!<

넓히는:

  ? " +
 = = * /
} = + ! @
 ! < . .
  . . .

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

배가

?"+==*/}=+!@!<?"+==*/}=+!@!<

넓히는:

   ? " + =
  = * / } =
 + ! @ ! < ?
" + = = * / }
 = + ! @ ! <
  . . . . .
   . . . .

온라인으로 두 배로 시도하십시오!

Hexagony는 실제로이 과제를 달성하는 것이 단순히 두 개의 개별 프로그램을 작성하는 것보다 훨씬 어렵지 않다는 점에서이 도전에서 약간 이상한 위치에 있습니다. 그러나 솔루션을 골퍼하는 것은 다소 어려운 것으로 판명되었습니다.

이 솔루션은 내가 생각할 수있는 가장 짧은 형태의 사소한 아이디어이지만 더 짧고 영리한 답변이 있다고 생각합니다. 이 버전은 두 가지 값을 입력에 매우 순진하게 설정하고 소스가 두 배인지 여부에 따라 값을 합산하거나 곱합니다. 유일한 코드 재사용은 "+원래 프로그램의 사용되지 않은 공간에 맞도록 이중 프로그램의 복사 코드를 짧게 만드는 것입니다.

IP 변경 지침 []을 사용하면 부품을 쉽게 분리 할 수 있다고 생각 하지만 진정으로 이상적인 솔루션은 두 제품 사이에 많은 코드를 재사용합니다. 육각형 소스 코드를 두 배로 늘리는 도우미 프로그램 을 만들었습니다 . 마지막 no-ops를 제거하므로 끝에 자리 표시 자 no-ops를 가지려면 다른 문자를 채우고 나중에 변경하십시오. 가능한 각 프로그램을 출력하는 코드를 아직 작성하지 않았지만 다른 청크 크기를 처리 할 수 ​​있습니다 (Hexagony는 전체 청크 크기를 사용하는 것처럼 보입니다).

Hexagony , 12 바이트 (청크 크기 4)

?"2+...}=*!@

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

형식화 :

  ? " 2
 + . . .
} = * ! @
 . . . .
  . . .

그리고 두 배로 한 다음 형식을 지정하십시오.

   ? " 2 +
  ? " 2 + .
 . . } . . .
} = * ! @ = *
 ! @ . . . .
  . . . . .
   . . . .

기본적으로 이것은 첫 번째 모서리를 입력으로 설정 한 다음 두 번째 모서리를 2입력 또는 복사 사본으로 설정 한 다음 두 모서리를 세 번째 모서리로 곱한 다음 인쇄하고 종료합니다. 실행 된 명령어 목록은

?"2}=*!@

과

?"2+}=*!@

유일한 차이점 은 두 번째 프로그램을 +재정의하는 것 2입니다.

자바 스크립트 (ES6),  24  22 바이트

특이한 형식에도 불구하고 이것은 익명 함수의 정의이며 직접 호출하거나 변수에 할당 할 수 있습니다.

+(g=x=>x*x)?g:(x=>x*2)

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

+(g=x=>x*x)?g:(x=>x*2)+(g=x=>x*x)?g:(x=>x*2)

온라인으로 두 배로 시도하십시오!

방법?

단항 +을 함수에 적용하는 것은 함수를 숫자로 강제하려는 시도로 해석되어 NaN이 됩니다. 따라서 +(g=x=>x*x)두 버전 모두에서 선행 이 허위입니다.

반면 +2 개의 함수 사이 에 이진법을 적용하면 문자열이됩니다. 따라서 (x=>x*2)+(g=x=>x*x)배가 된 버전에서는 진실입니다.

펄 6 , 8 바이트 (청크 크기 1)

* *<1 2>

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

Whatever / HyperWhatever 람다는 숫자를 취하여 첫 번째 프로그램의 숫자와 두 번째 프로그램의 싱글 톤 목록을 반환합니다. 기본적으로 이것은 곱셈 연산자 (* )가 지수 )로 대체** .

**  **<<11  22>>

Whatever 리터럴 (혼란스럽고 *a로 표시됨 **)은 목록에 매핑되는 것을 제외하고는 기본적으로 동일한 HyperWhatever ( ) 로 두 배가됩니다 . Whatever 리터럴을 곱셈에서 분리하는 데 공백이 필요하며 두 배가되면 무시됩니다. 그냥 2(두 배가되는 22) 대신 두 개의 요소가 포함 된 목록을 사용합니다 (숫자 컨텍스트에서는 2로 평가됩니다). 는 <>보간 목록으로 배가 될 수 있으며, 내부의 두 요소 배가되지만 목록도 그 변화의 길이.

룬 마법 , 9 바이트 (청크 크기 3)

i3?:*@:+@

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

(가) 3?결과적으로, 다음 3 개 명령들을 스킵 (실행) i3?...:+@. 두 배가되면 3 NOP 명령을 나타내는 실행 i3?...:*@이 .발생합니다. @"전체 스택 인쇄 및 종료"입니다.

C # (Visual C # Interactive Compiler) / Javascript, 22 바이트, 청크 크기 11

m=>/*      /2*m//*/m*2

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

Brain-Flak , 48 30 바이트 (청크 크기 10)

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

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

이것은 기본적으로 세 단계를 거치고 두 배가 될 때 각 단계를 두 번 실행합니다. 초기 프로그램은 다음과 같습니다

1. TOS 복제, 스택 전환 및 가치 추진 시작
2. TOS의 삼각수 n * (n-1) / 2를 구합니다
3. TOS를 팝하고 스택을 전환하고 두 번 팝한 다음 결과를 누릅니다.

n이중화되지 않은 프로그램에 입력 하면 다음과 같은 결과가 발생합니다.

1.  Start stack: n n
    Other stack: <
    Third stack: 
2.  Start stack: n n
    Other stack: 0 <
    Third stack: tri(0) = 0
3.  Start stack: n+n+tri(0) = 2n <
    Other stack:
    Third stack:

이중 프로그램의 경우 :

1a. Start stack: n n
    Other stack: <
    Third stack: 
1b. Start stack: n n <
    Other stack: 0 0
    Third stack: 
2a. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)
2b. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)+tri(0) = tri(n)
3a. Start stack: n
    Other stack: tri(n) <
    Third stack: tri(n)
3a. Start stack: 0+n+tri(n)+tri(n) = n + 2*tri(n) = n + n*(n-1) = n*n <
    Other stack: 
    Third stack: 

Brain-Flak , 76 바이트, 76 바이트 청크

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

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

두 배 (명확성을 위해 줄 바꿈으로)

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

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

다음은 더 복잡한 배가 절차를 사용하는 버전입니다. 크기가 15 인 5 개의 청크를 수행합니다. 여기의 코드는 46 바이트이지만 필요한 패딩으로 인해 실제로 더 깁니다.

105 90 바이트, 15 바이트 청크

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

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

두 배 (명확성을 위해 줄 바꿈)

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

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

Cubix , 18 14 바이트 (청크 길이 9 7)

*OI$|:/@O+:I. 

후행 공백에 유의하십시오. 온라인으로 사용해보십시오!

배가 :

*OI$|:/*OI$|:/@O+:I. @O+:I. 

다시 말하지만, 후행 공간이 하나 있습니다. 온라인으로 사용해보십시오!

설명

코드를 두 배로 늘리면 큐브가 커지므로 명령어 포인터가 다른 기호에서 시작한다는 것이 주된 아이디어입니다. 추가 프로그램을 측면 길이 1의 큐브에 넣을 수 없으므로 측면 길이는 2가됩니다. 또한 이중 코드는 측면 길이 3의 큐브에 있어야하므로 이중 코드는 25 바이트 이상이어야합니다. . 이는 코드 길이가 13 바이트 이상이어야 함을 의미합니다. 따라서 최대 1 바이트를 더 저장할 수 있습니다.

이제 실제 코드입니다. 첫 번째 관찰은 윗면 (즉, 처음 4 자)이 추가 프로그램에서 사용되지 않는다는 것입니다. 또한 5 번째 문자가 큐브 주변의 IP를 반영하게하면 2 개의 문자를 더 확보 할 수 있습니다. 이 문자를 사용하여 제곱 프로그램을 작성합니다.

모닝 턴 초승달 , 656 바이트 (청크 크기 328)

거의 모든 언어로 해결할 수 있다는 이론에 무게를 더하기 만하면됩니다 ...

Take Northern Line to Bank
Take District Line to Bank
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Hammersmith
Take District Line to Upminster
Take District Line to Embankment
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Acton Town
Take District Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Leicester Square
Take Northern Line to Leicester Square
Take Northern Line to Mornington Crescent

(마지막 줄 바꿈이 중요합니다)

단일 버전을 사용해보십시오! ... 또는 ... 두 배로 된 버전을 사용해보십시오!

여기서 이론은 간단합니다. 단일 버전에서 'Bounds Green'은 임의의 문자열로 채워지지만 두 배가 된 버전에서는 제곱 된 입력으로 채워집니다. 청크가 끝나면 두 버전 모두 '입력'을 두 배로 늘리지 만 코드의 두 배 버전에서는 입력이 0으로 대체되었습니다.

이 결과는 출력을 얻기 전에 max () 작업을 두 번 수행하는 Bounds Green으로 다시 가져옵니다. 단일 버전에서는 두 배가 변경되지 않은 상태로 유지되지만 (int와 문자열은 앞뒤로 전환됩니다), 두 배 버전에서는 0을 Bounds Green에 이미 저장된 제곱 결과로 대체합니다.

JavaScript (Node.js) , 15 12 바이트 (청크 크기 : 6)

x=>/**/2*(x)

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

단일 사례 :

x=>/**/2*(x)

더블 케이스 :

x=>/**x=>/**/2*(x)/2*(x)

변화하는 경우도 C #에서의 작업, 자바 것 =>에 ->?

아르 자형 , 42 35 28 바이트 (청크 크기 4)

이제 청크가 작고 오류가 없습니다. 또한 청크 크기 3의 더 긴 솔루션이 있습니다. 아래를 참조하십시오.

청크 크기 1 또는 2의 R 답변을 작성할 수는 없다고 생각합니다. 나는 나를 잘못 증명하는 사람에게 행복하게 현상금을 줄 것이다.

s =scan#
n=s()# 
  
n/2*4#  

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

그만큼 # 제 3 라인 이전 및 다음 청크 더 줄 바꿈을 가질 수 그래서, 줄 바꿈 + 2 개 공간 + 줄 바꿈의 덩어리를 만드는 유일한 공간이다 R.의 의견입니다.

두 배가됩니다.

s =ss =scan#can#
n=s
n=s()# ()# 
  

  
n/2*n/2*4#  4#  

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

단일 버전은 계산합니다.$\frac n2\times4=2n$$\frac n2\times \frac n2\times4=n^2$

다음은 약간 더 긴 해결책이지만 청크 크기 3입니다.

R , 39 바이트 (청크 크기 3)

s =bbb=scan#
n=s(#
 
)# 
n* 1/ 2/ 1* 4#

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

배가 :

s =s =bbbbbb=sc=scan#an#
n=
n=s(#s(#
 

 
)# )# 
n*
n* 1/ 1/ 2/ 2/ 1* 1* 4# 4#

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

주세페에는 또 다른 R 응답이 있으며 한 청크는 30 바이트입니다.

R , 59 30 바이트 (청크 크기 59 30)

F=F+1;f=function(n)n*c(2,n)[F]

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

영감을 얻은 Robin Ryder의 공로 F매번 증가 하고, 기능 f은 적절한 출력을 선택합니다.

이것은 특히 흥미롭지는 않지만, 청크 크기를 조작하는 영리한 무언가가 꿈꾸게 될 것입니다. 예상대로 Robin Ryder는 이것을 생각해 냈습니다. 모두 짧고 산뜻한 약간의 덩어리 조작을 가지고있다.

PowerShell , 22 바이트 (청크 크기 11)

param($p)
#   /
2 * $p

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

배가 :

param($p)
#param($p)
#   /
2 * $p   /
2 * $p

이 솔루션은 @ ShieruAsakoto 's 솔루션을 합니다 .

PowerShell로 변환 된 @Grimy 솔루션 , 26 바이트 (청크 크기 13)

param($p)$t=';$p*$p#';$p*2

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

배가 :

param($p)$t=';param($p)$t=';$p*$p#';$p*2$p*$p#';$p*2

펄 5 (-p ), 22 15 바이트

Grimy 덕분에 -7 바이트

$_*=$'/4||2;//;

TIO

숯 , 13 바이트

ＰＩ×Ｉθ⎇υＩθ²⊞υω

온라인으로 사용해보십시오! 설명 : 사전 정의 된 빈 목록이 거짓이므로 입력에 2가 곱해집니다. 두 번째 패스에서 두 번째 패스는 빈 문자열이 목록으로 푸시 된 것으로 보이므로 대신 입력 자체를 곱합니다. 온라인으로 사용해보십시오! 자세한 구문에서 이는에 해당합니다 Multiprint(Cast(Times(Cast(q), Ternary(u, Cast(q), 2)))); Push(u, w);.

파이썬 3, 56 53 바이트

print(eval(input()+"**2"[len(*open(__file__))%2:])) #

내 파이썬 기술은 다소 빨라서 확실히 골프를 칠 수 있습니다. "" 나는 소스를 두 배로 늘리면 출력을 두 배로! " 입니다.

청크 길이 53.

온라인으로 사용해보십시오 시도 하거나 두 배로 온라인으로 시도하십시오 .

자바 8, 62 바이트

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

청크 길이 62.

온라인으로 시도 하거나 시도두 배로 온라인으로 시도하십시오 .

설명:

n->                    // Method with integer as both parameter and return-type
  n*                   //  The input, multiplied by:
    (Byte.SIZE>8?      //   If Byte.SIZE is larger than 8:
      n                //    Multiply by the input itself
     :                 //   Else:
      2);              //    Multiply by 2
class Byte{            // Class which overwrites Byte
  static int SIZE=9;}  //  And sets the SIZE to 9

Java에서 사용 가능한 주석은 // comment및 /* comment */입니다. 여기에 결합되어 특정 부분을 덮어 씁니다. Java 강조 표시로 이러한 주석이 어떻게 작동하는지 확인하십시오.

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

이중화 된 프로그램은 사용자 정의 Byte클래스와 해당 값을 작성 SIZE=9하여 기본 java.lang.Byte클래스와 해당 값 을 겹쳐 씁니다 SIZE=8.

Japt , 7 5 바이트

*N²jJ

사용해보십시오 | 배가

²2를 입력 배열로 푸시 N한 다음 j인덱스에서 요소 를 제거하고 반환합니다 J=-1(즉, 새로 삽입2 ) 하고 입력 값에 곱합니다.

두 배가되면 J에 곱하는 결과가 2되므로 인덱스의 요소 -2(예 : 입력)가 반환되어 j승수로 사용됩니다.

젤리 , 8 6 바이트 (청크 길이 3)

Ḥ;²3ị 

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

배가

좋은 해결책 : Lua , 66 바이트 (청크 크기 66 바이트)

a,x=a and...^2 or ...*2,setmetatable(x or{},{__gc=load'print(a)'})

온라인으로 사용해보십시오! (자신의 두 배, 그렇게 어렵지는 않습니다)

오, 그래, 이것에 대한 더 짧은 해결책이 있다는 것을 확신하지만, 내가이 방법으로 생각해 낼 수있는 것이 가장 좋습니다. 첫 번째 인수로 입력하십시오.

간단한 설명 : 전체 비즈니스 a는 모든 사람에게 명백한 반면, 두 번째 부분 x은 더 흥미 롭습니다. 기본적으로 __gc프로그램 종료시 호출되는 종료 자 ( 메타 메소드)를 사용하여 테이블을 만들거나 두 번째 단계에서 기존 항목을 업데이트 합니다.

절름발이 솔루션 : Lua , 60 바이트 (청크 크기 30 바이트)

a=a and...^2 or ...*2;                     print(a)os.exit()

온라인으로 사용해보십시오! 또는 두 배로 시도하십시오!

작고 더 나은 청킹이 있지만, 영리한 속임수없이 궁극적으로 지루하고 절름발이입니다. 나는 이것에 대한 의견이 필요 없다고 확신한다.

J , ^{15 10} 9 바이트

+: :(*-:)

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

두 배 버전 : 온라인으로 사용해보십시오!

f : gf하나의 인수로 g호출 될 때와 2 개의 인수로 호출 될 때 실행되는 동사를 작성합니다 . 그래서 우리 +:는 원본 소스와 *-:소스가 두 배가 될 때 double 을 실행 합니다.

이것은 J에서 두 동사의 기차가 후크가되기 때문에 y가 원래 입력 인 곳에서 f f실행 되기 때문에 작동 y f (f y)합니다. 또한, *-:그 자체가 곱셈으로 작동하는 "이완 고리"입니다* 왼쪽 에 절반-: 오른쪽 arg의 . 왼쪽 arg는 원래 입력이되고 오른쪽 arg는 입력이 두 배가되므로 원래 입력의 제곱을 생성합니다.

원래 답변

J , 15 바이트

*:@]`(+:@])@.=~

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

두 배 버전 : 온라인으로 사용해보십시오!

단일 버전에서, 우리는 Agenda @.를 사용 하여 if ... then logic을 수행 하는 단일 동사 =~를 가지고 있습니다 (+:@[).

그러나 코드를 두 배로 늘리면 J 후크가 생깁니다. 동사 f와 입력을 호출하십시오 y. 그런 다음 후크는 다음 f f과 같이 실행됩니다.

y f (f y)

즉, 원래 입력은 왼쪽 arg이고 오른쪽 arg는 두 배의 입력입니다. 이것들이 같지 않기 때문에 =~이번에는 false를 리턴 할 것이고, 이제 우리는 의제의 다른 포크, 즉 *:@]"오른쪽 arg"를 의미 하는 다른 포크를 실행할 것 입니다. 그리고 ~이진 동사의 입력을 뒤집기 때문에 오른쪽 arg는 원래 입력이됩니다.

파이썬 3 , 60 바이트

청크 크기 6.
훌륭한 솔루션은 아니지만 작동합니다. 이것은 독특한 도전이며, 실제로 다른 관점에서 생각하게 만듭니다.

0;  i=input;0;  p=print;n=i()#
x=int(n)##
z=2*x#z=x*x
p(z)##

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

배가 :

0;  i=0;  i=input;input;0;  p=0;  p=print;print;n=i()#n=i()#
x=int
x=int(n)##
(n)##
z=2*x#z=2*x#z=x*x
z=x*x
p(z)##p(z)##

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

캐스케이드 , 13 바이트 (청크 크기 13)

]
&/2
#
*
 2&

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

]
&/2
#
*
 2&]
&/2
#
*
 2&

두 배로 해보십시오!

이것은 매우 어려웠다. 이것의 기본 요지 2는 첫 번째 프로그램 에 대해 곱한 입력을 인쇄 하고2 에 대한 입력 사본으로 입니다.

설명:

첫 번째 프로그램의 실행 부분은 다음과 같습니다

]     Redirection
 /
#     Print
*     The multiplication of
 2&   Input and 2 (wrapping around the left)

두 배로 된 프로그램은 기본적으로 ]마지막 줄의 끝에 첫 번째 를 추가 하므로 프로그램은 대신에 줄을 바꿉니다 &. 이것은 그것을

]     Redirection
 /
#     Print
*     The multiplication of
 2 ]  Set the value of
& 2   The variable '2' to the input
      Then multiply the result of that (input) by '2' (input)

Zsh , 30 바이트 (청크 크기 10)

m=$m[1]*2
x=$[$1$m]
return $x

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

$varin $[$var]이 먼저 확장 된 다음 산술 컨텍스트에서 평가 된다는 사실을 남용합니다 .

             # each line is 9 characters long. when doubled, each is run twice.
m=$m[1]*2    # first time: m='*2'   second time: $m[1] is '*', so m='**2'
x=$[$1$m]    # single: x=$[$1*2]    doubled: x=$[$1**2];x=$[$1**2].
return $x    # zsh supports 32-bit return values from functions, unlike bash

누구든지 이것을 낮추기 위해 균열을 원한다면 여기에 24/8내가 얻은 솔루션에 가장 가까운 것이 있습니다 ( x^2+2두 배가되면 출력 )