Einstellen der Szene:

Es ist ein durchschnittlicher Nachmittag, an dem Sie nach einem langen Tag die Seele baumeln lassen, indem Sie sich auf Ihre Lieblingsbeschäftigung einlassen: die Beantwortung der Fülle faszinierender Fragen zu PPCG. Es war kein guter Tag für dich; Diese verdammten Pyth-Programmierer bekommen immer die beste Antwort, und es bringt deine Stimmung um. Plötzlich stellen Sie fest, dass eine neue Frage gestellt wurde! Sie entscheiden sich; diesmal nicht CJammers. Wütend fängt man an zu tippen und erzeugt einen Strom von Charakteren. ein Fötus der herrlichen BrainFuck-Schleife, die Ihr Endprodukt sein wird. Sie tippen und tippen. Schneller! Immer noch schneller! Sie sind so fokussiert, dass Sie nicht einmal bemerken, dass die Lichter auf Ihrem Bildschirm anfangen zu blinken. Plötzlich leuchtet der Monitor grün, ein fremdartiges Symbol auf dem Desktop. Verwenden Sie Ihre makellosen Fähigkeitencat ~/Desktop/aliensymbolund erhalten Sie eine Reihe von Zahlen, eine Nachricht präsentiert! Als der kluge PPCG-Programmierer, der Sie sind, bemerken Sie, dass es wie ASCII aussieht. Egal für Sie, Sie print(chr(i) for i in file)und entschlüsseln die Nachricht. Dein erster Gedanke: "Ich muss das mit der Community teilen!".

...

Wer hätte das gedacht? Dass die ersten Leute, die Kontakt mit Außerirdischen aufnehmen, die bescheidenen Programmierer von PPCG sind. Warum wir? Vielleicht liegt es daran, dass wir der Inbegriff menschlicher Intelligenz sind. Oder vielleicht, weil BrainFuck einer fremden Sprache so nahe kommt wie wir. Nichtsdestotrotz wollen die Außerirdischen - die ultraschlauen Lebensformen, die sie sind - testen, ob sie die menschliche Rasse als intelligent einstufen sollen oder nicht. Als Test für unser geistiges Können haben die Außerirdischen uns gebeten, ihnen ein paar Computerprogramme zu schicken, um zu demonstrieren, dass wir technologisch kultiviert sind. Das Problem ist, dass die einzige menschliche Sprache, die sie verstehen, numerisches ASCII ist!

Hilf der Menschheit, diesen Kreaturen zu zeigen, wer das wahre intellektuelle Alpha ist. Wir müssen ihnen ein Skript senden, das unsere textbasierten Quellcodes in ihre numerischen ASCII-Versionen konvertiert. Leider müssen wir aufgrund unserer unterentwickelten Technologie (danke Obama) ein so kleines Übersetzungsprogramm wie möglich schicken. Gut, dass sie sich entschieden haben, PPCG zu kontaktieren!

Die Herausforderung:

Die Prämisse dieser Herausforderung ist einfach: Sie müssen ein Programm schreiben, das den Quellcode eines beliebigen Programms (oder eine beliebige allgemeine Textdatei) verwendet und eine durch Leerzeichen getrennte Version davon mit einer ASCII-Übersetzung unter jeder Zeile ausgibt. Wenn Sie also eine Textdatei eingeben, müssen Sie jede Zeile dieser Datei ausgeben, gefolgt von einer Zeile, die die ASCII-Darstellung jedes Zeichens in der darüber liegenden Zeile enthält (wobei jede Zahl mit dem Zeichen übereinstimmt, das sie darstellt).

Ein Beispiel wird dies sehr verdeutlichen. Den Quellcode des Berüchtigten hello worldals Eingabe nehmen:

#include <stdio.h>

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

Ihr Programm sollte folgendes ausgeben:

#   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

Implementierungsdetails:

Sie können die Eingabe in einer beliebigen Form vornehmen (Datei öffnen, Befehlszeilen-Pipe, Funktionsparameter usw.) und die Ausgabe auf stdout setzen oder die Ausgabe einer Funktion zurückgeben.

Dinge zu beachten

• Jedes Zeichen in der Ausgabe ist durch ein '\ t' getrennt, damit das dreistellige Leerzeichen in der unteren Zeile in einer Reihe steht (wir gehen davon aus, dass Ihr Tabulator auf 4 oder mehr Leerzeichen eingestellt ist).
• Die Zeilenumbrüche werden in der Zeile angezeigt, in der die Eingabetaste gedrückt wurde (beachten Sie die Zehner im Beispiel).
• Die Druckanforderungen '\ t' und '\ n' sind lax. Ihre Ausgabe muss im Allgemeinen gut aussehen (um zu zeigen, dass die Aliens, die wir haben, auch ästhetisch sind), und wenn Sie die vorherigen beiden Punkte biegen können, während die visuelle Integrität erhalten bleibt, wird Ihnen vergeben.
• Sie können festlegen, ob am Ende der letzten Zeile eine neue Zeile eingefügt werden soll.

Wertung

Dies ist Code-Golf, also gewinnt das kürzeste Programm. Beachten Sie, auch wenn Ihr Programm nicht das kürzeste ist, aber in Bezug auf die Sprache, die Sie verwenden, wirklich nette Tricks verwendet, viele +1 für Sie!

Viel Glück. Das intergalaktische Intelligenzranking der Menschheit ruht auf Ihren Schultern.

Hinweis: Bitte verzeihen Sie die Handlungslöcher. Ich bin kein Schriftsteller : D

Dyalog APL , 14 Bytes

Nimmt eine Liste von Strings auf, die Newline-Sequenzen enthalten (10 oder 13 10 usw.)

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

↑ matrify die Liste der Listen bestehend aus

(... )¨für jeden Zeilenumbruch ...

 ⊢ der Text selbst

 ,[.5] gefolgt in einer neuen Dimension vor der ersten Dimension von

 ⎕UCSder U nicode C haracter S et code points

TryAPL online!

Pyth, 17 13 Bytes

Ein weiterer dieser Pyth-Programmierer. Es tut uns leid.

Der neue Code setzt voraus, dass jede Zeile in Anführungszeichen gesetzt und mit einem Escapezeichen versehen wird (einschließlich Zeilenumbrüchen, wenn Sie möchten, dass sie gedruckt werden). Zwischen der Zeile und dem ASCII-Code wird jedoch ein zusätzlicher Zeilenumbruch eingefügt.

jjLC9smCMBd.Q

Probieren Sie es online!

Erläuterung:

           .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

Ich behalte den alten Code und dessen Erklärung weiter unten.

#Jw
jKC9J
jK+CMJT

Probieren Sie es online! oder verwenden Sie einen besser lesbaren Testfall .

Erläuterung:

#                  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

Dies verwendet einen etwas anderen Ansatz als die Antwort des OP. Beachten Sie, dass SO meine wörtlichen Tabulatoren mit Leerzeichen durcheinander bringt.

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

Probieren Sie es online aus

Vim, 86, 77 Tastenanschläge

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

Dies ist viel zu lang, aber genau das erhalten Sie, wenn Sie die evalFunktion ( \=) von vim verwenden .

Perl, > 33 31 Bytes

Beinhaltet +3 für -F(kann nicht mit kombiniert werden -eund der Code hat 'auch Platz und -wird auch gezählt).

Führen Sie mit der Eingabe auf STDIN aus oder geben Sie einen oder mehrere Dateinamen als Argument an

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

asciidump.pl

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

Die Ausgabe ist nicht ästhetisch, wenn der Text einen Tabulator enthält oder keine letzte neue Zeile vorhanden ist

Pyth, 21 Bytes

j.imjC9d.zmjC9+CMdT.z

Hier ist ein Eintrag von einem dieser "verdammten Pyth-Programmierer" ;)

Ein Programm, das die Eingabe eines nicht in Anführungszeichen gesetzten mehrzeiligen Strings in STDIN akzeptiert und das Ergebnis ausgibt. Dies setzt voraus, dass alle Eingaben eine nachgestellte Newline haben. Wenn Sie möchten, dass es keine nachgestellten Zeilen enthält, fügen Sie diese <am Anfang und )_3am Ende des Programms hinzu .

Probieren Sie es online aus

Die Ausgabe für den Testfall ist im Online-Interpreter schwer zu sehen, daher habe ich sie hier eingefügt:

#   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

Wie es funktioniert

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

Kann so getestet werden

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

Die Eingabe erfolgt über einen Pfad zu einer Datei. Wir dann Get-Content(aliasgc ) auf diese Datei, die automatisch auf Zeilenumbrüche aufgeteilt. Wir durchlaufen jeden von ihnen |%{...}. Beginnen Sie mit dem Setzen von $aund $bzu einer leeren Zeichenfolge - dies sind unsere ASCII-Zeichen bzw. Codepunkte. Wir überprüfen dann -splitdie Eingabezeile für jedes Zeichen, behalten sie (.)bei und entfernen die leeren Werte -ne''(dies liegt daran, wie .NET Regex analysiert) und senden diese dann in eine andere Schleife.

In jeder inneren Schleife verketten wir das aktuelle Zeichen mit einem Tabulator `t und fügen diesen hinzu $a. Ähnlich $bverhält es sich mit der Ausnahme, dass wir explizit als charund dann als int casten +.

Außerhalb der inneren Schleife platzieren wir das resultierende $aund $b(mit einem Zeilenvorschub-Bezeichner, da dies in unserer Schleife niemals auftritt) auf der Pipeline. Diese werden Write-Outputbei Programmabschluss implizit erfasst.

Beispiel

(mit dem Verständnis, dass ich einen nachgestellten Zeilenumbruch habe und Markdown das Tabulatorzeichen entstellt)

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

> <> (Fisch), 48 Bytes

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

Eine Aufgabe, bei der die Sprache glänzt! Ich bin sicher, ich hätte wahrscheinlich ein bisschen mehr Golf spielen können, aber es war eine lange Woche. Könnte es aber später ansehen.

Probieren Sie es online!

Alternativ können Sie es auch online versuchen, was meiner Meinung nach besser aussieht, aber der Textumbruch ist bei Eingaben mit langen Zeilen etwas durcheinander, wie im Testfall.

PHP, 131 115 Bytes

Nur ein FGITW, vielleicht kann ich es besser machen. Es stellt sich heraus, ich kann!

Erste Version mit 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'
';};

Der Dateiname wird als erstes Argument nach dem Skriptnamen angegeben: php aliens.php helloworld.c

Zweite Version mit 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'
';}};

Die erste Version berücksichtigt fehlende Zeilenumbrüche am Ende der Zeile, aber nach der zusätzlichen Klärung können wir diesen Code weglassen und alles in eine Funktion einfügen, um 16 Bytes zu sparen.

Die Leerzeichen in join(' ',$a)und in echo$c.' 'sind Tabulatorzeichen = \t. Die Zeilenumbrüche im Code sind absichtlich.

Python 3, 89 77 Bytes

mehr Golf-Version auf der gleichen Idee basiert:

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

Wenn der Eingang '\ t' enthält, ändern Sie den Wert 4in a 9.

Vorherige Version:

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

Nimmt eine Liste von Zeichenfolgen auf, die jeweils mit einem '\ n' enden.

Powershell, 56 Bytes

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

Skript akzeptiert einen Dateipfad als Eingabe. Get-Content teilt Eingaben automatisch in ein Array von Zeichenfolgen auf, die in Zeilenumbrüchen in der Quelle aufgeteilt sind.

Von dort aus gebe ich ein foreach ein, setze es in ein Array von Zeichen und setze es auf $ a, verbinde das mit Tabulatoren und drucke es aus. Als nächstes habe ich das Zeichen-Array in ein Integer-Array umgewandelt, einen Zeilenvorschub angehängt und mit einem Tabulator wieder verbunden.

Anruf sieht so aus:

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

und hier ist ein Ausgabebeispiel

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

Wobei ␉ das buchstäbliche Tabulatorzeichen darstellt. Funktioniert, solange die Eingabe keine Tabulatorzeichen enthält. 81-Byte-Version, für die für die Eingabe auch ein Zeilenumbruch erforderlich ist:

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 unter Verwendung des tatsächlichen Tabulatorzeichens anstelle von \t. Hinweis: Wird als 4 Leerzeichen oben und 2 Leerzeichen in der unbenutzten Version unten dargestellt.

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

Ergebnisse:

(Hinweis: Visual Studio hat verwendet \r\n für die neuen Zeilen verwendet, als ich die Eingabe eingefügt habe, daher die 13 10Zeilenenden in der Ausgabe.)

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

Probieren Sie es online!

Erläuterung

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

Power, 61 59 Bytes

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

Dinge zu beachten:

• Liest die Eingabe aus einer Datei mit dem Namen m im aktuellen Verzeichnis benannt ist.
• Alle Zeilenumbrüche (einschließlich des in die Zeichenfolge eingebetteten nach dem ersten) $_ ) sind nur Zeilenumbrüche (0xA), also jeweils ein Byte.
• Der Inhalt der Zeichenketten direkt nach dem -join Operatoren ist jeweils ein einzelnes Tabulatorzeichen (unabhängig davon, wie es hier gerendert wird).

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

Ich kann nicht einmal die Mühe machen, dies kürzer zu machen ..

Haskell - 71 Bytes

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

Python 3, 92 97 107 Bytes

für i in der Liste (open (input ()). read (). split ("\ n")): für 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)

Dies ist nicht getestet, sollte aber funktionieren.

Vielen Dank an @gowrath für den Hinweis, dass der Code nicht den in der Frage angegebenen Anforderungen entspricht.