Mise en scène:

C'est un après-midi moyen, alors que vous vous détendez après une longue journée en vous adonnant à votre passe-temps favori: répondre à la pléthore de questions captivantes sur PPCG. Ce n’a pas été une bonne journée pour vous; ces maudits programmeurs Pyth continuent d'obtenir la meilleure réponse et cela tue votre ambiance. Soudain, vous remarquez qu'une nouvelle question a été publiée! Vous décidez; pas cette fois CJammers. Furieusement, vous commencez à taper, donnant naissance à un flot de personnages; un fœtus de la magnifique boucle BrainFuck que sera votre produit final. Vous tapez et tapez. Plus rapide! Toujours plus vite! Vous êtes tellement concentré que vous ne remarquez même pas que les lumières sur votre écran commencent à clignoter. Soudain, le moniteur devient vert, un symbole semblable à un extraterrestre marqué sur le bureau. En utilisant vos compétences impeccables, vouscat ~/Desktop/aliensymbolet recevez un tas de chiffres, un message! Étant le programmeur PPCG astucieux que vous êtes, vous remarquez qu'il ressemble à ASCII. Peu importe pour vous, vous print(chr(i) for i in file)et déchiffrez le message. Votre première pensée: "J'ai besoin de partager cela avec la communauté!".

...

Qui l'aurait pensé? Que les premières personnes à entrer en contact avec des extraterrestres seraient les humbles programmeurs de PPCG. Pourquoi nous? C'est peut-être parce que nous sommes l'incarnation de l'intelligence humaine. Ou peut-être parce que BrainFuck est aussi proche que possible d'une langue étrangère. Néanmoins, les extraterrestres - étant les formes de vie ultra-intelligentes qu'ils sont - veulent tester s'ils doivent classer la race humaine comme intelligente ou non. Pour tester nos prouesses mentales, les extraterrestres nous ont demandé de leur envoyer quelques programmes informatiques pour démontrer que nous sommes cultivés sur le plan technologique. Le problème est que le seul langage humain qu'ils comprennent est l'ASCII numérique!

Aidez l'humanité à montrer à ces créatures qui est le véritable alpha intellectuel. Nous devons leur envoyer un script qui convertira nos codes sources basés sur du texte en leurs versions ASCII numériques. Malheureusement, en raison de notre technologie sous-développée (merci Obama), nous devons envoyer un programme de traduction aussi petit que possible. Heureusement qu'ils ont choisi de contacter PPCG!

Le défi:

La prémisse de ce défi est simple: vous devez écrire un programme qui prendra le code source de tout programme (ou tout fichier texte général d'ailleurs), et en sortir une version séparée par des espaces avec une traduction ASCII sous chaque ligne. C'est-à-dire, étant donné l'entrée d'un fichier texte, vous devez sortir chaque ligne de ce fichier suivie d'une ligne contenant la représentation ASCII de chaque caractère dans la ligne au-dessus (chaque numéro étant aligné avec le caractère qu'il représente).

Un exemple clarifiera grandement cela. Prendre le code source de l'infâme hello worldcomme entrée:

#include <stdio.h>

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

votre programme devrait produire:

#   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

Détails d'implémentation:

Vous pouvez choisir de prendre l'entrée sous la forme que vous souhaitez (fichier d'ouverture, ligne de commande, paramètre de fonction, etc.) et vous devez sortir sur stdout ou renvoyer la sortie d'une fonction.

À noter

• Chaque caractère dans la sortie est séparé par un '\ t' pour permettre l'espace de 3 chiffres dans la ligne ci-dessous pour s'aligner (nous allons supposer que votre tabulation est définie sur 4 espaces ou plus).
• Les nouvelles lignes s'affichent sur la ligne sur laquelle la touche retour a été enfoncée (remarquez les 10 dans l'exemple)
• Les exigences d'impression «\ t» et «\ n» sont laxistes. Votre sortie doit, dans le sens général, avoir l'air agréable à l'œil (nous devons également montrer aux extraterrestres que nous avons un sens esthétique), et si vous pouvez plier les deux points précédents tout en maintenant l'intégrité visuelle, vous serez pardonné.
• Vous pouvez choisir de supposer s'il existe ou non une nouvelle ligne à la fin de la dernière ligne.

Notation

C'est le golf de code, donc le programme le plus court gagne. Notez que même si votre programme n'est pas le plus court, mais utilise des astuces vraiment soignées par rapport à la langue que vous utilisez, beaucoup de +1 pour vous!

Bonne chance. Le classement de l'intelligence intergalactique de l'humanité repose sur vos épaules.

Remarque: veuillez pardonner les trous de l'intrigue. Je ne suis pas écrivain : D

Dyalog APL , 14 octets

Prend la liste des chaînes qui incluent des séquences de nouvelle ligne (10 ou 13 10 etc.)

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

↑ matrifier la liste des listes

(... )¨pour chaque retour de ligne ...

 ⊢ le texte lui-même

 ,[.5] suivi d'une nouvelle dimension avant la première dimension par

 ⎕UCSles U nicode C haracter S ET points de code

TryAPL en ligne!

Pyth, 17 13 octets

Un autre de ces programmeurs Pyth. Désolé.

Le nouveau code nécessite que chaque ligne soit entourée de guillemets et d'échappement (y compris les sauts de ligne si vous souhaitez qu'ils soient imprimés), mais met une nouvelle ligne supplémentaire entre la ligne et l'ASCII.

jjLC9smCMBd.Q

Essayez-le en ligne!

Explication:

           .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

Je garde l'ancien code et ses explications ci-dessous.

#Jw
jKC9J
jK+CMJT

Essayez-le en ligne! ou utilisez un scénario de test plus facile à lire .

Explication:

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

Cela utilise une approche légèrement différente de la réponse du PO. Notez que SO gâche mes onglets littéraux avec des espaces.

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

Essayez-le en ligne

Vim, 86, 77 frappes

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

C'est beaucoup trop long, mais c'est ce que vous obtenez lorsque vous utilisez la evalfonction de vim ( \=).

Perl, > 33 31 octets

Comprend +3 pour -F(ne peut pas être combiné avec -eet le code 'aussi, donc l'espace et -sont également comptés).

Exécuter avec l'entrée sur STDIN ou donner un ou plusieurs noms de fichiers comme argument

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

asciidump.pl

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

La sortie n'est pas esthétique si le texte contient un onglet ou s'il n'y a pas de nouvelle ligne finale

Pyth, 21 octets

j.imjC9d.zmjC9+CMdT.z

Voici une entrée d'un de "ces maudits programmeurs Pyth" ;)

Un programme qui prend l'entrée d'une chaîne multiligne non cotée sur STDIN et imprime le résultat. Cela suppose que toutes les entrées ont une nouvelle ligne de fin. Si vous voulez qu'il ne traite pas de saut de ligne, ajoutez <au début du programme et )_3à la fin.

Essayez-le en ligne

La sortie pour le cas de test est difficile à voir dans l'interpréteur en ligne, donc je l'ai inclus ici:

#   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

Comment ça marche

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 Octets

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

Peut être testé comme ça

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

PowerShell v2 +, 85 octets

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

L'entrée se fait via un chemin vers un fichier. Nous avons ensuite Get-Content(alias gc) sur ce fichier, qui se divise automatiquement sur les nouvelles lignes. Nous passons en revue chacun d'eux |%{...}. Commencez par définir $aet $bune chaîne vide - ce sont nos caractères ASCII et points de code respectivement. Nous avons ensuite -splitla ligne d'entrée sur chaque caractère, en la conservant (.)et en supprimant les valeurs vides -ne''(c'est dû à la façon dont .ge regex analyse), puis les envoyons dans une autre boucle.

À chaque boucle interne, nous enchaînons le caractère courant avec un onglet `tet nous ajoutons cela $a. De même pour $b, sauf que nous transcrivons explicitement en tant que charpuis en entier +.

En dehors de la boucle interne, nous plaçons le résultat $aet $b(avec un identificateur de saut de ligne, car cela n'apparaîtra jamais dans notre boucle) sur le pipeline. Ceux-ci sont rassemblés avec un implicite Write-Outputà la fin du programme.

Exemple

(étant entendu que j'ai un saut de ligne de fin et que Markdown modifie le caractère de tabulation)

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

> <> (Poisson), 48 octets

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

Une tâche sur laquelle la langue brille! Je suis sûr que j'aurais probablement pu jouer un peu plus, mais la semaine a été longue. Je pourrais y jeter un œil plus tard.

Essayez-le en ligne!

Alternativement, essayez-le en ligne qui semble plus agréable à mon avis, mais l'habillage du texte gâche un peu la saisie avec de longues lignes comme le cas de test.

PHP, 131 115 octets

Juste un FGITW, je peux peut-être l'améliorer davantage. Il s'avère que je peux!

Première version à 131 octets:

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

Le nom de fichier est fourni comme premier argument après le nom du script: php aliens.php helloworld.c

Deuxième version à 115 octets:

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

La première version explique les sauts de ligne manquants à la fin de la ligne, mais après la clarification supplémentaire, nous pouvons laisser ce code et mettre tout dans une fonction pour économiser 16 octets.

Les caractères d'espacement dans join(' ',$a)ainsi que dans echo$c.' 'sont des caractères de tabulation = \t. Les retours à la ligne du code sont intentionnels.

Python 3, 89 77 octets

version plus golfée basée sur la même idée:

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

S'il y a des '\ t' dans l'entrée, changez le 4en a 9.

Version antérieure:

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

Prend une liste de chaînes, chacune se terminant par un «\ n».

Powershell, 56 octets

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

Le script accepte un chemin de fichier en entrée. Get-Content divise automatiquement l'entrée en un tableau de chaînes réparties sur les sauts de ligne dans la source.

À partir de là, j'entre un foreach, je transforme en un tableau de caractères et je le place sur $ a, je le joint avec des tabulations et je l'imprime. Ensuite, mais toujours dans le foreach, je transforme le tableau de caractères en un tableau entier, ajoute un saut de ligne et rejoins à nouveau avec un onglet.

L'appel ressemble à ceci:

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

et voici un échantillon de sortie

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

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

Où ␉ représente le caractère de tabulation littéral. Fonctionne tant que l'entrée ne contient pas de caractères de tabulation. Version de 81 octets qui nécessite également que l'entrée ait une nouvelle ligne de fin:

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

C #, 64 63 octets

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

-1 octet en utilisant le caractère de tabulation réel au lieu de \t. Remarque: s'affiche comme 4 espaces au-dessus et 2 espaces dans la version non golfée ci-dessous.

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

Résultats:

(Remarque: Visual Studio a utilisé \r\nles nouvelles lignes lorsque j'ai collé l'entrée, d'où les 13 10fins de ligne en sortie)

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 octets

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

Essayez-le en ligne!

Explication

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 octets

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

A noter:

• Lit l'entrée d'un fichier nommé mdans le répertoire courant.
• Tous les sauts de ligne (y compris celui incorporé dans la chaîne après le premier $_) sont des sauts de ligne littéraux uniquement (0xA), donc un octet chacun.
• Le contenu des chaînes directement après les -joinopérateurs est chacun un caractère de tabulation unique (quelle que soit la façon dont il est rendu ici).

Non 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 octets

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

Je ne peux même pas être gêné de raccourcir cela ..

Haskell - 71 octets

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

Python 3, 92 97 107 octets

pour i dans la liste (open (input ()). read (). split ("\ n")): pour j dans 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)

Ceci n'est pas testé, mais devrait fonctionner.

Merci @gowrath d'avoir souligné que le code ne fonctionne pas comme le spécifie la question.