Было несколько проблем, связанных с удвоением исходного кода: здесь и здесь . Задача, стоящая перед нами, немного сложнее, но должна быть выполнима практически на каждом языке.

В этом задании вы получите произвольное положительное целое число. Ваша программа должна вывести это целое число в два раза . Когда ваш исходный код удваивается, он принимает положительное целое число и выводит его в квадрате .

Как ваш исходный код удвоился? Ну, вы можете иметь это по-своему . Другими словами, вы можете разбить свой исходный код на строки байтов или символов (или токенов в токенизированных langs) любой равной длины, которую вы хотите , и повторять каждый фрагмент дважды по очереди.

Для начальной программы ABCDEFGHIJKL(длина 12) все возможные дублированные программы:

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

Обратите внимание, что это означает, что программы простых длин могут быть удвоены только двумя способами: каждый символ удваивается, или полная программа повторяется дважды.

Правила:

• Код должен быть полной программой или функцией.
• Стандартные лазейки запрещены.
• Стандартные методы ввода / вывода разрешены.
• Все символы / байты, включая пробелы и символы новой строки, учитываются в длине кода и вносят вклад в куски.
• Вы можете предположить, что входные данные и их квадрат могут быть представлены типом int / integer вашего языка.
• Вы не можете использовать завершающий символ новой строки или другой символ.
• Укажите свой размер куска в заголовке после подсчета байтов.
• Это код-гольф , поэтому короткие программы лучше! Если две программы имеют одинаковую длину, побеждает та, которая использует меньшую длину фрагмента. (Если у вас более длинная программа, которая использует меньшую длину чанка, то это тоже стоит опубликовать!)
• Если вашей программе требуется второй ввод / строка, вы можете не делать никаких предположений относительно ее значения. В частности, ваша программа должна работать, если второй вход пустой, такой же, как первый, или другое целое число. Если вашей программе не требуется второй ввод / строка, вы можете игнорировать это ограничение.

Песочница ссылка

Perl 5 , 8 байтов (размер блока 4)

$_*=~~+2

Попробуйте онлайн или попробуйте двойную версию .

Унарный ~является побитовым отрицанием, поэтому двойное его применение - пустяк. Таким образом, базовая программа просто умножает $_(неявная переменная ввода-вывода) на 2.

Binary ~~- это smartmatch, который возвращает логическое значение. ~~+2~~+2разбирает как (~~+2) ~~ (+2). Поскольку 2 равно 2, это дает истину (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

Попробуйте онлайн!

-4 байта благодаря @negativeSeven

Вдвое:

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), выход с возвратом код)

Гексагония , 14 байтов (размер куска 14)

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

Expanded:

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

Попробуйте онлайн!

двойной

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

Expanded:

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

Попробуйте это в два раза онлайн!

В этой задаче Hexagony находится в несколько странном положении, поскольку в действительности выполнить задачу не намного сложнее, чем просто написать две отдельные программы. Однако решение этой проблемы оказалось довольно сложным.

Это решение - тривиальная идея в самой короткой форме, которую я мог бы уместить, но я подозреваю, что есть более короткие и умные ответы. Эта версия очень наивно устанавливает два значения для ввода и суммирует их или умножает их, в зависимости от того, удвоен ли источник. Единственное повторное использование кода - это то, "+что делает код копирования для удвоенной программы достаточно коротким, чтобы помещаться в неиспользуемое пространство исходной программы.

Я подозреваю, что использование инструкций по изменению IP []сделает изоляцию частей более легкой, но действительно идеальное решение будет использовать много кода между ними. Я сделал вспомогательную программу для удвоения исходного кода шестиугольника. Обратите внимание, что он удаляет завершающие no-ops, так что если вы хотите, чтобы в конце не использовались no-ops-заполнители, просто заполните какой-нибудь другой символ и измените его после. Он может обрабатывать блоки разных размеров, хотя я еще не писал код для вывода каждой возможной программы (похоже, что Hexagony может использовать полный размер блока).

Гексагония , 12 байт (размер блока 4)

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

Попробуйте онлайн!

отформатирован:

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

И дублируется , затем форматируется:

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

По сути, это устанавливает первое ребро на вход, затем второе ребро на любую 2или копию ввода, затем умножает эти два ребра на третье ребро, печатает это и завершает. Список выполненных инструкций просто

?"2}=*!@

а также

?"2+}=*!@

Единственная разница заключается в +переопределении 2второй программы.

JavaScript (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)является ложным в обеих версиях.

С другой стороны, применение двоичного кода +между двумя функциями приводит к строке. Поэтому (x=>x*2)+(g=x=>x*x)правдив в дублированном варианте.

Perl 6 , 8 байтов (размер блока 1)

* *<1 2>

Попробуйте онлайн! Попробуй вдвое!

Какая бы ни была / HyperWh независимо от лямбды, которая принимает число и возвращает число для первой программы и одноэлементный список для второй программы. В основном это сохраняет ту же логику, за исключением того, что оператор умножения ( *) заменяется экспоненциальным ( **).

**  **<<11  22>>

Независимо от того, что литерал (который также вводит в заблуждение *), удваивается до HyperWhwhat ( **), который в основном одинаков, за исключением того, что он отображает списки. Пространство необходимо для отделения литерала Wh независимо от умножения и игнорируется при удвоении. Вместо простого 2(который удваивается 22) мы используем список, содержащий два элемента, который оценивается как 2 в числовом контексте). <>Может быть удвоены к списку с интерполяцией, а также два элемента внутри удваивается, но ни один из этих изменений длины списка.

Рунические чары , 9 байт (размер чанка 3)

i3?:*@:+@

Попробуйте онлайн!
Попробуй вдвое!

3?Пропускает следующие 3 инструкции, в результате чего (выполняется) i3?...:+@. Когда удвоено, это приводит к выполнению, i3?...:*@где .представляет 3 NOP'd инструкции. @это «печатать весь стек и завершить».

C # (интерактивный компилятор Visual C #) / Javascript, 22 байта, размер фрагмента 11

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

Попробуйте онлайн!

Brain-Flak , 48 30 байт (размер куска 10)

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

Попробуйте онлайн! Попробуй вдвое!

Это в основном занимает три шага, затем, когда doubled выполняет эти шаги дважды каждый. Начальная программа:

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 байтов

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

Попробуйте онлайн!

Удвоенный (с новой строкой для ясности)

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

Попробуйте онлайн!

Вот версия, которая использует более сложную процедуру удвоения. Он выполняет 5 блоков размером 15. Код здесь составляет 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.

Этот результат возвращается обратно в Bounds Green, который дважды выполняет операцию max (), прежде чем передать результат на выход. В единственной версии это оставляет удвоение неизменным (int и string просто переключаются назад и вперед), но в удвоенной версии это заменяет 0 результатом квадрата, уже сохраненным в Bounds Green.

JavaScript (Node.js) , 15 12 байт (размер фрагмента: 6)

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

Попробуйте онлайн!

Единичный случай:

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

Двойной корпус:

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

Кажется, также работает в C # и Java, если изменить =>на ->?

R , 42 35 28 байтов (размер блока 4)

Теперь с меньшим куском и без ошибок. У меня также есть более длинное решение с размером чанка 3; увидеть ниже.

Я не думаю, что возможно написать ответ R с размером чанка 1 или 2; Я с радостью дам щедрость любому, кто докажет, что я неправ.

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

Попробуйте онлайн!

Для #комментариев в R. 3-я строка содержит только пробелы, образуя кусок новой строки + 2 пробела + новую строку, так что предыдущий и следующий фрагменты не могут иметь новой строки.

Вдвое становится:

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]

Попробуйте онлайн!

Благодарим Робина Райдера за то, что он вдохновил меня; увеличивается Fкаждый раз, и функция fвыбирает соответствующий выход.

Это не особенно интересно, но, несомненно, будет придумано что-нибудь умное, манипулирующее размером с чанкКак и ожидалось, Робин Райдер придумал это, которое и короче, и имеет некоторые аккуратные манипуляции с чанками.

PowerShell , 22 байта (размер блока 11)

param($p)
#   /
2 * $p

Попробуйте онлайн .

Вдвое:

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

Это решение основано на @ ShieruAsakoto's растворе .

Решение @Grimy , преобразованное в PowerShell, 26 байтов (размер блока 13)

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

Попробуйте онлайн .

Вдвое:

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

Perl 5 (-p ), 22 15 байт

-7 байт благодаря Грими

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

TIO

Древесный уголь , 13 байт

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

Попробуйте онлайн! Объяснение: Предопределенный пустой список равен Falsey, поэтому вход умножается на 2. При удвоении второго прохода видно, что пустая строка добавлена ​​в список, поэтому вместо этого он сам умножает ввод. Попробуйте онлайн! В подробном синтаксисе это соответствует Multiprint(Cast(Times(Cast(q), Ternary(u, Cast(q), 2)))); Push(u, w);.

Python 3, 56 53 байта

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

Мой питон навыки своего рода сосать, так что, безусловно , может быть golfed .. На основании ответа Python в « Я удвоении источника, вы удвоить выход! » Вызов .

Длина куска 53.

Попробуйте онлайн или попробуйте онлайн в два раза .

Java 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 : gсоздает глагол, который выполняется fпри вызове с одним аргументом и gпри вызове с 2 аргументами. Таким образом, наш выполняется дважды +:с исходным источником, а *-:когда источник удваивается.

Это работает, потому что последовательность из двух глаголов в J становится хуком, и, таким образом f f, выполняется y f (f y)там, где у - исходный ввод. Кроме того, *-:сам по себе является «диадическим крючком», который работает путем умножения *левого аргумента на половину-: правого аргумента. Левый аргумент будет исходным входом, а правый аргумент будет удвоенным, поэтому будет получен квадрат исходного ввода.

оригинальный ответ

J 15 байт

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

Попробуйте онлайн!

Удвоенная версия: попробуйте онлайн!

В единственной версии у нас есть один глагол, который использует Agenda @.для выполнения логики if ... then: если аргумент равен самому себе =~, то взять аргумент и удвоить его (+:@[).

Однако, когда мы удваиваем код, мы получаем J-хук. Назовите глагол fи введите y. Затем хук f fвыполняется так:

y f (f y)

Это означает, что теперь исходный ввод - это левый аргумент, а правый - дублированный. Так как они не будут равны, на =~этот раз вернут false, и теперь мы выполним другой форк Повестки дня, т. Е., Что *:@]означает «квадрат правого аргумента». И так как ~инвертирует входные данные двоичного глагола, правый аргумент будет исходным.

Python 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

Попробуйте онлайн! Попробуй вдвое!

Злоупотребления тот факт , что $varв $[$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при удвоении)