Entre la question du chaton et voir cette question à U&L sur la sedmagie, que diriez-vous de l'implémentation tac?

Objectif

Implémentez un programme qui inversera et imprimera les lignes dans un fichier.

Contribution

Un fichier, fourni sous forme de nom ou via une entrée standard

Sortie

Les lignes, inversées, à la sortie standard.

Notation

Octets de code source.

GS2, 3 octets

* +

Les trois octets sont, dans l'ordre, les lignes divisées, inversées et jointes.

Perl, 11 octets

$\=$_.$\}{

Se comporte exactement comme tac. Ce code nécessite le -pcommutateur, que j'ai compté comme 1 octet.

Essais

$ echo -en 'a\nb' | perl -pe'$\=$_.$\}{' | xxd -g 1
0000000: 62 61 0a                                         ba.
$ echo -en 'a\nb\n' | perl -pe'$\=$_.$\}{' | xxd -g 1
0000000: 62 0a 61 0a                                      b.a.

Comment ça marche

Comme expliqué ici , le -pcommutateur while (<>) { ... ; print }entoure essentiellement le programme, donc le code source est équivalent à

 while(<>)
 {
   $\ = $_ . $\
 }
 print

Pour chaque ligne d'entrée, nous ajoutons la ligne actuelle ( $_) à $\(initialement non définie), en mettant à jour cette dernière avec le résultat.

Une fois toutes les lignes traitées, printimprime la valeur de la variable locale $_(non définie dans cette étendue), suivie du séparateur d'enregistrement de sortie ( $\).

Pyth, 4 octets

j_.z

.zest l'entrée séparée par des lignes sous forme de liste, l' _inverse et la jjoint par un caractère, qui par défaut est \n.

FlogScript , 2 octets

)"

(Essayez-le sur le golf d'anarchie .)

Le mode )enable --in-out-line-array, et le reste du programme est ", inversant le tableau de lignes.

Rétine , 7 octets

!rm`.*$

Avec une seule expression régulière, Retina s'exécute en mode Match. Cela n'imprime normalement que le nombre de correspondances, mais avec !nous le configurons pour imprimer les correspondances réelles à la place (séparées par des sauts de ligne).

Le regex réel est simplement .*$. .*correspond à n'importe quelle ligne (potentiellement vide), car .peut correspondre à n'importe quel caractère à l'exception des sauts de ligne. J'y arriverai $dans une minute.

Comment faire imprimer les allumettes à l'envers? En utilisant le mode de correspondance de droite à gauche de .NET, activé avec le r. Cela signifie que le moteur d'expression régulière démarre à la fin de la chaîne lors de la recherche de correspondances et fonctionne à l'envers.

Enfin, le mfait $correspondre la fin d'une ligne au lieu de la fin de la chaîne. Pourquoi en avons-nous même besoin? Le problème est que cela .*génère des correspondances étrangères. Considérez la substitution d'expression régulière

s/a*/$0x/

appliqué à l'entrée baaababaa. Vous penseriez que cela donnerait baaaxbaxbaax, mais cela vous donne en fait baaaxxbaxxbaaxx. Pourquoi? Parce qu'après avoir fait correspondre aaale curseur du moteur se trouve entre le aet le b. Maintenant, il ne peut plus correspondre à as, mais il a*est également satisfait d'une chaîne vide. Cela signifie qu'après chaque match, vous obtenez un autre match vide.

Nous ne voulons pas cela ici, car cela introduirait des lignes vides supplémentaires, donc nous supprimons ces correspondances étrangères (qui sont au début des lignes, en raison du mode de droite à gauche) en exigeant que les correspondances incluent la fin la ligne.

Haskell, 34 octets

main=interact$concat.reverse.lines

[modifier]

Un octet enregistré en remplaçant unlinespar concat.

CJam, 7 octets

qN/W%N*

Lit stdin, imprime sur stdout.

Explication:

q       Get input.
N/      Split at newlines.
W%      Reverse list.
N*      Join with newlines.

Pyth, 5 octets

jb_.z

Cela inverse l'ordre des lignes avec une approche simple de split-reverse-join, mais pas tout à fait comme tac .

Essayez-le en ligne.

Befunge-93, 17 octets

~:1+!#v_
>:#,_@>$

Rien d'extraordinaire ici; il suffit de tout mettre sur la pile, puis de le retirer.

Pure Bash (pas d'utilitaires externes), 56

mapfile a
for((i=${#a[@]};i--;));{
printf %s "${a[i]}"
}

C'est l'une des rares réponses à faire une tacémulation exacte , comme demandé dans le commentaire de Dennis :

$ echo -en 'a\nb' | ./tacemu.sh | xxd -g 1
0000000: 62 61 0a                                         ba.
$ echo -en 'a\nb\n' | ./tacemu.sh | xxd -g 1
0000000: 62 0a 61 0a                                      b.a.
$ 

Ruby, 16 octets

puts [*$<].reverse

JavaScript (SpiderMonkey Shell), 38 octets

[...read(readline())].reverse().join``

Assez simple

read() lit un fichier

readline() lit une chaîne de STDIN

[...str]divisera str en un tableau de caractères

reverse() inversera le tableau

join`` collpase le tableau dans une chaîne

Python 2, 52 octets

import sys;print''.join(sys.stdin.readlines()[::-1])

C #, 179 171 octets

using B=System.Console;class A{static void Main(){var a=new System.Collections.Stack();string b;while((b=B.ReadLine())!=null)a.Push(b);foreach(var c in a)B.WriteLine(c);}}

Lit les lignes, les place dans une pile, puis les écrit à l'envers. J'utiliserais Mathematica pour cela, mais cela n'a aucun sens d'EOF.

sed, 9 octets

1!G;h;$!d

Pas de vote positif, c'est un fameux monoplace sed.

Perl, 16 octets

print reverse<>

Powershell, 41 octets

$a=$args|%{gc $_};[array]::Reverse($a);$a

Stocke le contenu d'un fichier ligne par ligne a, l'inverse aet l'imprime finalement.

GolfScript, 7 octets

n/-1%n*

Test en ligne ici .

Burlesque , 6 octets

ln<-uN

lndivise les lignes, <-inverse, uNjoint les lignes et les formats pour la sortie brute.

Bash, 48 43 caractères

(Inspirés par le numérique Trauma de réponse Bash . Upvotes l'idée devrait aller à lui.)

mapfile -c1 -C's=$2$s;set'
printf %s "$2$s"

Exemple d'exécution:

bash-4.3$ echo -en 'a\nb' | bash tac.sh | xxd -g 1
0000000: 62 61 0a                                         ba.

bash-4.3$ echo -en 'a\nb\n' | bash tac.sh | xxd -g 1
0000000: 62 0a 61 0a                                      b.a.

GNU Awk, 27 caractères

(Inspiré par Ed Morton de réponse GNU Awk . CW que je ne comptais pirater sa solution.)

{s=$0RT s}END{printf"%s",s}

Notez qu'en changeant RT→ RScela devient Awk standard portable mais perd la possibilité de préserver l'absence de la nouvelle ligne finale.

Exemple d'exécution:

bash-4.3$ echo -en 'a\nb' | awk '{s=$0RT s}END{printf"%s",s}' | xxd -g 1
0000000: 62 61 0a                                         ba.

bash-4.3$ echo -en 'a\nb\n' | awk '{s=$0RT s}END{printf"%s",s}' | xxd -g 1
0000000: 62 0a 61 0a                                      b.a.

SNOBOL, 42 octets

S S =INPUT CHAR(10) S :S(S)
 OUTPUT =S
END

Gema, 25 caractères

*\n=@set{s;$0${s;}}
\Z=$s

Exemple d'exécution:

bash-4.3$ echo -en 'a\nb' | gema '*\n=@set{s;$0${s;}};\Z=$s'
ba

bash-4.3$ echo -en 'a\nb\n' | gema '*\n=@set{s;$0${s;}};\Z=$s'
b
a

Hassium , 90 octets 86 octets

use IO;func main(){c=File.readLines(args[0]);for(x=c.length-1;x>=0; println(c[x--]))0;

Voir développé ici

sed, 7 octets

G;h;$!d

Cela fonctionne pour moi (et c'est la solution la plus courte ailleurs), mais je ne veux pas vraiment savoir pourquoi. Je viens de jouer avec le fameux truc de 9 octets jusqu'à ce que je trouve cela. Je suppose Gque la première ligne ne fait rien?

JavaScript (Node.js), 91 octets

console.log(require('fs').readFileSync(process.argv[2])+"".split(d="\n").reverse().join(d))

Bash + utilitaires communs, 25

tr \\n ^G|rev|tr ^G \\n|rev

Ici, ^Gc'est un BELcaractère littéral . Je suppose que l'entrée est uniquement ascii imprimable.

Cela permet de trformer l'intégralité de l'entrée sur une ligne en remplaçant les sauts de ligne par des BEL, puis de revsupprimer cette ligne, puis de trretourner en multiligne, puis de revreplacer chaque ligne à nouveau, pour obtenir la sortie souhaitée.

MATLAB, 44

@(x) strjoin(fliplr(strsplit(x,'\n')),'\n');

Fractionne la chaîne à de nouvelles lignes, retourne le tableau résultant, puis rejoint avec de nouveaux caractères de ligne.

Julia, 65 octets

open(s->print(join(reverse([l for l=readlines(s)]),"")),ARGS[1])

Cela prend un fichier comme argument de ligne de commande et imprime ses lignes dans l'ordre inverse. Les nouvelles lignes de fin sont déplacées vers l'avant, contrairement à tacce qui est légitime.

Non golfé:

function p(s::Stream)
    # Create a vector of the lines of the input stream
    L = [l for l in readlines(s)]

    # Reverse the vector and join it back into a string
    j = join(reverse(L), "")

    # Print the string to STDOUT
    print(j)
end

# Open the file specified in the first command line argument
# and apply the function p to its contents
open(p, ARGS[1])

Pip , 3 + 2 = 5 octets

Utilise les drapeaux ret n; lit de stdin.

RVg

Le rdrapeau indique l' entrée standard et le stocke en tant que liste de lignes g(qui est normalement une liste de ligne de commande ar g s). Nous inversons ensuite cette liste et elle est imprimée automatiquement. L' nindicateur provoque la sortie des listes avec la nouvelle ligne comme séparateur.