Organizzare la scena:

È un pomeriggio medio, mentre ti rilassi dopo una lunga giornata impegnandoti nel tuo passatempo preferito: rispondere alla pletora di domande accattivanti su PPCG. Non è stata una buona giornata per te; quei dannati programmatori Pyth continuano a ricevere la risposta migliore e stanno uccidendo la tua atmosfera. Improvvisamente, si nota che è stata pubblicata una nuova domanda! Decidi tu; non questa volta CJammers. Furiosamente, inizi a scrivere, dando vita a un flusso di personaggi; un feto del glorioso loop BrainFuck che sarà il tuo prodotto finale. Digiti e digiti. Più veloce! Ancora più veloce! Sei così concentrato che non ti accorgi nemmeno che le luci sullo schermo iniziano a lampeggiare. All'improvviso, il monitor si illumina di verde, un simbolo simile ad un alieno marchiato sul desktop. Usando le tue abilità impeccabili tucat ~/Desktop/aliensymbole vieni presentato con un mucchio di numeri, un messaggio! Essendo il programmatore PPCG accorto che sei, noti che sembra ASCII. Non importa per te, tu print(chr(i) for i in file)e decifrare il messaggio. Il tuo primo pensiero: "Devo condividere questo con la comunità!".

...

Chi l'avrebbe mai pensato? Che le prime persone a contattare gli alieni sarebbero gli umili programmatori di PPCG. Perché noi? Forse è perché siamo l'epitome dell'intelligenza umana. O forse perché BrainFuck è più vicino che dobbiamo a una lingua aliena. Tuttavia, gli alieni - essendo le forme di vita ultra-intelligenti che sono - vogliono verificare se dovrebbero classificare la razza umana come intelligente o no. Come prova della nostra abilità mentale, gli alieni ci hanno chiesto di inviare loro alcuni programmi per computer per dimostrare che siamo tecnologicamente colti. Il problema è che l'unico linguaggio umano che comprendono è ASCII numerico!

Aiuta l'umanità a mostrare a quelle creature chi è il vero alfa intellettuale. Dobbiamo inviare loro uno script che convertirà i nostri codici sorgente basati su testo nelle loro versioni numeriche ASCII. Sfortunatamente, a causa della nostra tecnologia sottosviluppata (grazie Obama), dobbiamo inviare il più piccolo programma di traduzione possibile. Per fortuna hanno scelto di contattare PPCG!

La sfida:

La premessa di questa sfida è semplice: devi scrivere un programma che prenderà il codice sorgente di qualsiasi programma (o qualsiasi file di testo generale per quella materia), e ne produrrà una versione separata da spazio con una traduzione ASCII sotto ogni riga. Cioè, dato un input di un file di testo, è necessario emettere ciascuna riga di quel file seguita da una riga contenente la rappresentazione ASCII di ciascun carattere nella riga sopra di esso (con ogni numero in fila con il carattere che rappresenta).

Un esempio chiarirà molto questo. Prendendo il codice sorgente del famigerato hello worldcome input:

#include <stdio.h>

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

il tuo programma dovrebbe produrre:

#   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

Dettagli di implementazione:

Puoi scegliere di prendere l'input in qualunque forma tu voglia (apertura del file, pipe della riga di comando, parametro della funzione ecc.) E dovresti emettere in stdout o restituire l'output di una funzione.

Cose da notare

• Ogni carattere nell'output è separato da un '\ t' per consentire lo spazio di 3 cifre nella riga sottostante per allinearsi (supponiamo che la tua scheda sia impostata su 4 o più spazi).
• Le nuove righe vengono visualizzate sulla riga in cui è stato premuto il tasto Invio (notare i 10 nell'esempio)
• I requisiti di stampa '\ t' e '\ n' sono lassisti. La tua produzione deve, in senso generale, apparire piacevole alla vista (è necessario mostrare anche a quegli alieni che abbiamo un senso estetico), e se puoi piegare i due punti precedenti mantenendo l'integrità visiva, verrai perdonato.
• Puoi scegliere di assumere se c'è una nuova riga alla fine dell'ultima riga.

punteggio

Questo è code-golf, quindi il programma più corto vince. Nota, anche se il tuo programma non è il più breve, ma utilizza trucchi davvero accurati rispetto alla lingua che stai utilizzando, molti +1 per te!

In bocca al lupo. La classifica dell'intelligenza intergalattica dell'umanità riposa sulle tue spalle.

Nota: per favore perdona i buchi della trama. Non sono uno scrittore : D

Dyalog APL , 14 byte

Elenco di stringhe che includono sequenze di nuova riga (10 o 13 10 ecc.)

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

↑ maturare l'elenco di liste composto da

(... )¨per ogni ritorno di riga ...

 ⊢ il testo stesso

 ,[.5] seguito in una nuova dimensione prima della prima dimensione da

 ⎕UCSi U nicode C haracter S et punti di codice

ProvaAPL online!

Pyth, 17 13 byte

Un altro di quei programmatori Pyth. Scusate.

Il nuovo codice richiede che ogni riga sia racchiusa tra virgolette e sfuggita (comprese le nuove righe se si desidera che vengano stampate), ma inserisce una riga aggiuntiva tra la riga e l'ASCII.

jjLC9smCMBd.Q

Provalo online!

Spiegazione:

           .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

Sto mantenendo il vecchio codice e la sua 'spiegazione di seguito.

#Jw
jKC9J
jK+CMJT

Provalo online! o utilizzare un caso di test di facile lettura .

Spiegazione:

#                  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 byte

Questo utilizza un approccio leggermente diverso rispetto alla risposta del PO. Si noti che SO incasina le mie schede letterali con spazi.

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

Provalo online

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

È troppo lungo, ma è quello che ottieni quando usi la evalfunzione di vim ( \=).

Perl, > 33 31 byte

Include +3 per -F(non può essere combinato con -ee anche il codice ha ', quindi spazio e -vengono conteggiati anche).

Esegui con l'input su STDIN o assegna uno o più nomi di file come argomento

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

asciidump.pl

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

L'output non è estetico se il testo contiene una scheda o non è presente una nuova riga finale

Pyth, 21 byte

j.imjC9d.zmjC9+CMdT.z

Ecco una voce da uno di "quei dannati programmatori Pyth" ;)

Un programma che accetta l'input di una stringa multilinea non quotata su STDIN e stampa il risultato. Ciò presuppone che tutti gli input abbiano una nuova riga finale. Se vuoi che non abbia a che fare con una nuova riga finale, aggiungi <all'inizio del programma e )_3alla fine.

Provalo online

L'output per il test case è difficile da vedere nell'interprete online, quindi l'ho incluso qui:

#   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

Come funziona

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 byte

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

Può essere testato in questo modo

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

PowerShell v2 +, 85 byte

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

L'input avviene tramite un percorso a un file. Quindi Get-Content(alias gc) su quel file, che si divide automaticamente su newline. Passiamo sopra ciascuno di questi |%{...}. Inizia impostando $ae $bcon una stringa vuota: questi sono rispettivamente i nostri caratteri ASCII e punti di codice. Quindi -splitinseriamo la riga di input su ogni carattere, mantenendolo (.)e rimuovendo i valori vuoti -ne''(è dovuto al modo in cui .NET regex analizza), quindi li inviamo in un altro ciclo.

Ogni ciclo interno, stringiamo concatenare il carattere corrente con una scheda `te lo aggiungiamo a $a. Allo stesso modo $b, ad eccezione del fatto che stiamo esplicitamente eseguendo il casting come a chare quindi come int +.

Al di fuori del circuito interno, posizioniamo il risultante $ae $b(con un designatore di avanzamento riga, poiché non verrà mai visualizzato nel nostro ciclo) sulla tubazione. Quelli sono raccolti con un implicito Write-Outputal completamento del programma.

Esempio

(con la consapevolezza che ho un avanzamento di riga finale e Markdown modifica il carattere di tabulazione)

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

> <> (Pesce), 48 byte

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

Un compito in cui brilla la lingua! Sono sicuro che probabilmente avrei potuto giocare a golf un po 'di più, ma è stata una lunga settimana. Potrebbe dare un'occhiata più tardi però.

Provalo online!

Alternativamente provalo online che a mio avviso sembra più bello, ma il wrapping del testo incasina un po 'per l'input con righe lunghe come il caso di test.

PHP, 131 115 byte

Solo un FGITW, forse posso migliorarlo di più. Si scopre che posso!

Prima versione a 131 byte:

<?$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'
';};

Il nome file viene fornito come primo argomento dopo il nome dello script: php aliens.php helloworld.c

Seconda versione a 115 byte:

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

La prima versione tiene conto delle righe mancanti alla fine della riga, ma dopo l'ulteriore chiarimento, possiamo lasciare quel codice fuori e mettere tutto in una funzione per salvare 16 byte.

I caratteri degli spazi bianchi join(' ',$a)e quelli in echo$c.' 'sono caratteri di tabulazione = \t. Le nuove righe nel codice sono intenzionali.

Python 3, 89 77 byte

versione più giocata sulla base della stessa idea:

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

Se ci sono "\ t" nell'input, cambia 4in a 9.

Versione precedente:

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

Prende un elenco di stringhe, ciascuna che termina con un '\ n'.

Powershell, 56 byte

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

Lo script accetta un percorso file come input. Get-Content divide automaticamente l'input in una matrice di stringhe suddivise su newline nell'origine.

Da lì entro in una foreach, eseguo il cast su un array di caratteri e lo imposto su $ a, unisco quello con le schede e lo stampo. Successivamente, ma sempre all'interno della foreach, ho lanciato l'array di caratteri in un array intero, ho aggiunto un avanzamento di riga e mi sono unito nuovamente con una scheda.

La chiamata è simile al seguente:

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

e qui è un esempio di output

#   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 byte

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

Dove ␉ rappresenta il carattere di tabulazione letterale. Funziona finché l'input non contiene caratteri di tabulazione. Versione a 81 byte che richiede anche che l'input abbia una nuova riga finale:

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

C #, 64 63 byte

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

-1 byte utilizzando il carattere di tabulazione effettivo anziché \t. Nota: viene visualizzato come 4 spazi sopra e 2 spazi nella versione non modificata sotto.

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

risultati:

(Nota: Visual Studio ha usato \r\nper le nuove linee quando ho incollato l'input, quindi le 13 10terminazioni di riga nell'output)

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 byte

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

Provalo online!

Spiegazione

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 byte

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

Cose da notare:

• Legge l'input da un file denominato mnella directory corrente.
• Tutte le interruzioni di riga (inclusa quella incorporata nella stringa dopo la prima $_) sono solo avanzamenti di riga letterali (0xA), quindi un byte ciascuno.
• I contenuti delle stringhe direttamente dopo gli -joinoperatori sono ciascuno un singolo carattere di tabulazione (indipendentemente da come viene visualizzato qui).

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 byte

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

Non posso nemmeno preoccuparmi di rendere questo più corto ..

Haskell - 71 byte

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

Python 3, 92 97 107 byte

per i nella lista (open (input ()). read (). split ("\ n")): per j in 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)

Questo non è testato, ma dovrebbe funzionare.

Grazie @gowrath per aver sottolineato che il codice non funziona come specificato dalla domanda.