Escreva o programa mais curto possível, de modo que quando você combinar o primeiro caractere e cada enésimo caractere depois dele em um novo programa, a saída será N. Isso deve funcionar para N = 1, 2, ..., 16.

Outra maneira de dizer isso é: se você remover todos os caracteres do seu programa, exceto o primeiro e o enésimo nono depois disso, a saída do código restante deverá ser N.

Exemplo

Se o seu código foi

ABCDEFGHIJKLMNOP

N = 1 resulta em ABCDEFGHIJKLMNOP. Executando esta deve saída 1.
N = 2 resulta em ACEGIKMO. Executando esta deve saída 2.
N = 3 resulta em ADGJMP. Executando esta deve saída 3.
N = 4 resulta em AEIM. Executando esta deve saída 4.
N = 5 resulta em AFKP. Executando esta deve saída 5.
N = 6 resulta em AGM. Executando esta deve saída 6.
N = 7 resulta em AHO. Executando esta deve saída 7.
N = 8 resulta em AI. Executando esta deve saída 8.
N = 9 resulta em AJ. Executando esta deve saída 9.
N = 10 resulta na AK. Saída de executar este deveria 10.
N = 11 resultados em AL. A execução disso deve gerar 11.
N = 12 resulta emAM. Executando esta deve saída 12.
N = 13 resulta na AN. Executando esta deve saída 13.
N = 14 resulta na AO. Executando esta deve saída 14.
N = 15 resulta na AP. Executando esta deve saída 15.
N = 16 resulta na A. A execução disso deve gerar 16.

Detalhes

• Todos os caracteres são permitidos, ASCII e não ASCII. (Novas linhas e ASCII não imprimíveis também são permitidos. Observe que o retorno de carro e o avanço de linha contam como caracteres distintos.)
• Sua pontuação é o comprimento em caracteres do seu programa inalterado (15 no exemplo). A pontuação mais baixa vence.
• Uma pontuação abaixo de 16 é claramente impossível, porque pelo menos dois dos programas alterados seriam idênticos.
• A saída pode ser para um arquivo ou stdout ou qualquer outra coisa razoável. No entanto, a saída dos 16 programas diferentes deve ir para o mesmo local (por exemplo, não está bom se AOfor para stdout, mas Apara um arquivo). Não há entrada.
• A saída deve ser decimal, não hexadecimal. A saída real deve conter apenas os 1 ou 2 caracteres que compõem o número de 1 a 16, nada mais. (Coisas como Matlab's ans =estão bem.)
• Seu programa não precisa trabalhar para N = 17 ou superior.

APL, 49

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

Programas alterados

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

Explicação

Vou começar de baixo, pois facilitaria a explicação

Há um recurso de dois idiomas do APL a ser lembrado. Primeiro, o APL não tem precedência de operador, as instruções são sempre avaliadas da direita para a esquerda. Segundo, muitas funções da APL se comportam de maneira bastante diferente, dependendo de um argumento à direita (monádico) ou dois argumentos à esquerda e à direita (diádico).

Monádico ⌊é arredondado para baixo (função de piso), Diádico ×é obviamente multiplicação, ⍝comenta o restante da linha
Isso deve tornar isso óbvio:

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

9:⌊/9×1
/ é reduzir. Basicamente, assume a função da esquerda e a matriz à direita, insira a função entre cada par de elementos da matriz e avalie. (Isso é chamado de "dobra" em alguns idiomas).
Aqui, o argumento correto é um escalar, e /não faz nada.

8:⌊|8×× 2
Monádico ×é a função signum e monádico |é a função de valor absoluto. Portanto, × 2avalia 1e |8×1é claro8

7:⌊11-4 ⍝ deve ser óbvio

6:⌊⍟19×51⍝2
Monádica ⍟é log natural.
Portanto, ⍟19×51avalia ln(19×51) = 6.87626...e ⌊arredonda para6

5:⌊⍟21×○5
Monádica ○multiplica seu argumento por π
⍟21×○5éln(21×5π) = 5.79869...

4:⌊7|18××4×1 ⍝2
Dyadic |é a função mod
×4×1avaliada 1e 7|18×1é18 mod 7 = 4

3:⌊○⍟/119-××5 1 ⍝ 2
Valores separados por espaço são uma matriz. Observe que no APL, quando a maioria das funções escalares fornece argumentos de matriz, é um mapa implícito.
Diádico ⍟é log
Então ××5 1, é signum de signum em 5 e 1, o que fornece 1 1, 119-1 1é ¯118 ¯118( ¯é apenas o sinal de menos. O APL precisa distinguir entre números negativos e subtração) e ⍟/¯118 ¯118é log _-118 (-118) = 1

2:⌊⍟7⍟|21189×1×345× 1 ⍝⍝_2
Você pode resolver isso sozinho

1:⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_× 1_ _⍝_⍝ __2
Este consiste em um uso mais complicado de /. Se né um número, Fé uma função e Aé uma matriz, nF/Apega cada grupo de nentradas consecutivas de Ae aplica F/. Por exemplo, 2×/1 2 3pega cada par de entradas consecutivas (que são 1 2e 2 3) e aplica ×/- se a cada grupo para fornecer 2 6
So, 1|/2111118 9apenas retorna 2111118 9(como se aplica |/aos escalares). Então, ⍟○7⍟⍟aplica ln, registra ₇ nesses números e os multiplica por π e ln novamente. Os números que saem do outro lado estão 1.46424... 0.23972...
aqui, ⊃são usados ​​apenas para selecionar o primeiro elemento de uma matriz.

Python - 1201 1137 (gerador: 241 218) - viva os hashes!

Estratégia:

Tentei iniciar cada linha com tantos hashes quanto a saída desejada n. Todas as outras versões pularão completamente esta linha.

A principal dificuldade, no entanto, foi acrescentar o número correto de hashes para que a próxima execução chegasse exatamente ao início da próxima linha. Além disso, interferências com outras versões podem ocorrer, por exemplo, a versão 16 saltando diretamente para o printcomando da linha 5 e assim por diante. Portanto, houve muitas tentativas e erros combinados com um script auxiliar para testes rápidos.

Estatisticas:

• Personagens: 1201 1137
• Hash: 1066 1002 (88,1%)
• Sem hashes: 135 (11,9%)

Código:

#
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

Script de teste:

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

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

Resultado:

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

Atualização: Um script de geração!

Pensei na minha solução e que deve haver um padrão para gerá-la algoritmicamente. Aqui vamos nos:

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)

Ele cria o programa linha por linha:

1. Comece com um hash.
2. Acrescente uma nova linha iao print icomando e faça um i - 1hash entre cada dois caracteres vizinhos.
3. Enquanto a "versão i" (todo i-ésimo caractere) do programa atual não contém o comando print i(devido ao desalinhamento) ou qualquer nversão com n in range(1, 17)lança uma exceção, adicione outro hash à linha anterior.

Na verdade, ele retornou um programa mais curto do que eu encontrei manualmente esta manhã. (Portanto, atualizei minha solução acima.) Além disso, tenho certeza de que não há implementação mais curta seguindo esse padrão. Mas você nunca sabe!

Versão golfe - 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)

Observe que pode haver um gerador mais curto, por exemplo, codificando o número necessário de hashes subsequentes para cada linha. Mas este calcula-os e pode ser usado para qualquer N> 16.

Befunge 93 - Cinco milhões setecentos e sessenta e cinco mil e setecentos e setenta e seis caracteres

Exijo ser levado a sério ...

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 razões pelas quais. 1ª razão: um script befunge é sempre 80x25, então não importa o que aconteça, tinha que haver algo que fosse reduzido nas linhas com o código. Segunda razão: por que algo tem cerca de 5,5 milhões de espaços, é porque 720 720 é o menor múltiplo comum de 1 a 16 ... Significa que não haverá quebra de linha quando estivermos pulando caracteres. 3ª razão: uau, isso é bastante absurdo.

209 caracteres (Vários idiomas)

Eu apenas tentei manter as coisas simples e evitar colocar qualquer coisa em posições com muitos fatores principais. A vantagem é a capacidade de executar em várias linguagens de script. Ele deve funcionar em qualquer idioma que não seja deliberadamente perverso e possua os seguintes recursos:

• Literais inteiros
• Operadores aritméticos básicos +, - (subtração e negação), *, /
• Imprime a avaliação de uma expressão simples
• Tem um único caractere que inicia um comentário de linha

Por exemplo,

Intérprete de linha de comando do Python 2 (embora não seja de um arquivo):

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

MATLAB (basta substituir '#' por '%'):

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

NB Deve haver 17 espaços precedendo o primeiro '1'. Vocês conhecem muitos idiomas, então, por favor, ajude-me a listar mais do que poderia ser executado (:

EDIT: Adicionado unário + na posição 0 para Python para evitar que a linha seja recuada.

CJam, 89 bytes

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

Essa abordagem não usa nenhum tipo de comentário.

ilança para inteiro, por isso é um noop aqui. Pode ser substituído por espaço em branco, mas as letras parecem mais legíveis para mim ...

Experimente online executando o seguinte código :

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*

Exemplo de execução

$ 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 bytes

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

Isso tira proveito dos comentários ( #) e dos "super comentários" não documentados (tudo o que segue um incomparável }é ignorado silenciosamente).

_é um noop. Pode ser substituído por espaço em branco, mas os sublinhados parecem mais legíveis para mim ...

Experimente online.

Exemplo de execução

$ 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