Ваша задача, если вы хотите принять это, - написать программу, которая выводит положительное целое число (больше 0). Если исходный код дублируется, вывод должен остаться прежним. Сложность в том, что если исходный код напечатан три раза ( трижды ?) Результат будет умножен на 3.

правила

• Вы должны построить полную программу . То есть ваш вывод должен быть распечатан на STDOUT.

• Исходный источник должен быть длиной не менее 1 байта.

• Оба целых числа должны быть в базе 10 (вывод их в любую другую базу или с научными обозначениями запрещен).

• Ваша программа не должна принимать данные (или иметь неиспользуемые пустые данные).

• Вывод целых чисел с концевыми / ведущими пробелами разрешен.

• Ведущие нули допускаются только в том случае, если цифры совпадают, например: 001 - 001 - 003 или 004 - 004 - 012

• Вы не можете использовать новую строку между копиями вашего источника.

• Это код-гольф , поэтому выигрывает самый короткий (оригинальный) код на каждом языке !

• Применяются стандартные лазейки .

пример

Допустим, ваш исходный код Abcи соответствующий вывод 4. Если я пишу AbcAbcвместо этого и запускаю его, вывод все равно должен быть 4. Однако, если я пишу AbcAbcAbcи запускаю его, вывод должен быть 12.

Бесстыдно украденные производный от г для Xcoder вызова

Wumpus , 6 байт

{~)
@O

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

Принты 1и 3.

объяснение

Я нашел тонну 6-байтовых решений с помощью перебора, но ни одного за 5 байт. Это не обязательно означает, что нет 5 байтов, но они, вероятно, будут использовать странные символы или что-то в этом роде.

Я выбрал это решение, потому что оно не печатает никаких ведущих нулей (большинство из них делают), и у него есть некоторый интересный поток управления. Начнем с одной программы:

Итак, исполняемый код:

{~)O@

{   Turn the IP left by 60°.
~   Swap two implicit zeros on the stack, does nothing.
)   Increment the top zero to 1.
O   Print it.
@   Terminate the program.

Достаточно просто. Теперь дублированная программа. Поскольку первая строка добавляется ко второй строке, сетка расширяется до ширины 5 (и высоты 3), что значительно меняет поток управления:

IP проходит этот цикл ровно один раз, поэтому исполняемый код:

{~){~)){~O@

{~) As before, we end up with a 1 on top of the stack.
{   Turn left by 60° again.
~   Swap the 1 with the 0 underneath.
))  Increment the zero to 2.
{   Turn left by 60° again.
~   Swap the 2 with the 1 underneath.
O   Print the 1.
@   Terminate the program.

Наконец, утроенная программа очень похожа на удвоенную, но мы добавим еще пару важных команд в эту третью строку:

Итак, исполняемый код:

{~){~)){~~)O@

{~){~)){~
    As before. We end up with a 1 on top of the stack and a 2 underneath.
~   Swap the 1 with the 2 underneath.
)   Increment the 2 to a 3.
O   Print the 3.
@   Terminate the program.

Шелуха , 5 байт

KΣK+1

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

Повторяется дважды!

Повторяется трижды!

объяснение

Довольно сложно построить повторяющуюся программу в Husk. Поскольку система типов запрещает функцию, которая может быть применена к самой себе, я должен как-то позволить первой части выполнить оценку функции, а оставшуюся часть - оценке значения, а типы существующих встроенных функций предназначены для предотвращения этого. вид двусмысленности. Токены программы

• K, который строит постоянную функцию. K a bэквивалентно a.
• Σ, который принимает целое число n и возвращает n- е треугольное число.
• +, который добавляет два числа.
• 1, который является буквальным 1.

Оригинальная программа интерпретируется так:

   K Σ (K+) 1
== Σ 1
== 1

Это (K+)бессмысленная функция, которая съедается первымK .

Дважды повторенная программа интерпретируется так:

   K Σ (K+1KΣK+) 1
== Σ 1
== 1

Функция в скобках снова поедается первой K.

Трижды повторенная программа интерпретируется так:

   K (Σ (K (+1) (KΣK+) 1)) (KΣK+1)
== Σ (K (+1) (KΣK+) 1)
== Σ ((+1) 1)
== Σ (+1 1)
== Σ 2
== 3

Желе , 7 5 байт

»‘µ*Ḃ

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

Попробуй вдвое!

Попробуйте это втрое!

Как это устроено

»‘µ*Ḃ            Main link. No arguments. Implicit argument: x = 0

 ‘               Increment; yield x + 1 = 1.
»                Take the maximum of x and 1. Yields 1.
  µ              Begin a new, monadic chain. Argument: y = 1
    Ḃ            Bit; yield 1 if y is odd, 0 if it is even. Yields 1.
   *             Power; yield y**1 = 1.

»‘µ*Ḃ»‘µ*Ḃ       Main link.

»‘µ*Ḃ            As before.
      ‘          Increment; yield y + 1 = 2.
     »           Take the maximum of 1 and 2. Yields 2.
       µ         Begin a new, monadic chain. Argument: z = 2
         Ḃ       Bit; yield 1 if z is odd, 0 if it is even. Yields 0.
        *        Power; yield z**0 = 1.

»‘µ*Ḃ»‘µ*Ḃ»‘µ*Ḃ  Main link.

»‘µ*Ḃ»‘µ*Ḃ       As before.
           ‘     Increment; yield z + 1 = 3.
          »      Take the maximum of 1 and 3. Yields 3.
            µ    Begin a new, monadic chain. Argument: w = 3
              Ḃ  Bit; yield 1 if w is odd, 0 if it is even. Yields 1.
             *   Power; yield w**1 = 3.

Haskell , 24 байта

main=print.div 3$4
 -1--

Принты 1: попробуйте онлайн!

main=print.div 3$4
 -1--main=print.div 3$4
 -1--

Также печатает 1: попробуйте онлайн!

main=print.div 3$4
 -1--main=print.div 3$4
 -1--main=print.div 3$4
 -1--

Принты 3: попробуйте онлайн!

Cubix , 5 байтов

)<@OP

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

объяснение

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

Я должен признать, что это было найдено грубой силой; Я бы никогда не нашел его самостоятельно. Фактически, @MartinEnder был тем, кто попросил меня попробовать перебор, так как он безуспешно искал это решение. Это единственное решение, найденное брутфорсером, и я верю, что это единственное и самое короткое решение в Cubix.

Одиночная программа

Смотреть это бежать!

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

  )
< @ O P
  .

IP (указатель инструкции) начинается с самого левого лица ( <), направленного на восток. Тот <немедленно указывает на запад, и он оборачивается вокруг P. Pэто возведение в степень, и поскольку в стеке ничего нет, интерпретатор вытягивает два 0 с и вычисляет 0 ⁰ , что равно 1 в соответствии с JavaScript. Oзатем печатает это значение и @завершает программу.

Двойная программа

Смотреть это бежать!

)<@OP)<@OP

10-байтовая программа слишком длинна, чтобы поместиться в единичный куб, поэтому она расширяется до куба размера 2:

    ) <
    @ O
P ) < @ O P . .
. . . . . . . .
    . .
    . .

Как и прежде, IP начинается в верхнем левом углу самого левого лица. На этот раз самая первая инструкция P, которая нажимает 1, как и раньше. Далее идет ), который увеличивает верхний элемент, превращая его в 2 . Затем <переворачивает IP, и он )снова попадает в , превращая 2 в 3 .

Вот где это становится интересным. Pподнимает второй элемент сверху до уровня первого элемента, что дает 0 ³ = 0 . Затем IP-адрес оборачивается к крайнему правому лицу и проходит через две неоперативные операции, .прежде чем ударить другую P. Здесь мы видим еще одну причуду Cubix: бинарные операторы (такие как P) не удаляют свои операнды из стека. Итак, поскольку стек теперь [3, 0], мы вычисляем 3 ⁰ = 1 , который Oвыводит и @завершает программу.

Тройная программа

Смотреть это бежать!

)<@OP)<@OP)<@OP

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

    ) <
    @ O
P ) < @ O P ) <
@ O P . . . . .
    . .
    . .

Эта программа запускается так же, как и предыдущая: Pнажимает 1 , )увеличивает, <указывает IP на запад, )снова увеличивает, а Pтеперь нажимает 0 . Затем IP оборачивается <на крайний правый край, который ничего не делает, так как IP уже направлен на запад.

Вот одно отличие от двойной программы: )увеличивает 0 на вершине стека до 1 . Когда Pснова выполняет свою магию, на этот раз он вычисляет 3 ¹ = 3 . Oвыводится и @заканчивается, и мы окончательно доказываем, что третий раз действительно очаровывает.

Brain-Flak , 10 байт

<>([]{}())

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

Попробуй вдвое!

Попробуйте это втрое!

Объяснение:

#Toggle stacks
<>

#Push
(
    #Stack-height (initially 0) + 
    []

    #The TOS (initially 0) + 
    {}

    #1
    ()
)

Когда мы запустим это один раз, он будет помещен (0 + 0 + 1) == 1в альтернативный стек. Запущенный во второй раз, он помещает то же самое в основной стек. Запустите третий раз, однако он оценивает (1 + 1 + 1) == 3и помещает его в альтернативный стек и неявно печатает.

SQL, 25 24 23 байта

( -1 байт удален опечатанный символ, который всегда закомментировался и ничего не делал )
( -1 байт изменен SELECTна PRINTрекомендованный Разваном Соколом )

PRINT 2/*
*2+1--*/-1
--

Как это работает:
в SQL вы можете закомментировать теги комментария, например так:

/*
'Comment'--*/

против

--/*
'Not Comment'--*/

Код в 1 строке без комментариев:
первая итерация: SELECT 2-1вывод: 1
вторая итерация: SELECT 2-1*2+1вывод: 1
третья итерация: SELECT 2-1*2+1*2+1вывод:3

SOGL V0.12 , 7 5 4 байта

ē»«I

Попробуй это здесь!

Попробуй вдвое!

Попробуйте это втрое!

Объяснение:

ē»«I
ē     push counter, then increment it.
      First time running this will push 0, then 1, then 2.
             TOS on each: 0  1  2
 »    floor divide by 2   0  0  1
  «   multiply by 2       0  0  2
   I  and increment       1  1  3

05AB1E , 6 5 байт

.gDÈ+

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

объяснение

.g     # push length of stack
  D    # duplicate
   È   # check if even
    +  # add

Одноместный: 0 + (0 % 2 == 0) -> 1
двухместный: 1 + (1 % 2 == 0) -> 1
трехместный:2 + (2 % 2 == 0) -> 3

> <> , 9 байт

\5 n;
\\1

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

Попробуй вдвое!

Попробуйте это втрое!

Я нашел такую ​​удачу, используя философию, что «если вы сделаете путь рыбы достаточно запутанным, в конечном итоге что-то сработает». Исходная и дублированная версии печатают 5, а утроенная версия печатает 1, а затем 5, чтобы получить 15 = 3 × 5. Вот умноженные версии, для вашего прочтения:

\5 n;
\\1\5 n;
\\1

\5 n;
\\1\5 n;
\\1\5 n;
\\1

Python 2 ,  46 45  39 байт

Вдохновлен ответом Халварда . Я рад, что мой вызов вдохновил новый, который я считаю еще более интересным. Сохранено 6 байтов благодаря Кевину Круйссену .

print open(__file__,"a").tell()/79*3|1#

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

Попробуй вдвое!

Попробуйте это втрое!

Как это работает (устарело)

k=open(__file__,"a").tell() # Read the source code in "append" mode and get its length.
                            # Assign it to a variable k.
;print k>>(k==90)#          # Print k, with the bits shifted to the right by 1 if k
                            # is equal to 90, or without being shifted at all overwise.
                            # By shifting the bits of a number to the right by 1 (>>1),
                            # we basically halve it.

Когда он удваивается, длина становится 90 , но новый код игнорируется благодаря #, поэтому k==90оценивается как True. Логические значения являются подклассами целых чисел в Python, поэтому k>>Trueэквивалентны k>>1, что по существу равно k / 2 = 45 . Когда она в три раза, новый код снова игнорируется, поэтому новая длина 135 , которая не сдвигаются , потому что имеет k==90значение False, так k>>(k==90) ⟶ k>>(135==90) ⟶ k>>False ⟶ k>>0 ⟶ kи к печатается как есть.

Python 2 , 36 байт

Это было предложение Эйдана Ф. Пирса в 38 байт, и я сыграл в гольф 2 байта. Я не публикую это как свое основное решение, потому что я не придумал это сам.

0and""
True+=1
print True>3and 3or 1

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

R , 37 31 28 байт

Спасибо Джузеппе за то, что он сыграл в гольф последние 3 байта.

length(readLines())%/%2*2+1

(с завершающим переводом строки).

Попробуйте один раз!

Попробуйте дважды!

Попробуйте трижды!

Это использует readLines()трюк из ответа Джузеппе на вызов из 8 шаров , где stdinперенаправляет в исходный файл. Этот код в основном просто подсчитывает, сколько строк существует ниже первой строки, и выводит, 1если есть 1 или 3 строки (т. Е. Код одинарный или удвоенный), или 3если есть 5 строк (т. Е. Код утроен).

Потерян , 38 байт

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

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

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

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

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

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

объяснение

Потерянный - очень интересный язык для этой задачи. Обычная техника Lost - это построить «ловушку». Ловушка - это раздел программы, предназначенный для перехвата всех ips в одном месте, чтобы их стеки можно было очистить и ими можно было управлять в определенном направлении. Это делает написание программ в Lost намного более управляемым. Однако, поскольку программа дублируется, нам также нужно избегать дублирования ловушек. Это требует, чтобы мы разработали новую ловушку, которая работает должным образом, но при дублировании работает только одна из ловушек. Моя основная идея здесь заключается в следующем

v<<<<>
>%?!^^

Пока стек не пуст, ?он удалит элемент и заставит его вернуться к началу, если этот элемент ненулевой. Ключевым моментом здесь является то, что, когда это складывает линию ^^s

v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^

Это означает, что независимо от того, как вы входите, вы всегда будете выходить в одном и том же месте.

Отсюда мы можем попытаться реализовать ту же идею из моего ответа Кляйна .

\\<<<<<v<<<<>
2>((1+@>?!^%^

Основой нашей программы является левая сторона, которая выдвигает число 2s. Каждый раз, когда мы добавляем копию программы, 2в ее основную часть добавляется другая, что означает добавление дополнительных 2 в стек. Как только он уходит вниз, он прыгает \\>и выполняет код

((1+@

Это удаляет первые 2 элемента стека, добавляет один к тому, что осталось, и выходит. Как только у нашей магистрали будет 3 2, мы добавим 1 и получим 3, если у нас будет меньше 3 предметов, мы просто отбросим весь стек и вернем 1.

Теперь единственной проблемой остается то, что !в нашей программе может возникнуть бесконечный цикл. Если ip начинает !идти вверх, он прыгнет и приземлится обратно туда, где он был. Это означает, что мы должны добавить еще одну строку внизу, чтобы предотвратить цикл.

\\<<<<</<<<<>
2>((1+@>?!^%^
.........^

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

Stax , 5 байт

|dhH^

Запускать и отлаживать онлайн! · Рскладной · утроилось

объяснение

|dhH^
|d       Push Current stack depth `d`, originally 0
         Doubled -> 1, Tripled -> 2
  hH^    Map d to 2*(floor(d/2))+1
         Implicit print

C (gcc) , 95 91 85 байт

#ifndef a
#define a-1
main(){puts(3
#include __FILE__
?"1":"3");}
#define a
#endif
a

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

Japt , 8 6 5 байт

-1 байт благодаря @ETHproductions

°U-v

Объяснение:

°U-v
 U     # variable U=0                # U=0
°U     # ++U                         # U=1
  -    # minus:
   v   #   1 if U is divisible by 2  
       #     else
       #   0                         # U=1

Это оценивает 1-0 = 1

Удвоенная оценка 2-1 = 1

Утроенный оценивает 3-0 = 3

Чистый Баш (нет wcили другие внешние утилиты), 27

trap echo\ $[a++&2|1] EXIT

• Попробуйте это один раз.
• Попробуйте дважды.
• Попробуйте трижды.

Perl 5 , 18 15 13 12 11 байт

-3 байта благодаря nwellnhof

say 1|
+.7#

Один раз попробуйте онлайн!

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

Трижды Попробуйте онлайн!

> <> , 10 9 8 байт

562gn|

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

Попробуй вдвое!

Попробуйте это втрое!

Я уверен, что где-то там есть 8-байтовое решение.

Непечатаемый конец имеет значение ASCII 1 и выбирается только командой get на третьей итерации. Для первых двух он печатает 05, а затем печатает 15.

C (gcc) , 107 байт

Моя первая подача в C (GCC). Слишком долго ...

i;
#ifdef c
#define c
#ifdef b
i=2;
#else
#define b
#endif
#else
#define c main(){putchar(i+49);}
#endif
c

TIO ссылки: одинарные , двойные , тройные .

Лабиринт , 12 11 9 байт

: #% @
 7

TIO (1x) , TIO (2x) , TIO (3x)

JavaScript, 81 77 74 70 байт

^{Сохранено 4 байта благодаря Shaggy}

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

Довольно слабое решение JS. Потребляет значения из [3,1,1]массива справа ( pop()). Регистрирует тайм-аут для отображения текущего значения в будущем. Если тайм-аут уже зарегистрирован, отмените его. Полагается на грязную природу var, которая поднимает переменные объявления.

Два раза:

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

Три раза:

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

C (gcc) , 53 52 байта

Обратите внимание на пробел после #endif.

n;main(){putchar(n+49);}
#if __LINE__>7
n=2;
#endif 

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

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

⎚≔⁺ι¹ιＩ⁻ι⁼ι²

Попробуйте онлайн! Ссылка на подробный код.

Попробуй вдвое!

Попробуйте это втрое!

объяснение

⎚             Clear
 ≔⁺ι¹ι        Assign plus(i, 1) to i
       Ｉ      Cast (and implicitly print)
         ⁻ ⁼ι² Subtract equals(i, 2) from
          ι    i

JavaScript, 43 40 байт

var t=t?--t:~!setTimeout`t=alert(1|~t)`;

2x:

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

3x:

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

PowerShell , 54 48 45 44 байта

if(99-gt(gc $PSCOMMANDPATH|wc -c)){1;exit}3#

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

Попробуй вдвое!

Попробуйте это втрое!

Получает свой путь вызова с $PSCOMMANDPATHи выполняет gЕТ content на файл. Ifколичество символов в этом файле меньше 99(проверено с помощью wc -ccoreutils), затем мы выводим 1и exit(то есть прекращаем выполнение). Это объясняет оригинальный код и удвоенный код. В противном случае мы выводим 3и выходим. Фактический код, который находится в удвоенных или тройных разделах, не имеет смысла, поскольку либо мы exitдо этого доберемся, либо за комментарием# .

Сохраненные 6 байт благодаря г Xcoder
сохраненных 3 4 байта благодаря Павлу

C # (178 байт)

Console.WriteLine(1+2*4%int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]=(int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]??"0"))+1+""));

сумасшедшее решение C #, но я рад, что это вообще возможно в одной строке в C #. :)

Для меня самой сложной частью было наличие действующего C #, который либо инициализировал бы, либо увеличивал ту же самую переменную, поэтому я в конечном итоге злоупотребил ConfigurationManager, потому что мне требовалась глобальная статическая коллекция NameValueCollection, и ConfigurationManager был единственным, о чем я мог думать, что я мог обновить в памяти. EnvironmentVariables был еще одним вариантом, на который я обратил внимание, но у него нет индексатора, поэтому я не уверен, как сделать это в одной строке, которую можно скопировать, чтобы получить требуемый вывод в соответствии со спецификацией.

Рунические чары , 35 байт

^w3'\
    f
    1
/1@
/
 '54\w
/yyy

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

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

Функции из-за того, что в последней строке нет завершающего символа новой строки (или, в этом отношении, конечных пробелов), что позволяет дублирующимся IP-адресам появляться в другом месте. Верхний левый завершает создание большого цикла вокруг сетки, в то время как второй IP-адрес выполняет операцию Reflection, чтобы заменить в \6-й строке на a . Этот IP тогда будет зацикливаться вечно и ничего не делать.

Третий IP также делает такую же замену в то же время, а потому , что она находится на 13 - й линии, ее копия этого отражателя посылает его вверх , и он выполняет 1f'3wприсутствующие последовательности в верхнем правом углу, заменяющий 1с 314 - го линии, непосредственно перед тем, как исходный IP-адрес выполнит его, что приведет к выводу утроенной программы 3вместо 1(значения также могут быть 2и 6, 3и 9, 4и 12, или, 5и 15из-за наличия a-fчисловых констант; 1и 3были выбраны произвольно). Затем он остается в бесконечном цикле, выполняя больше команд отражения, которые ничего не делают.

Попробуйте в трех экземплярах!

Perl 5, 28 25 байт

-3 байта благодаря @neil!

print"\e[D$a"if(++$a!=2);

Перемещает курсор назад (ничего не делает в начале строки) и печатает значение в $aпервый и третий раз (т. Е. В третий раз, когда печатается 1, курсор перемещается, а 3 печатается в позиции 1).

QBasic, 19 байтов

CLS
x=2^x
?x-1OR 1

Источник должен включать завершающий перевод строки.

объяснение

Мы хотим , чтобы выход 1, 1, 3. Заметьте, что эти числа на единицу меньше степеней 2. Итак:

CLS      ' CLear Screen of any output from previous copies of the code

x        ' Numeric variables are preset to 0...
 =2^x    ' so as this statement is repeated, the value of x goes 1, 2, 4

 x-1     ' Therefore x-1 goes 0, 1, 3...
    OR 1 ' and we bitwise OR it with 1 to change the 0 to 1...
?        ' and print.