Escriba el programa más corto posible de modo que cuando combine el primer carácter y cada enésimo carácter posterior en un nuevo programa, la salida sea N. Esto debe funcionar para N = 1, 2, ..., 16.

Otra forma de decirlo es, si elimina todos los caracteres de su programa, excepto el primero y cada Nth después de eso, la salida del código restante debería ser N.

Ejemplo

Si tu código fuera

ABCDEFGHIJKLMNOP

N = 1 da como resultado ABCDEFGHIJKLMNOP. Ejecutar esto debería generar 1.
N = 2 resultados en ACEGIKMO. Ejecutar esto debería generar 2.
N = 3 resultados en ADGJMP. Ejecutar esto debería generar 3.
N = 4 resultados en AEIM. Ejecutar esto debería generar 4.
N = 5 resultados en AFKP. Ejecutar esto debería generar 5.
N = 6 resultados en AGM. Ejecutar esto debería generar 6.
N = 7 resultados en AHO. Ejecutar esto debería generar 7.
N = 8 resultados en AI. Ejecutar esto debería generar 8.
N = 9 resultados en AJ. Ejecutar esto debería generar 9.
N = 10 resultados en AK. Ejecutar esto debería generar 10.
N = 11 resultados en AL. Ejecutar esto debería generar 11.
N = 12 resulta enAM. Ejecutar esto debería generar 12.
N = 13 resultados en AN. Ejecutar esto debería generar 13.
N = 14 resultados en AO. Ejecutar esto debería generar 14.
N = 15 resultados en AP. Ejecutar esto debería generar 15.
N = 16 resultados en A. Ejecutar esto debería generar 16.

Detalles

• Todos los caracteres están permitidos, ASCII y no ASCII. (También se permiten líneas nuevas y ASCII no imprimibles. Tenga en cuenta que el retorno de carro y el avance de línea cuentan como caracteres distintos).
• Su puntaje es la longitud en caracteres de su programa inalterado (15 en el ejemplo). El puntaje más bajo gana.
• Una puntuación por debajo de 16 es claramente imposible porque entonces al menos dos de los programas alterados serían idénticos.
• La salida puede ser a un archivo o stdout o cualquier otra cosa razonable. Sin embargo, la salida de los 16 programas diferentes debe ir al mismo lugar (por ejemplo, no está bien si AOva a stdout pero Ava a un archivo). No hay entrada
• La salida debe estar en decimal, no hexadecimal. La salida real solo debe contener los 1 o 2 caracteres que componen el número del 1 al 16, nada más. (Cosas como las de Matlab ans =están bien).
• Su programa no tiene que funcionar para N = 17 o 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

Explicación

Comenzaré desde abajo ya que facilitaría la explicación

Hay dos características de lenguaje de APL a tener en cuenta. Uno, APL no tiene prioridad de operador, las declaraciones siempre se evalúan de derecha a izquierda. Dos, muchas funciones APL se comportan de manera bastante diferente dependiendo de si se le da un argumento a su derecha (monádico) o dos argumentos a su izquierda y derecha (diádico).

Monadic ⌊es redondeado hacia abajo (función de piso), Dyadic ×es obviamente una multiplicación, ⍝comenta el resto de la línea
.

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

9:⌊/9×1
/ es reducir. Básicamente toma la función de la izquierda y la matriz de la derecha, inserta la función entre cada par de elementos de la matriz y evalúa. (Esto se llama "plegar" en algunos idiomas)
Aquí, el argumento correcto es un escalar, por lo /que no hace nada.

8:⌊|8×× 2
Monadic ×es la función signum y monadic |es la función de valor absoluto Entonces, se × 2evalúa 1y |8×1es, por supuesto,8

7:⌊11-4 ⍝ debería ser obvio

6:⌊⍟19×51⍝2
Monadic ⍟es un registro natural
Entonces, ⍟19×51evalúa ln(19×51) = 6.87626...y ⌊redondea a6

5:⌊⍟21×○5
Monadic ○multiplica su argumento por π
⍟21×○5esln(21×5π) = 5.79869...

4:⌊7|18××4×1 ⍝2
Dyadic |es la función mod que se
×4×1evalúa 1y 7|18×1es18 mod 7 = 4

3:⌊○⍟/119-××5 1 ⍝ 2
los valores separados por espacios son una matriz. Tenga en cuenta que en APL, cuando la mayoría de las funciones escalares son argumentos de matriz, es un mapa implícito.
Dyadic ⍟es log
Entonces ××5 1, es signum of signum en 5 y 1, lo que da 1 1, 119-1 1es ¯118 ¯118( ¯es solo el signo menos. APL tiene que distinguir entre números negativos y resta), y ⍟/¯118 ¯118es log _-118 (-118) = 1

2:⌊⍟7⍟|21189×1×345× 1 ⍝⍝_2
Puedes resolverlo tú mismo

1:⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_× 1_ _⍝_⍝ __2
Este consiste en un uso más complicado de /. Si nes un número, Fes una función y Aes una matriz, nF/Atoma cada grupo de nentradas consecutivas Ay aplica F/. Por ejemplo, 2×/1 2 3toma cada par de entradas consecutivas (que son 1 2y 2 3) y se aplica ×/a cada grupo para dar 2 6
So, 1|/2111118 9solo retorna 2111118 9(como se aplica |/a los escalares). Luego, ⍟○7⍟⍟aplica ln, luego registra ₇ a esos números, luego los multiplica por π y ln nuevamente. Los números que salen del otro lado están 1.46424... 0.23972...
aquí, ⊃solo se usan para seleccionar el primer elemento de una matriz.

Python - 1201 1137 (generador: 241 218) - ¡Vivan los hashes!

Estrategia:

Traté de comenzar cada línea con tantos hashes como la salida deseada n. Entonces, todas las demás versiones omitirán esta línea por completo.

La principal dificultad, sin embargo, fue agregar el número correcto de hashes para que la próxima ejecución llegue exactamente al comienzo de la siguiente línea. Además, pueden producirse interferencias con otras versiones, por ejemplo, la versión 16 salta directamente al printcomando de la línea 5 y así sucesivamente. Así que esto fue una gran cantidad de prueba y error combinados con un script auxiliar para pruebas rápidas.

Estadísticas:

• Caracteres: 1201 1137
• Hashes: 1066 1002 (88,1%)
• No hash: 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 prueba:

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

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

Salida:

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

Actualización: ¡Un script generador!

Pensé en mi solución y que debe haber un patrón para generarla algorítmicamente. Así que, aquí vamos:

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)

Construye el programa línea por línea:

1. Comience con un hash.
2. Agregue una nueva línea icon el print icomando y los i - 1hashes entre cada dos caracteres vecinos.
3. Si bien la "versión i" (cada carácter i-ésimo) del programa actual no contiene el comando print i(debido a una desalineación) o cualquier nversión con n in range(1, 17)una excepción, agrega otro hash a la línea anterior.

En realidad, devolvió un programa más corto que el que encontré manualmente esta mañana. (Así que actualicé mi solución anterior). Además, estoy bastante seguro de que no hay una implementación más corta siguiendo este patrón. ¡Pero nunca se sabe!

Versión golfizada - 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)

Tenga en cuenta que puede haber un generador más corto, por ejemplo, codificando el número requerido de hashes sucesivos para cada línea. Pero éste los calcula por sí mismo y podría usarse para cualquier N> 16.

Befunge 93: cinco millones setecientos sesenta y cinco mil setecientos setenta y seis caracteres

Exijo que me tomen en serio ...

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 razones por las cuales 1.a razón: un script befunge siempre es 80x25, así que no importa qué, debe haber algo que se reduzca en las líneas con código. 2da razón: por qué ese algo tiene aproximadamente 5.5 millones de espacios es porque 720 720 es el múltiplo común más pequeño de 1 a 16 ... Significa que no habrá desorden cuando salteamos caracteres. Tercera razón: wow, esto es bastante absurdo.

209 caracteres (varios idiomas)

Solo traté de mantener las cosas simples y evitar poner algo en posiciones con muchos factores primos. La ventaja es la capacidad de ejecutarse en muchos lenguajes de secuencias de comandos. Debería funcionar en cualquier idioma que no sea deliberadamente perverso y tenga las siguientes características:

• Literales enteros
• Operadores aritméticos básicos +, - (resta y negación), *, /
• Imprime la evaluación de una expresión desnuda.
• Tiene un solo carácter que comienza un comentario de línea

Por ejemplo,

Intérprete de línea de comandos de Python 2 (aunque no de un archivo):

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

MATLAB (simplemente reemplace '#' con '%'):

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

NB Debe haber 17 espacios antes del primer '1'. Ustedes saben muchos idiomas, así que por favor, ayúdenme a enumerar más de lo que podría ejecutarse (:

EDITAR: Se agregó unario + en la posición 0 para Python para evitar que la línea se sangra.

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-

Este enfoque no utiliza ningún tipo de comentarios.

ise convierte en entero, por lo que es un noop aquí. Podría ser reemplazado por espacios en blanco, pero las letras me parecen más legibles ...

Pruébelo en línea ejecutando el siguiente 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*

Ejecución de ejemplo

$ 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

Esto aprovecha los comentarios ( #) y los "supercomentarios" no documentados (todo lo que sigue a un no }coincidente se ignora en silencio).

_Es un noop. Podría ser reemplazado por espacios en blanco, pero los guiones bajos me parecen más legibles ...

Pruébalo en línea.

Ejecución de ejemplo

$ 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