Preparando a cena:

É uma tarde normal, enquanto você relaxa após um longo dia participando de seu passatempo favorito: respondendo à infinidade de perguntas cativantes no PPCG. Não foi um bom dia para você; esses malditos programadores Pyth continuam recebendo a melhor resposta e isso está matando sua vibe. De repente, você percebe que uma nova pergunta foi publicada! Você decide; não desta vez CJammers. Furiosamente, você começa a digitar, criando um fluxo de caracteres; um feto do glorioso loop BrainFuck que seu produto final será. Você digita e digita. Mais rápido! Mais rápido, ainda! Você está tão concentrado que nem percebe que as luzes na tela começam a piscar. De repente, o monitor brilha em verde, um símbolo alienígena marcado na área de trabalho. Usando suas habilidades impecáveis ​​vocêcat ~/Desktop/aliensymbole receba um monte de números, uma mensagem! Sendo o programador astuto de PPCG que você é, você percebe que ele se parece com ASCII. Não importa para você, você print(chr(i) for i in file)e decifra a mensagem. Seu primeiro pensamento: "Eu preciso compartilhar isso com a comunidade!".

...

Quem teria pensado isso? Que as primeiras pessoas a fazer contato com alienígenas seriam os humildes programadores do PPCG. Por que nós? Talvez seja porque somos o epítome da inteligência humana. Ou talvez porque o BrainFuck seja tão próximo quanto o de uma língua estrangeira. No entanto, os alienígenas - sendo as formas de vida ultra-inteligentes que são - querem testar se devem classificar a raça humana como inteligente ou não. Como teste de nossas proezas mentais, os alienígenas nos pediram para enviar-lhes alguns programas de computador para demonstrar que somos tecnologicamente cultivados. A questão é que a única linguagem humana que eles entendem é ASCII numérica!

Ajude a humanidade a mostrar às criaturas quem é o verdadeiro alfa intelectual. Precisamos enviar a eles um script que converta nossos códigos-fonte baseados em texto em suas versões numéricas ASCII. Infelizmente, devido à nossa tecnologia subdesenvolvida (obrigado Obama), devemos enviar o menor programa de tradução possível. Ainda bem que eles escolheram entrar em contato com a PPCG!

O desafio:

A premissa deste desafio é simples: você deve escrever um programa que utilize o código-fonte de qualquer programa (ou qualquer arquivo de texto geral) e produza uma versão separada por espaço com uma tradução ASCII abaixo de cada linha. Ou seja, dada a entrada de um arquivo de texto, você precisa gerar cada linha desse arquivo seguida por uma linha que contenha a representação ASCII de cada caractere na linha acima (com cada número alinhado com o caractere que representa).

Um exemplo vai esclarecer muito isso. Tomando o código fonte do infame hello worldcomo a entrada:

#include <stdio.h>

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

seu programa deve gerar:

#   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

Detalhes da implementação:

Você pode optar por receber a entrada da forma que desejar (arquivo de abertura, canal de linha de comando, parâmetro de função etc.) e deve enviar para stdout ou retornar a saída de uma função.

Coisas a observar

• Cada caractere na saída é separado por um '\ t' para permitir o espaço de 3 dígitos na linha abaixo para alinhar (vamos assumir que sua guia está configurada para 4 espaços ou mais).
• As novas linhas são exibidas na linha em que a tecla de retorno foi pressionada (observe os 10's no exemplo)
• Os requisitos de impressão '\ t' e '\ n' são pouco flexíveis. Sua produção deve, no sentido geral, parecer agradável aos olhos (é preciso mostrar aos alienígenas que também temos senso estético) e, se você puder dobrar os dois pontos anteriores, mantendo a integridade visual, será perdoado.
• Você pode optar por assumir se há ou não uma nova linha no final da última linha.

Pontuação

Este é o código-golfe, e o programa mais curto vence. Observe que, mesmo que seu programa não seja o mais curto, mas use truques realmente legais em relação ao idioma que você está usando, muitos +1 para você!

Boa sorte. O ranking de inteligência intergaláctica da humanidade repousa sobre seus ombros.

Nota: perdoe os orifícios da plotagem. Eu não sou um escritor : D

Dyalog APL , 14 bytes

Leva a lista de seqüências de caracteres que incluem sequências de nova linha (10 ou 13 10 etc.)

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

↑ matricular a lista de listas que consiste em

(... )¨para cada linha retornada ...

 ⊢ o próprio texto

 ,[.5] seguida em uma nova dimensão antes da primeira dimensão por

 ⎕UCSos U nicode C haracter S et pontos de código

TryAPL online!

Pitão, 17 13 bytes

Outro daqueles programadores Pyth. Desculpe.

O novo código exige que cada linha seja colocada entre aspas e escape (incluindo novas linhas, se você desejar que elas sejam impressas), mas coloca uma nova linha extra entre a linha e o ASCII.

jjLC9smCMBd.Q

Experimente online!

Explicação:

           .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

Estou mantendo o código antigo e sua explicação abaixo.

#Jw
jKC9J
jK+CMJT

Experimente online! ou use um caso de teste mais fácil de ler .

Explicação:

#                  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

Isso usa uma abordagem ligeiramente diferente da resposta do OP. Observe que o SO bagunça minhas guias literais com espaços.

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

Experimente online

Teclas Vim, 86, 77

: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>

Isso é muito longo, mas é o que você obtém quando usa o evalrecurso do vim ( \=).

Perl, > 33 31 bytes

Inclui +3 para -F(não pode ser combinado com -ee o código 'também possui , portanto, espaço e também -são contados).

Execute com a entrada STDIN ou dê um ou mais nomes de arquivos como argumento

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

asciidump.pl

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

A saída não é estética se o texto contiver uma guia ou se não houver uma nova linha final

Pitão, 21 bytes

j.imjC9d.zmjC9+CMdT.z

Aqui está uma entrada de um desses "malditos programadores Pyth" ;)

Um programa que recebe a entrada de uma cadeia de linhas multilinha não citada no STDIN e imprime o resultado. Isso pressupõe que todas as entradas tenham uma nova linha à direita. Se você deseja que ela lide com nenhuma nova linha à direita, adicione <no início do programa e )_3no final.

Experimente online

É difícil ver a saída do caso de teste no intérprete on-line, então incluí-o aqui:

#   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

Como 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("");}}

Pode ser testado assim

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"}

A entrada é via um caminho para um arquivo. Nós Get-Content(alias gc) nesse arquivo, que se divide automaticamente em novas linhas. Nós passamos por cima de cada um deles |%{...}. Comece definindo $ae $bpara uma sequência vazia - esses são nossos caracteres ASCII e pontos de código, respectivamente. Em seguida, colocamos -splita linha de entrada em cada caractere, mantendo-o (.)e removendo os valores vazios -ne''(é devido à maneira como o regex do .NET analisa) e depois os enviamos para outro loop.

A cada loop interno, concatenamos o caractere atual com uma guia `te adicionamos isso a $a. Da mesma forma $b, exceto que estamos explicitamente lançando como a chare depois como int +.

Fora do loop interno, colocamos o resultado $ae $b(com um designador de avanço de linha, pois isso nunca será exibido em nosso loop) no pipeline. Esses são reunidos com um implícito Write-Outputna conclusão do programa.

Exemplo

(com o entendimento de que tenho um avanço de linha à direita e Markdown manipula o caractere de tabulação)

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

> <> (Peixe), 48 bytes

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

Uma tarefa na qual a linguagem brilha! Tenho certeza de que provavelmente poderia ter jogado um pouco mais, mas já faz uma semana. Pode dar uma olhada mais tarde.

Experimente online!

Experimente alternativamente on-line que pareça melhor na minha opinião, mas o empacotamento de texto atrapalha um pouco a entrada com linhas longas como o caso de teste.

PHP, 131 115 bytes

Apenas um FGITW, talvez eu possa melhorar ainda mais. Acontece que eu posso!

Primeira versão em 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'
';};

O nome do arquivo é fornecido como o primeiro argumento após o nome do script: php aliens.php helloworld.c

Segunda versão em 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'
';}};

A primeira versão é responsável por novas linhas ausentes no final da linha, mas após esclarecimentos adicionais, podemos deixar esse código de fora e colocar tudo em uma função para economizar 16 bytes.

Os caracteres de espaço em branco join(' ',$a)e em echo$c.' 'são caracteres de tabulação = \t. As novas linhas no código são de propósito.

Python 3, 89 77 bytes

versão mais golfe com base na mesma idéia:

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

Se houver \ \ t na entrada, altere 4para a 9.

Versão anterior:

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

Leva uma lista de seqüências de caracteres, cada uma terminada com '\ n'.

Powershell, 56 bytes

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

O script aceita um caminho de arquivo como entrada. O Get-Content divide automaticamente a entrada em uma matriz de seqüências de caracteres divididas em novas linhas na fonte.

A partir daí, entrei em um foreach, converti-o em uma matriz de caracteres e defini-o como $ a, uno-o às guias e imprimo-o. Em seguida, mas ainda dentro do foreach, lancei a matriz de caracteres para uma matriz inteira, acrescente um avanço de linha e ingresso novamente em uma guia.

A chamada fica assim:

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

e aqui está uma amostra de saída

#   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`␉`}
`)

Onde ␉ representa o caractere de tabulação literal. Funciona desde que a entrada não contenha caracteres de tabulação. Versão de 81 bytes que também requer que a entrada tenha uma nova linha à direita:

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 usando o caractere de tabulação real em vez de \t. Nota: é processado como 4 espaços acima e 2 espaços na versão não destruída abaixo.

Ungolfed:

/*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: O Visual Studio usou \r\nas novas linhas quando colei a entrada, portanto, as 13 10terminações de linha na saída)

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+*

Experimente online!

Explicação

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' '}

Coisas a serem observadas:

• Lê a entrada de um arquivo nomeado mno diretório atual.
• Todas as quebras de linha (incluindo a incorporada na sequência após a primeira $_) são apenas feeds de linha literais (0xA), portanto, um byte cada.
• O conteúdo das sequências diretamente após os -joinoperadores é um caractere de tabulação único (independentemente de como é renderizado aqui).

Ungolfed

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();}};

Eu não posso nem me incomodar em fazer isso mais curto ..

Haskell - 71 bytes

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

Python 3, 92 97 107 bytes

para i na lista (abrir (entrada ()). ler (). dividir ("\ n")): para j em i: imprimir (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)

Isso não foi testado, mas deve funcionar.

Obrigado @gowrath por apontar que o código não está funcionando como a pergunta especifica.