Напишите самую короткую из возможных программ, чтобы при объединении первого символа и каждого N-го символа после него в новую программу выводился N. Это должно работать при N = 1, 2, ..., 16.

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

пример

Если ваш код был

ABCDEFGHIJKLMNOP

N = 1 результатов в ABCDEFGHIJKLMNOP. Выполнение этого должно вывести 1.
N = 2 приводит к ACEGIKMO. Выполнение этого должно вывести 2.
N = 3 результата в ADGJMP. Выполнение этого должно вывести 3.
N = 4 результата в AEIM. Запуск этого должен вывести 4.
N = 5 результатов в AFKP. Запуск этого должен вывести 5.
N = 6 результатов в AGM. Запуск этого должен вывести 6.
N = 7 результатов в AHO. Выполнение этого должно вывести 7.
N = 8 приводит к AI. Запуск этого должен вывести 8.
N = 9 результатов в AJ. Выполнение этого должно вывести 9.
N = 10 результатов в AK. Запуск этого должен вывести 10.
N = 11 результатов в AL. Запуск этого должен вывести 11.
N = 12 результатов вAM, Запуск этого должен вывести 12.
N = 13 приводит к AN. Запуск этого должен вывести 13.
N = 14 результатов в AO. Запуск этого должен вывести 14.
N = 15 результатов в AP. Выполнение этого должно вывести 15.
N = 16 приводит к A. Выполнение этого должно вывести 16.

Детали

• Все символы разрешены, ASCII и не ASCII. (Новые строки и непечатаемый ASCII также допускаются. Обратите внимание, что возврат каретки и перевод строки считаются как отдельные символы.)
• Ваша оценка - длина в символах вашей неизмененной программы (15 в примере). Самый низкий балл побеждает.
• Оценка ниже 16 явно невозможна, потому что тогда как минимум две из измененных программ будут идентичны.
• Вывод может быть в файл или стандартный вывод или что-либо еще разумное. Однако выходные данные 16 различных программ должны идти в одно и то же место (например, это не нормально, если AOидет в стандартный вывод, но Aидет в файл). Там нет ввода.
• Вывод должен быть десятичным, а не шестнадцатеричным. Фактический вывод должен содержать только 1 или 2 символа, которые составляют число от 1 до 16, и ничего больше. (Вещи как Matlab's ans =в порядке.)
• Ваша программа не должна работать для N = 17 или выше.

APL, 49

⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_×   1_   _⍝_⍝ __2

Измененные программы

1  ⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_×   1_   _⍝_⍝ __2
2  ⌊⍟7⍟|21189×1×345× 1  ⍝⍝_2
3  ⌊○⍟/119-××5 1 ⍝ 2
4  ⌊7|18××4×1 ⍝2
5  ⌊⍟21×○5   
6  ⌊⍟19×51⍝2
7  ⌊11-4 ⍝
8  ⌊|8×× 2
9  ⌊/9×1 
10 ⌊2×5 
11 ⌊11 ⍝
12 ⌊1×12
13 ⌊13 
14 ⌊14⍝
15 ⌊15 
16 ⌊8×2

Explaination

Я начну с самого низа, так как это облегчит объяснение

Следует помнить о двух языковых особенностях APL. Во-первых, APL не имеет приоритета операторов, операторы всегда оцениваются справа налево. Во-вторых, многие функции APL ведут себя совершенно по-разному, в зависимости от того, задан ли один аргумент справа (монадический) или два аргумента слева и справа (диадический).

Monadic округляется ⌊вниз (функция этажа), Dyadic ×- это, очевидно, умножение, ⍝комментарии в остальной части строки.
Это должно сделать это очевидным:

16 ⌊8×2
15 ⌊15 
14 ⌊14⍝
13 ⌊13 
12 ⌊1×12
11 ⌊11 ⍝
10 ⌊2×5 

9:⌊/9×1
/ уменьшить. По сути, он принимает функцию слева и массив справа, вставляет функцию между каждой парой элементов массива и выполняет оценку. (В некоторых языках это называется «сгиб»).
Здесь правильным аргументом является скаляр, поэтому /он ничего не делает.

8:⌊|8×× 2
Monadic ×- это функция signum, а monadic |- функция абсолютного значения. Итак, × 2оценивает 1и, |8×1конечно,8

7:⌊11-4 ⍝ должно быть очевидно

6:⌊⍟19×51⍝2
Monadic ⍟- натуральное бревно.
Итак, ⍟19×51оценивает ln(19×51) = 6.87626...и ⌊округляет до6

5:⌊⍟21×○5
Монадические ○умножает свой аргумент на я
⍟21×○5являетсяln(21×5π) = 5.79869...

4:⌊7|18××4×1 ⍝2
Диадические |является функция мод имеет
×4×1значение 1, и 7|18×1является18 mod 7 = 4

3:⌊○⍟/119-××5 1 ⍝ 2
разделенные пробелами значения - это массив. Обратите внимание, что в APL, когда большинство скалярных функций дают аргументы массива, это неявное отображение.
Dyadic ⍟is log
Итак ××5 1, это signum of signum на 5 и 1, который дает 1 1, 119-1 1есть ¯118 ¯118( ¯это просто знак минус. APL должен различать отрицательные числа и вычитание), и ⍟/¯118 ¯118это log _-118 (-118) = 1

2: ⌊⍟7⍟|21189×1×345× 1 ⍝⍝_2
Вы можете решить это самостоятельно

1:⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_× 1_ _⍝_⍝ __2
Этот состоит из более сложного использования /. Если nэто число, Fфункция и Aмассив, то он nF/Aпринимает каждую группу nпоследовательных записей Aи применяет F/. Например, 2×/1 2 3берет каждую пару последовательных записей (которые есть 1 2и 2 3) и применяется ×/к каждой группе, чтобы дать 2 6
So, 1|/2111118 9просто возвращает 2111118 9(как это применяется |/к скалярам). Затем ⍟○7⍟⍟применяет ln, затем записывает ₇ к этим числам, затем умножает их на π и ln снова. Числа, которые выходят с другой стороны, 1.46424... 0.23972...
здесь, ⊃просто используются для выбора первого элемента массива.

Питон - 1201 1137 (генератор: 241 218) - Да здравствуют хэши!

Стратегия:

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

Основная трудность, однако, заключалась в том, чтобы добавить правильное количество хэшей, чтобы следующий запуск точно достиг начала следующей строки. Кроме того, могут возникать помехи с другими версиями, например, версия 16 прыгает прямо вprint команду строки 5 и так далее. Так что это было много проб и ошибок в сочетании со вспомогательным скриптом для быстрого тестирования.

Статистика:

• Персонажи: 1201 1137
• Хэши: 1066 1002 (88,1%)
• Номера хэшей: 135 (11,9%)

Код:

#
print 1#####
#p#r#i#n#t# #2######################
##p##r##i##n##t## ##3###
###p###r###i###n###t### ###4
####p####r####i####n####t#### ####5#########
#####p#####r#####i#####n#####t##### #####6##########
######p######r######i######n######t###### ######7###########
#######p#######r#######i#######n#######t####### #######8###
########p########r########i########n########t######## ########9##
#########p#########r#########i#########n#########t######### #########1#########0##
##########p##########r##########i##########n##########t########## ##########1##########1##
###########p###########r###########i###########n###########t########### ###########1###########2##
############p############r############i############n############t############ ############1############3##
#############p#############r#############i#############n#############t############# #############1#############4##
##############p##############r##############i##############n##############t############## ##############1##############5##
###############p###############r###############i###############n###############t############### ###############1###############6

Тестовый скрипт:

with open('printn.py', 'r') as f:
    c = f.read()

for n in range(1, 17):
    print "n =", n, "yields",
    exec c[::n]

Выход:

n = 1 yields 1
n = 2 yields 2
n = 3 yields 3
n = 4 yields 4
n = 5 yields 5
n = 6 yields 6
n = 7 yields 7
n = 8 yields 8
n = 9 yields 9
n = 10 yields 10
n = 11 yields 11
n = 12 yields 12
n = 13 yields 13
n = 14 yields 14
n = 15 yields 15
n = 16 yields 16

Обновление: генерирующий скрипт!

Я подумал о своем решении и о том, что должен быть шаблон для его генерации алгоритмически. Итак, поехали:

lines = ['#']
for i in range(1, 17):
    lines.append(('#' * (i - 1)).join('\nprint ' + `i`))
    fail = True
    while fail:
        while ''.join(lines)[::i].find('print ' + `i`) < 0:
            lines[i] = '#' + lines[i]
        fail = False
        for n in range(1, 17):
            try:
                exec ''.join(lines)[::n]
            except:
                lines[i] = '#' + lines[i]
                fail = True
                break
print ''.join(lines)

Он строит программу построчно:

1. Начните с хеша.
2. Добавьте новую строку iс print iкомандой и i - 1хэшами между каждыми двумя соседними символами.
3. Хотя «i-версия» (каждый i-й символ) текущей программы не содержит команду print i(из-за смещения) или любое n-version с n in range(1, 17)исключением, добавьте еще один хеш к предыдущей строке.

На самом деле программа вернула более короткую программу, чем я обнаружил вручную этим утром. (Поэтому я обновил свое решение выше.) Кроме того, я почти уверен, что более короткая реализация не следует этому шаблону. Но вы никогда не знаете!

Гольф версия - 241 218:

h='#';L=[h];I=range(1,17);J=''.join
for i in I:
 p='print '+`i`;L+=[(h*(i-1)).join('\n'+p)]
 while 1:
  while J(L)[::i].find(p)<0:L[i]=h+L[i]
  try:
   for n in I:exec J(L)[::n]
   break
  except:L[i]=h+L[i]
print J(L)

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

Befunge 93 - Пять миллионов семьсот шестьдесят пять тысяч семьсот семьдесят шесть символов

Я требую, чтобы меня воспринимали всерьез ...

v                                                                               &(720 720 - 80) X SPACE
""""""""""""""""                                                                &(720 720 - 80) X SPACE
1234567890123456                                                                &(720 720 - 80) X SPACE
"""""""""1111111                                                                &(720 720 - 80) X SPACE
,,,,,,,,,"""""""                                                                &(720 720 - 80) X SPACE
@@@@@@@@@,,,,,,,                                                                &(720 720 - 80) X SPACE
         ,,,,,,,                                                                &(720 720 - 80) X SPACE
         @@@@@@@                                                                &(720 720 - 80) X SPACE

3 причины почему. 1-я причина: сценарий befunge всегда имеет размер 80x25, поэтому, несмотря ни на что, должно быть что-то, что было сокращено в строках с кодом. 2-я причина: почему это что-то около 5,5 миллионов пробелов, потому что 720 720 - это наименьшее общее кратное от 1 до 16 ... Означает, что при пропуске символов не будет сложностей. Третья причина: вау, это довольно абсурдно.

209 знаков (разные языки)

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

• Целочисленные литералы
• Основные арифметические операторы +, - (вычитание и отрицание), *, /
• Печатает оценку голого выражения
• Имеет один символ, начинающий комментарий

Например,

Интерпретатор командной строки Python 2 (но не из файла):

+                1 #            4 /   23      #    #   5            #            9   #            7   6 *         #    # -        5     2   *  -        ##  2        6   #2                     *   2       6   4

MATLAB (просто замените '#' на '%'):

                 1 %            4 /   23      %    %   5            %            9   %            7   6 *         %    % -        5     2   *  -        %%  2        6   %2                     *   2       6   4

NB. Перед первым «1» должно быть 17 пробелов. Вы, ребята, знаете много языков, поэтому, пожалуйста, помогите мне перечислить больше, на которых он может работать (:

РЕДАКТИРОВАТЬ: Добавлен унарный + в позиции 0 для Python, чтобы избежать отступа строки.

CJam, 89 байт

GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(iiii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-

Этот подход не использует никаких комментариев.

iприводит к целочисленному, так что это просто тупик. Его можно заменить пробелами, но буквы кажутся мне более читабельными ...

Попробуйте онлайн , выполнив следующий код :

G,{)
"GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(iiiii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-"
%_~}%N*

Пример запуска

$ cat nth-char.cjam 
G,{)"GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(i
iii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-"%_~}%N*N
$ cjam nth-char.cjam 
GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(i
iii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-
1
GiH(A(i)i((i((iii)(i(((
i(i(ii(ii(-(iii(ii(i-
2
GA(5ii(-(-ii(((iii(i(i(iii(((i
3
GHAii((ii(((iii(i-iii(-
4
GH(i(iii(i(i(i(ii-
5
G(i((i((i(((i((
6
G5)-ii(iii(i(
7
GAi(i(iiiii-
8
G5(-(i(ii(
9
G((i((((i
10
G7ii(i(i-
11
Gi((i(i(
12
Gi((ii(
13
G)i(i((
14
Giii(i
15
Giiiii
16

GolfScript, 61 байт

1})_#;#;;00123358_(_};}_}_}} _}_(__6
_})4_)_+)__(__}__;_}___6

Для этого используются комментарии ( #) и недокументированные «супер-комментарии» (все, что следует за непревзойденным} игнорируется).

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

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

Пример запуска

$ cat nth-char.gs
16,{)"1})_#;#;;00123358_(_};}_}_}} _}_(__6
_})4_)_+)__(__}__;_}___6"\%.~}%n*
$ golfscript nth-char.gs
1})_#;#;;00123358_(_};}_}_}} _}_(__6
_})4_)_+)__(__}__;_}___6
1
1)##;0238(}}}} }(_
}4)+_(__;}_6
2
1_#025(;}}}_
)))(};_6
3
1#;28}} (
4+(_}6
4
1;05}_}64)__6
5
1#2(}}
)(;6
6
1;3; 6)_}
7
1;8}(4(}
8
10(}
);
9
10}}4_6
10
11}_+_
11
12}
(6
12
13})_
13
13 )}
14
15})6
15
18((
16