Напишіть можливу найкоротшу програму так, що при поєднанні першого символу та кожного N-го символу після нього у нову програму, вихідний результат - N. Це повинно працювати для N = 1, 2, ..., 16.

Ще один спосіб сказати це: якщо ви видалите всі символи зі своєї програми, окрім першого та кожного Nth після цього, вихід решти коду має бути 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 явно неможлива, оскільки тоді щонайменше дві змінені програми були б ідентичними.
• Вихід може бути у файлі, stdout або будь-якому іншому розумному. Однак вихід 16 різних програм повинен надходити в одне і те ж місце (наприклад, це не нормально, якщо AOйде stdout, але Aйде у файл). Введення немає.
• Вихід повинен бути десятковим, а не шістнадцятковим. Фактичний вихід повинен містити лише 1 або 2 символи, які складають число від 1 до 16, нічого іншого. (Такі речі, як у Матлаба, 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

Пояснення

Я почну знизу, як це полегшило б пояснення

Майте на увазі дві мовні особливості APL. По-перше, APL не має переваги перед оператором, заяви завжди оцінюються праворуч ліворуч. Дві, багато функцій APL поводяться зовсім по-різному, залежно від того, якщо йому надано один аргумент праворуч (монадичний) або два аргументи зліва та справа (діадік).

Монадіка ⌊закруглена вниз (функція підлоги), Діадич ×, очевидно, множення, ⍝коментує решту рядка
Це повинно зробити це очевидним:

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

9:⌊/9×1
/ є зменшення. В основному це займає функцію зліва та масиву праворуч, вставляє функцію між кожною парою елементів масиву та оцінює. (У деяких мовах це називається "скласти")
Тут правильний аргумент - скаляр, тому /нічого не робить.

8:⌊|8×× 2
Монадіка ×- це функція сигнуму, а монадична |- функція абсолютного значення. Отже, × 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
Dyadic |- це модна функція, яку
×4×1оцінюють 1, і 7|18×1є18 mod 7 = 4

3:⌊○⍟/119-××5 1 ⍝ 2
Значення, розділені пробілом, є масивом. Зауважте, що в APL, коли більшість скалярних функцій дають аргументи масиву, це неявна карта.
Діадик ⍟- це лог.
Отже ××5 1, симптум сигнума на 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
Так, 1|/2111118 9просто повертається 2111118 9(як це стосується |/скалярів). Потім ⍟○7⍟⍟застосуємо ln, потім log ₇ до цих чисел, а потім помножимо їх на π та ln знову. Цифри, які виходять на іншу сторону, знаходяться 1.46424... 0.23972...
Тут, ⊃просто використовуються для вибору першого елемента масиву.

Python - 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-версії з 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 причини, чому. Перша причина: сценарій befunge завжди має розмір 80x25, тому незалежно від того, на рядках з кодом повинно бути щось, що зменшилося. Друга причина: чому це щось про 5,5 мільйона пробілів, це тому, що 720 720 є найменшим загальним кратним від 1 до 16 ... Значить, не буде обгортання безладу, коли ми пропускаємо символи. 3-я причина: ух, це досить абсурдно.

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

Примітка. Перед першим "1" має бути 17 пробілів. Ви, хлопці, знаєте багато мов, тому, будь ласка, допоможіть мені перелічити більше, на яких він може працювати (:

EDIT: Додано уніар + у позиції 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

Це використовує переваги коментарів ( #) та недокументованих "супер-коментарів" (усе, що слідує за неперевершеним }, мовчки ігнорується).

_є noop. Його можна було б замінити пробілом, але підкреслення здається мені більш зрозумілим ...

Спробуйте в Інтернеті.

Приклад виконання

$ 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