Preparando la escena:

Es una tarde promedio, ya que te relajas después de un largo día participando en tu pasatiempo favorito: respondiendo a la gran cantidad de preguntas cautivadoras sobre PPCG. No ha sido un buen día para ti; esos malditos programadores de Pyth siguen obteniendo la mejor respuesta y está matando tu ambiente. De repente, te das cuenta de que se ha publicado una nueva pregunta. Te decides; esta vez no CJammers. Furiosamente, comienzas a escribir, generando una corriente de personajes; Un feto del glorioso bucle BrainFuck que será su producto final. Escribes y escribes. ¡Más rápido! ¡Más rápido todavía! Estás tan concentrado que ni siquiera notas que las luces de tu pantalla comienzan a parpadear. De repente, el monitor se ilumina en verde, un símbolo extraterrestre marcado en el escritorio. Usando tus habilidades impecablescat ~/Desktop/aliensymboly que te presenten un montón de números, un mensaje! Siendo el astuto programador de PPCG que eres, te das cuenta de que se parece a ASCII. No importa para ti, print(chr(i) for i in file)descifra el mensaje. Tu primer pensamiento: "¡Necesito compartir esto con la comunidad!".

...

¿Quién lo hubiera pensado? Que las primeras personas en contactar con extraterrestres serían los humildes programadores de PPCG. ¿Porque nosotros? Tal vez sea porque somos el epítome de la inteligencia humana. O tal vez porque BrainFuck está tan cerca como tenemos de un idioma extraño. Sin embargo, los extraterrestres, siendo las formas de vida ultrainteligentes que son, quieren probar si deben clasificar a la raza humana como inteligente o no. Como prueba de nuestra destreza mental, los extraterrestres nos han pedido que les enviemos algunos programas de computadora para demostrar que estamos tecnológicamente cultos. ¡El problema es que el único lenguaje humano que entienden es ASCII numérico!

Ayuda a la humanidad a mostrarles a esas criaturas quién es el verdadero alfa intelectual. Necesitamos enviarles un script que convierta nuestros códigos fuente basados ​​en texto en sus versiones ASCII numéricas. Desafortunadamente, debido a nuestra tecnología subdesarrollada (gracias Obama), debemos enviar un programa de traducción lo más pequeño posible. ¡Qué bueno que eligieron contactar a PPCG!

El reto:

La premisa de este desafío es simple: debe escribir un programa que tomará el código fuente de cualquier programa (o cualquier archivo de texto general) y generará una versión separada por espacios con una traducción ASCII debajo de cada línea. Es decir, dada la entrada de un archivo de texto, debe generar cada línea de ese archivo seguida de una línea que contenga la representación ASCII de cada carácter en la línea superior (con cada número alineado con el carácter que representa).

Un ejemplo aclarará mucho esto. Tomando el código fuente de los infames hello worldcomo entrada:

#include <stdio.h>

int main() {
    printf("hello, world\n");
    return 0;
}

su programa debería generar:

#   i   n   c   l   u   d   e       <   s   t   d   i   o   .   h   >
35  105 110 99  108 117 100 101 32  60  115 116 100 105 111 46  104 62  10

10
i   n   t       m   a   i   n   (   )       {
105 110 116 32  109 97  105 110 40  41  32  123 10
                p   r   i   n   t   f   (   "   h   e   l   l   o   ,       w   o   r   l   d   \   n   "   )   ;
32  32  32  32  112 114 105 110 116 102 40  34  104 101 108 108 111 44  32  119 111 114 108 100 92  110 34  41  59  10
                r   e   t   u   r   n       0   ;
32  32  32  32  114 101 116 117 114 110 32  48  59  10
}
125 10

Detalles de implementacion:

Puede optar por tomar la entrada en la forma que desee (abrir archivo, línea de comando, parámetro de función, etc.) y debe enviar a stdout o devolver la salida de una función.

Cosas a tener en cuenta

• Cada carácter en la salida está separado por un '\ t' para permitir el espacio de 3 dígitos en la línea de abajo para alinear (vamos a suponer que su pestaña está configurada en 4 espacios o más).
• Las nuevas líneas se muestran en la línea donde se presionó la tecla de retorno (observe los 10 en el ejemplo)
• Los requisitos de impresión '\ t' y '\ n' son laxos. Su salida debe, en el sentido general, verse agradable a la vista (necesita mostrar a esos extraterrestres que también tenemos un sentido estético), y si puede doblar los dos puntos anteriores mientras mantiene la integridad visual, será perdonado.
• Puede optar por suponer si hay una nueva línea al final de la última línea.

Tanteo

Este es el código de golf, por lo que gana el programa más corto. Tenga en cuenta que, incluso si su programa no es el más corto, pero usa trucos realmente buenos en relación con el idioma que está utilizando, ¡muchos + 1 para usted!

Buena suerte. La clasificación de inteligencia intergaláctica de la humanidad descansa sobre tus hombros.

Nota: Por favor, perdona los agujeros de la trama. No soy escritor : D

Dyalog APL , 14 bytes

Toma una lista de cadenas que incluyen secuencias de nueva línea (10 o 13 10, etc.)

↑(⊢,[.5]⎕UCS)¨

↑ Matrificar la lista de listas que consiste en

(... )¨para cada línea de retorno ...

 ⊢ el texto en sí

 ,[.5] seguido en una nueva dimensión antes de la primera dimensión por

 ⎕UCSlos U nicode C r incón dele S et puntos de código

TryAPL en línea!

Pyth, 17 13 bytes

Otro de esos programadores Pyth. Lo siento.

El nuevo código requiere que cada línea se envuelva entre comillas y se escape (incluidas las nuevas líneas si desea que se impriman), pero coloca una nueva línea adicional entre la línea y el ASCII.

jjLC9smCMBd.Q

Pruébalo en línea!

Explicación:

           .Q  Evaluate all input lines
      m        For each of those lines:
         Bd     Return the line and
       CM       the line mapped to ASCII characters
     s         Sum all these together to begin alternating between line and mapped line
 jLC9          Join all the characters and numbers in the lines and mapped lines on tabs
j              And join all of those on newlines

Mantengo el código antiguo y su explicación a continuación.

#Jw
jKC9J
jK+CMJT

Pruébalo en línea! o use un caso de prueba más fácil de leer .

Explicación:

#                  Until we run into an error:
 Jw                 Read in the next line of input and call it J.
                     (When there is no line of input, error is thrown that ends program.) 

j                  Join: 
    J               all characters in input line
 KC9                and insert tab characters (C9), which we can refer to later as K.
                        (Setting it to a variable doesn't save or lose bytes.)

                   Implicit print that join with trailing newline.

j                  Join:
   CMJ              the mapping of ASCII numbers to characters in the input,
 K                  inserting tab characters in between every number
  +   T             And with a trailing 10 for the newline at the end.

Python 2, 105 bytes

Esto utiliza un enfoque ligeramente diferente a la respuesta del OP. Tenga en cuenta que SO ensucia mis pestañas literales con espacios.

def f(s):
 o=x=''
 for c in s:
    o+=c+"  ";x+="%s    "%ord(c)
    if"\n"==c:print o[:-1],x;o=x=''
 print o+"\n"+x

Pruébalo en línea

Vim, 86, 77 pulsaciones de teclas

:g/^/norm A<C-v><C-v>10<C-v><esc>Yp:s/./\=char2nr(submatch(0))."\t"/g<C-v><cr>k:s/./&\t/g<C-v><cr>
:%s/<C-v><cr>0<cr>

Esto es demasiado largo, pero eso es lo que obtienes cuando usas la evalfunción de vim ( \=).

Perl, > 33 31 bytes

Incluye +3 para -F(no se puede combinar con -ey el código 'también, así que el espacio y también -se cuentan).

Ejecutar con la entrada en STDIN o dar uno o más nombres de archivo como argumento

perl -M5.010 asciidump.pl <<< "Hoi"

asciidump.pl

#!/usr/bin/perl -F
$"=v9;say"@F@{[unpack'W*']}"

El resultado no es estético si el texto contiene una pestaña o no hay una nueva línea final

Pyth, 21 bytes

j.imjC9d.zmjC9+CMdT.z

Aquí hay una entrada de uno de "esos malditos programadores de Pyth" ;)

Un programa que toma la entrada de una cadena multilínea sin comillas en STDIN e imprime el resultado. Esto supone que todas las entradas tienen una nueva línea final. Si desea que no se ejecute una nueva línea final, agregue <al principio del programa y )_3al final.

Pruébalo en línea

El resultado para el caso de prueba es difícil de ver en el intérprete en línea, así que lo he incluido aquí:

#   i   n   c   l   u   d   e       <   s   t   d   i   o   .   h   >
35  105 110 99  108 117 100 101 32  60  115 116 100 105 111 46  104 62  10

10
i   n   t       m   a   i   n   t   (   )       {
105 110 116 32  109 97  105 110 116 40  41  32  123 10
                p   r   i   n   t   f   (   "   h   e   l   l   o   ,       w   o   r   l   d   \   n   "   )   ;
32  32  32  32  112 114 105 110 116 102 40  34  104 101 108 108 111 44  32  119 111 114 108 100 92  110 34  41  59  10
                r   e   t   u   r   n       0   ;
32  32  32  32  114 101 116 117 114 110 32  48  59  10
}
125 10

Cómo funciona

j.imjC9d.zmjC9+CMdT.z  Program. Input: .z (All of STDIN split on newlines)
     C9                 Yield tab character by taking chr(9)
    j                   Join on tab
   m   d.z             Map that over .z
               CM       Map ord()
              +   T     Append 10
           jC9          Join on tab
          m      d .z  Map that over .z
 .i                    Interleave the results of the two mappings
j                      Join on newlines
                       Implicitly print

C, 136 117 114 Bytes

#define p(s)while(l[i])printf(s,l[i++]);i=0;puts("")
char l[99];i;f(f){while(fgets(l,99,f)){p("%c\t");p("%d\t");}}

char l[99];i;f(f){while(fgets(l,256,f)){i=0;while(l[i])printf("%c\t",l[i++]);i=0;puts("");while(l[i])printf("%d\t",l[i++]);puts("");}}

Puede ser probado así

infile;
main(c,v)char**v;
{
    infile=fopen(v[1],"r");
    f(infile);    
}

PowerShell v2 +, 85 bytes

gc $args|%{$a=$b='';$_-split'(.)'-ne''|%{$a+="$_`t";$b+="$(+[char]$_)`t"};$a;$b+"10"}

La entrada es a través de una ruta a un archivo. Luego Get-Content(alias gc) en ese archivo, que se divide automáticamente en las nuevas líneas. Hacemos un bucle sobre cada uno de esos |%{...}. Comience configurando $ay $ben una cadena vacía: estos son nuestros caracteres ASCII y puntos de código respectivamente. Luego, -splitla línea de entrada en cada carácter, manteniéndola (.)y eliminando los valores vacíos -ne''(se debe a cómo analiza .NET regex), luego los enviamos a otro bucle.

Cada ciclo interno, encadenamos el carácter actual con una pestaña `ty lo agregamos $a. Del mismo modo $b, excepto que estamos explícitamente lanzando como ay charluego como int +.

Fuera del bucle interno, colocamos el resultado $ay $b(con un designador de salto de línea, ya que eso nunca aparecerá en nuestro bucle) en la tubería. Esos se reúnen con un implícito Write-Outputen la finalización del programa.

Ejemplo

(con el entendimiento de que tengo un salto de línea final y Markdown destruye el carácter de tabulación)

PS C:\Tools\Scripts\golfing> .\aliens-only-understand-ascii.ps1 '.\aliens-only-understand-ascii.txt'
#   i   n   c   l   u   d   e       <   s   t   d   i   o   .   h   >   
35  105 110 99  108 117 100 101 32  60  115 116 100 105 111 46  104 62  10

10
i   n   t       m   a   i   n   t   (   )       {   
105 110 116 32  109 97  105 110 116 40  41  32  123 10
                p   r   i   n   t   f   (   "   h   e   l   l   o   w   ,       w   o   r   l   d   \   n   "   )   ;   
32  32  32  32  112 114 105 110 116 102 40  34  104 101 108 108 111 119 44  32  119 111 114 108 100 92  110 34  41  59  10
                r   e   t   u   r   n       0   ;   
32  32  32  32  114 101 116 117 114 110 32  48  59  10
}   
125 10

> <> (Pescado), 48 Bytes

>i:0(?v::oa=?v9o
2';'oa<.20r  <~p3
o9nv?=0l
voa<

¡Una tarea en la que brilla el lenguaje! Estoy seguro de que probablemente podría haber jugado un poco más al golf, pero ha sido una semana larga. Sin embargo, podría echarle un vistazo más tarde.

Pruébalo en línea!

Alternativamente, pruébelo en línea que se ve mejor en mi opinión, pero el ajuste de texto se complica un poco para la entrada con líneas largas como el caso de prueba.

PHP, 131 115 bytes

Solo un FGITW, tal vez pueda mejorarlo más. Resulta que puedo!

Primera versión a 131 bytes:

<?$s=file($argv[1]);foreach($s as$l){$a=str_split(trim($l));echo join(' ',$a).'
';$i=0;while($c=ord($l{$i++}))echo$c.'  ';echo'
';};

El nombre del archivo se proporciona como primer argumento después del nombre del script: php aliens.php helloworld.c

Segunda versión a 115 bytes:

function($s){foreach($s as$l){$a=str_split($l);echo join('  ',$a);$i=0;while($c=ord($a[$i++]))echo$c.'  ';echo'
';}};

La primera versión tiene en cuenta las líneas nuevas que faltan al final de la línea, pero después de la aclaración adicional, podemos dejar ese código y poner todo en una función para guardar 16 bytes.

Los espacios en blanco join(' ',$a), así como en, echo$c.' 'son caracteres de tabulación = \t. Las nuevas líneas en el código son a propósito.

Python 3, 89 77 bytes

versión más golfizada basada en la misma idea:

def f(s):
 for a in s:print(*map('{:>4}'.format,[*a,*a.encode()]),end='\n\n')

Si hay '\ t's en la entrada, entonces cambie el 4a a 9.

Versión anterior:

def f(s):
 for l in s:
  print(*l,sep='\t',end='');print(*l.encode(),sep='\t',end='\n\n')

Toma una lista de cadenas, cada una terminando con un '\ n'.

Powershell, 56 Bytes

gc $args|%{($a=[char[]]$_)-join"    ";[int[]]$a+10-join"    "}

El script acepta una ruta de archivo como entrada. Get-Content divide automáticamente la entrada en una serie de cadenas divididas en nuevas líneas en la fuente.

A partir de ahí, ingreso un foreach, lo elevo a una variedad de caracteres y lo configuro en $ a, lo uno con pestañas e imprimo. A continuación, pero aún dentro del foreach, convierto la matriz de caracteres en una matriz de enteros, agrego un salto de línea y vuelvo a unirme con una pestaña.

La llamada se ve así:

PS C:\PretendFolder> .\aoua.ps1 ".\aoua.txt"

y aquí hay una muestra de salida

#   i   n   c   l   u   d   e       <   s   t   d   i   o   .   h   >
35  105 110 99  108 117 100 101 32  60  115 116 100 105 111 46  104 62  10

10
i   n   t       m   a   i   n   (   )       {
105 110 116 32  109 97  105 110 40  41  32  123 10
                p   r   i   n   t   f   (   "   h   e   l   l   o   ,       w   o   r   l   d   \   n   "   )   ;
32  32  32  32  112 114 105 110 116 102 40  34  104 101 108 108 111 44  32  119 111 114 108 100 92  110 34  41  59  10
                r   e   t   u   r   n       0   ;
32  32  32  32  114 101 116 117 114 110 32  48  59  10
}
125 10

JavaScript (ES6), 94 bytes

s=>s.replace(/(.*)\n?/g,(s,n)=>n&&[...s].join`␉`+`
${[...n].map(c=>c.charCodeAt()).join`␉`}
`)

Donde ␉ representa el carácter de tabulación literal. Funciona siempre que la entrada no contenga caracteres de tabulación. Versión de 81 bytes que también requiere que la entrada tenga una nueva línea final:

s=>s.replace(/.*\n/g,s=>[...s].join`␉`+[...s].map(c=>c.charCodeAt()).join`␉`+`
`)

C #, 64 63 bytes

s=>{foreach(int c in s+(s=""))s+=c+(10==c?"\n":"    ");return s;};

-1 byte utilizando el carácter de tabulación real en lugar de \t. Nota: se representa como 4 espacios arriba y 2 espacios en la versión sin golf debajo.

Sin golf:

/*Func<string, string> Lambda =*/ s =>
{
    // Enumerate the ascii (int) values of the chars in s, 
    // but at the same time set input s to "" to use at the output var.
    // +(s="")   is 2 bytes less than   var o="";
    foreach (int c in s + (s=""))
        // Append the string representation of the ascii value,
        // Append new line if c was new line, otherwise append tab. 
        s += c + (10==c ? "\n" : "  ");
    return s;
};

Resultados:

(Nota: Visual Studio se ha utilizado \r\npara las nuevas líneas cuando pegué la entrada, por lo tanto, las 13 10terminaciones de línea en la salida)

Input:

#include <stdio.h>

int maint() {
    printf("hello, world\n");
    return 0;
}

Output:

35  105 110 99  108 117 100 101 32  60  115 116 100 105 111 46  104 62  13  10
13  10
105 110 116 32  109 97  105 110 116 40  41  32  123 13  10
32  32  32  32  112 114 105 110 116 102 40  34  104 101 108 108 111 44  32  119 111 114 108 100 92  110 34  41  59  13  10
32  32  32  32  114 101 116 117 114 110 32  48  59  13  10
125 

CJam, 27 bytes

qN/{_1/9c*N+\{is9c}%+}%AN+*

Pruébalo en línea!

Explicación

q       e# Take the whole input
N/      e# Split on newlines
{       e# Map this block to every line:
_        e# Duplicate
1/       e# Split into characters
9c*      e# Join with tabs (ASCII code 9)
N+       e# Append a newline
\        e# Swap top elements
{is9c}%  e# Map each character to its ASCII code plus a tab character
+        e# Concatenate the two lines
}%      e# (end of block)
AN+*    e# Join with "10" plus a newline

PowerShell, 61 59 bytes

gc m|%{$b="$_
"[0..$_.Length]
$b-join'    '
[int[]]$b-join' '}

Cosas a tener en cuenta:

• Lee la entrada de un archivo nombrado men el directorio actual.
• Todos los saltos de línea (incluido el incrustado en la cadena después del primero $_) son solo saltos de línea literales (0xA), por lo que un byte cada uno.
• El contenido de las cadenas directamente después de los -joinoperadores es un carácter de tabulación individual (independientemente de cómo se represente aquí).

Sin golf

Get-Content m | ForEach-Object -Process { # Read the file line by line
    $b = "$_`n"[0..$_.Length]   # Line by line processing strips line endings, so add a newline
                                # Index operator on a [string] returns a [char], or given a [range], a [char[]]
                                # Using $_.Length automatically accounts for the extra linebreak (0 based index)
    $b -join "`t"               # PowerShell displays [char] as the printable character by default, so join the array with a tab
    [int[]]$b -join "`t"        # We need to convert the [char]s to an [int]s so we can display it as a number
                                # So cast the [char[]] as [int[]], then join with tab again

}

Java, 202 bytes

s->{for(String g : s.split("\n")){g.chars().forEach(c->System.out.print((char)c+"   "));System.out.println();g.chars().forEach(c->System.out.print(c+(c<10?"  ":c<100?"  ":" ")));System.out.println();}};

Ni siquiera me molesto en hacer esto más corto ...

Haskell - 71 bytes

f q=unlines[(x>>=(++"\t").show.ord)++'\n':intersperse '\t'x|x<-lines q]

Python 3, 92 97107 bytes

para i en la lista (open (input ()). read (). split ("\ n")): para j en i: print (i + "\ n" + ord (j))

p=print
for i in list(open(input()).read().split("\n"))
    s=t=''
    for j in i:
        r=str(ord(j))
        s+=j+' '*len(r)
        t+=r+' '
    p(s)
    p(t)

Esto no se ha probado, pero debería funcionar.

Gracias @gowrath por señalar que el código no funciona como lo especifica la pregunta.