Ustawiać scenę:

Jest przeciętne popołudnie, kiedy odpoczywasz po długim dniu, angażując się w ulubioną rozrywkę: odpowiadając na mnóstwo wciągających pytań na temat PPCG. To nie był dobry dzień dla ciebie; ci przeklęci programiści Pyth wciąż otrzymują najlepszą odpowiedź i to zabija twój klimat. Nagle zauważasz nowe pytanie! Podejmujesz decyzję; nie tym razem CJammers. Wściekle zaczynasz pisać, rodząc strumień postaci; płód chwalebnej pętli BrainFuck, którą będzie twój produkt końcowy. Pisz i pisz. Szybciej! Jeszcze szybciej! Jesteś tak skupiony, że nawet nie zauważysz, że światła na ekranie zaczynają migać. Nagle monitor świeci na zielono, symbol podobny do obcego, oznaczony na pulpicie. Wykorzystując swoje nieskazitelne umiejętnościcat ~/Desktop/aliensymboli otrzymaj mnóstwo liczb, wiadomość! Będąc sprytnym programistą PPCG, jakim jesteś, zauważysz, że wygląda jak ASCII. Bez względu na ciebie, ty print(chr(i) for i in file)i rozszyfrujesz wiadomość. Twoja pierwsza myśl: „Muszę się tym podzielić ze społecznością!”.

...

Kto by to pomyślał? Że pierwszymi ludźmi, którzy nawiążą kontakt z kosmitami, będą skromni programiści PPCG. Dlaczego my? Może dlatego, że jesteśmy uosobieniem ludzkiej inteligencji. A może dlatego, że BrainFuck jest tak blisko, jak my, do obcego języka. Niemniej jednak obcy - będąc ultra-inteligentnymi formami życia, którymi są - chcą sprawdzić, czy powinni sklasyfikować rasę ludzką jako inteligentną, czy nie. W celu sprawdzenia naszej sprawności umysłowej, kosmici poprosili nas o przesłanie im kilku programów komputerowych, aby pokazać, że jesteśmy kulturowo technologiczni. Problem polega na tym, że jedynym ludzkim językiem, który rozumieją, jest numeryczna ASCII!

Pomóż ludzkości pokazać tym stworzeniom, kim jest prawdziwa intelektualna alfa. Musimy wysłać im skrypt, który skonwertuje nasze tekstowe kody źródłowe na ich numeryczne wersje ASCII. Niestety, z powodu naszej słabo rozwiniętej technologii (dzięki Obama), musimy wysłać tak mały program tłumaczeniowy, jak to możliwe. Dobrze, że zdecydowali się skontaktować z PPCG!

Wyzwanie:

Założenie tego wyzwania jest proste: masz napisać program, który weźmie kod źródłowy dowolnego programu (lub dowolny ogólny plik tekstowy na ten temat), i wypisze jego oddzieloną spacjami wersję z tłumaczeniem ASCII poniżej każdego wiersza. To znaczy, biorąc pod uwagę wejście pliku tekstowego, musisz wypisać każdy wiersz tego pliku, a następnie wiersz zawierający reprezentację ASCII każdego znaku w wierszu nad nim (z każdą liczbą wyrównaną do znaku, który reprezentuje).

Przykład bardzo to wyjaśni. Biorąc kod źródłowy niesławnego hello worldjako dane wejściowe:

#include <stdio.h>

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

twój program powinien wypisać:

#   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

Szczegóły dotyczące wdrożenia:

Możesz wybrać wejście w dowolnej formie (otwarcie pliku, potok wiersza poleceń, parametr funkcji itp.) I powinieneś wyjść na standardowe wyjście lub zwrócić wyjście z funkcji.

Warto zwrócić uwagę

• Każdy znak na wyjściu jest oddzielony znakiem „\ t”, aby pozwolić na umieszczenie 3 cyfr w wierszu poniżej na wyrównanie (zakładamy, że twoja tabulacja jest ustawiona na 4 spacje lub więcej).
• Nowe linie są wyświetlane w wierszu, w którym naciśnięto klawisz powrotu (zwróć uwagę na 10 w przykładzie)
• Wymagania dotyczące drukowania „\ t” i „\ n” są luźne. Twój dorobek musi, w ogólnym sensie, wyglądać przyjemnie dla oka (musisz pokazać tym kosmitom, którzy również mamy zmysł estetyczny), a jeśli możesz zgiąć dwa poprzednie punkty przy zachowaniu integralności wizualnej, otrzymasz wybaczenie.
• Możesz założyć, czy na końcu ostatniego wiersza znajduje się nowy wiersz.

Punktacja

To jest golf golfowy, więc wygrywa najkrótszy program. Uwaga, nawet jeśli twój program nie jest najkrótszy, ale używa naprawdę schludnych sztuczek w stosunku do używanego języka, wiele +1 dla Ciebie!

Powodzenia. Międzygalaktyczny ranking inteligencji ludzkości spoczywa na twoich barkach.

Uwaga: wybacz dziury w fabule. Nie jestem pisarzem : D

Dyalog APL , 14 bajtów

Pobiera listę ciągów zawierających sekwencje nowego wiersza (10 lub 13 10 itd.)

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

↑ zmaterializuj listę składającą się z

(... )¨dla każdego powrotu linii ...

 ⊢ sam tekst

 ,[.5] następuje w nowym wymiarze przed pierwszym wymiarem przez

 ⎕UCSz U nicode C haracter S et punkty kodowe

Wypróbuj APL online!

Pyth 17 13 bajtów

Kolejny z tych programistów Pyth. Przepraszam.

Nowy kod wymaga, aby każdy wiersz był zawinięty w cudzysłowy i poprzedzony znakiem specjalnym (w tym znaki nowego wiersza, jeśli chcesz, aby były drukowane), ale wstawia nowy znak między wierszem a kodem ASCII.

jjLC9smCMBd.Q

Wypróbuj online!

Wyjaśnienie:

           .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

Trzymam stary kod i jego wyjaśnienie poniżej.

#Jw
jKC9J
jK+CMJT

Wypróbuj online! lub użyj łatwiejszego do odczytania przypadku testowego .

Wyjaśnienie:

#                  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 bajtów

Wykorzystuje to nieco inne podejście niż odpowiedź PO. Zauważ, że SO rozmywa moje dosłowne tabulatory spacjami.

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

Wypróbuj online

Vim, 86, 77 klawiszy

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

Jest to zdecydowanie za długo, ale to właśnie dostajesz, gdy używasz evalfunkcji vima ( \=).

Perl, > 33 31 bajtów

Obejmuje +3 dla -F(nie można łączyć z, -ea kod 'też, więc spacja i- są również liczone).

Uruchom z wejściem na STDIN lub podaj jeden lub więcej nazw plików jako argument

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

asciidump.pl

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

Wynik nie jest estetyczny, jeśli tekst zawiera tabulator lub nie ma końcowej nowej linii

Pyth, 21 bajtów

j.imjC9d.zmjC9+CMdT.z

Oto wpis z jednego z „tych przeklętych programistów Pyth” ;)

Program, który pobiera niecytowany ciąg wielowierszowy na STDIN i drukuje wynik. Zakłada się, że wszystkie dane wejściowe mają końcowy znak nowej linii. Jeśli chcesz, aby nie zajmował się końcowym znakiem nowej linii, dodaj< na początku programu i )_3na końcu.

Wypróbuj online

Dane wyjściowe dla przypadku testowego są trudne do odczytania w tłumaczu online, więc zamieściłem go tutaj:

#   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

Jak to działa

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 bajtów

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

Można przetestować w ten sposób

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

PowerShell v2 +, 85 bajtów

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

Dane wejściowe są poprzez ścieżkę do pliku. Następnie Get-Content(alias gc) tego pliku, który automatycznie dzieli się na nowe linie. Przewijamy każdy z nich |%{...}. Zacznij od ustawienia $ai$b od pustego ciągu - są to odpowiednio nasze znaki ASCII i punkty kodowe. Następnie -splitwprowadzamy wiersz wprowadzania każdego znaku, zachowując go (.)i usuwając puste wartości-ne'' (wynika to ze sposobu analizowania wyrażenia regularnego .NET), a następnie wysyłamy je do innej pętli.

W każdej pętli wewnętrznej łączymy bieżący znak z tabulatorem `ti dodajemy go do $a. Podobnie $b, z wyjątkiem tego, że jawnie przesyłamy jako a, chara następnie jako int +.

Poza wewnętrzną pętlą umieszczamy wynikowy $a i $b(z desygnatora nowego wiersza, ponieważ nigdy nie pojawią się w naszej pętli) na rurociągu. Są one gromadzone w sposób dorozumiany Write-Outputpo zakończeniu programu.

Przykład

(ze zrozumieniem, że mam tylny kanał i Markdown zmienia znak tabulatora)

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

> <> (Ryby), 48 bajtów

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

Zadanie, na które lśni język! Jestem pewien, że mógłbym trochę zagrać w golfa, ale to był długi tydzień. Może jednak przyjrzeć się temu później.

Wypróbuj online!

Alternatywnie wypróbuj online, który moim zdaniem wygląda ładniej, ale zawijanie tekstu trochę popsuwa w przypadku długich linii, takich jak przypadek testowy.

PHP, 131 115 bajtów

Tylko FGITW, może mógłbym to poprawić. Okazuje się, że mogę!

Pierwsza wersja przy 131 bajtach:

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

Nazwa pliku jest dostarczana jako pierwszy argument po nazwie skryptu: php aliens.php helloworld.c

Druga wersja o wielkości 115 bajtów:

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

Pierwsza wersja uwzględnia brakujące znaki nowego wiersza na końcu wiersza, ale po dodatkowym wyjaśnieniu możemy pominąć ten kod i umieścić wszystko w funkcji, aby zaoszczędzić 16 bajtów.

Znaki białych znaków w join(' ',$a)oraz w echo$c.' 'są znakami tabulacji = \t. Nowe wiersze w kodzie są celowe.

Python 3, 89 77 bajtów

bardziej golfowa wersja oparta na tym samym pomyśle:

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

Jeśli na wejściu znajdują się „\ t”, zmień na 4a 9.

Poprzednia wersja:

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

Pobiera listę ciągów znaków, z których każda kończy się na „\ n”.

PowerShell, 56 bajtów

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

Skrypt akceptuje ścieżkę pliku jako dane wejściowe. Get-Content automatycznie dzieli dane wejściowe na tablicę ciągów znaków podzielonych na nowe wiersze w źródle.

Stamtąd wchodzę do foreach, rzucam na tablicę znaków i ustawiam na $ a, łączę z kartami i drukuję. Następnie, ale wciąż w obrębie foreach, rzuciłem tablicę znaków na tablicę liczb całkowitych, dołączam znak wiersza i ponownie łączę za pomocą tabulatora.

Połączenie wygląda następująco:

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

a oto próbka wyjściowa

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

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

Gdzie ␉ oznacza dosłowny znak tabulacji. Działa, dopóki dane wejściowe nie zawierają znaków tabulacji. Wersja 81-bajtowa, która również wymaga, aby dane wejściowe miały znak nowej linii:

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

C #, 64 63 bajtów

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

-1 bajt przy użyciu rzeczywistego znaku tabulacji zamiast \t. Uwaga: renderuje jako 4 spacje powyżej i 2 spacje w wersji bez golfa poniżej.

Nie golfowany:

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

Wyniki:

(Uwaga: Visual Studio używał \r\nnowych linii, kiedy wkleiłem dane wejściowe, stąd 13 10zakończenia linii w danych wyjściowych)

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 bajtów

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

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

Ważne uwagi:

• Odczytuje dane wejściowe z pliku o nazwie mw bieżącym katalogu.
• Wszystkie podziały wiersza (w tym ten osadzony w ciągu po pierwszym $_) są dosłowne dosuwu wiersza (0xA), więc każdy bajt.
• Treść ciągów znaków bezpośrednio po -joinoperatorach jest pojedynczym znakiem tabulacji (niezależnie od tego, jak jest tutaj renderowana).

Nie golfił

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 bajty

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

Nie mogę nawet niepokoić się tym, że jest to krótsze ...

Haskell - 71 bajtów

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

Python 3, 92 97 107 bajtów

dla i na liście (open (input ()). read (). split ("\ n")): dla 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)

Jest to niesprawdzone, ale powinno działać.

Dzięki @gowrath za wskazanie, że kod nie działa zgodnie z pytaniem.