Entre a pergunta do gatinho e ver essa pergunta na U&L sobre alguma sedmágica, que tal implementar tac?

Objetivo

Implemente um programa que reverterá e imprimirá as linhas em um arquivo.

Entrada

Um arquivo, fornecido como um nome ou via entrada padrão

Saída

As linhas, invertidas, são padronizadas.

Pontuação

Bytes do código fonte.

GS2, 3 bytes

* +

Os três bytes são, em ordem, dividir linhas, reverter e unir linhas.

Perl, 11 bytes

$\=$_.$\}{

Comporta-se exatamente como tac. Esse código requer a -popção, que contei como 1 byte.

Execuções de teste

$ 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.

Como funciona

Como explicado aqui , o -pswitch basicamente envolve while (<>) { ... ; print }o programa, portanto o código fonte é equivalente a

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

Para cada linha de entrada, acrescentamos a linha atual ( $_) a $\(inicialmente indefinida), atualizando a última com o resultado.

Após o processamento de todas as linhas, printimprime o valor da variável local $_(indefinida neste escopo), seguida pelo separador do registro de saída ( $\).

Pitão, 4 bytes

j_.z

.zé a entrada separada por linhas como uma lista, a _reverte e june-a por um caractere, que por padrão é \n.

FlogScript , 2 bytes

)"

(Experimente no golfe da anarquia .)

O modo )ativado --in-out-line-arraye o restante do programa são ", invertendo a matriz de linhas.

Retina , 7 bytes

!rm`.*$

Com um único regex, o Retina é executado no modo de correspondência. Normalmente, isso apenas imprime o número de correspondências, mas, com !isso, configuramos para imprimir as correspondências reais (separadas por linhas de alimentação).

O regex real é apenas .*$. .*corresponde a qualquer linha (potencialmente vazia), porque .pode corresponder a qualquer caractere, exceto feeds de linha. Eu vou chegar $em um minuto.

Como podemos imprimir as correspondências ao contrário? Utilizando o modo de correspondência da direita para a esquerda do .NET, ativado com o r. Isso significa que o mecanismo regex inicia no final da string ao procurar correspondências e funciona ao contrário.

Finalmente, mfaz com que a $correspondência seja o final de uma linha, em vez do final da sequência. Por que precisamos disso? O problema é que .*gera correspondências estranhas. Considere a substituição de regex

s/a*/$0x/

aplicado à entrada baaababaa. Você pensaria que isso renderia baaaxbaxbaax, mas realmente lhe dá baaaxxbaxxbaaxx. Por quê? Porque, depois de corresponder, aaao cursor do mecanismo fica entre o ae o b. Agora não pode mais corresponder as, mas a*também está satisfeito com uma sequência vazia. Isso significa que, após cada partida, você recebe outra partida vazia.

Não queremos isso aqui, porque isso introduziria linhas vazias adicionais; portanto, descartamos essas correspondências estranhas (que estão no início das linhas, devido ao modo da direita para a esquerda), exigindo que as correspondências incluam o final de a linha.

Haskell, 34 bytes

main=interact$concat.reverse.lines

[editar]

Salvo um byte, substituindo unlinespor concat.

CJam, 7 bytes

qN/W%N*

Lê stdin, imprime em stdout.

Explicação:

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

Pitão, 5 bytes

jb_.z

Isso inverte a ordem das linhas com uma abordagem simples de junção reversa dividida, mas não muito parecida com tac .

Experimente online.

Befunge-93, 17 bytes

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

Nada extravagante aqui; basta colocar tudo na pilha e soltar.

Pure Bash (sem utilitários externos), 56

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

Esta é uma das poucas respostas para fazer a tacemulação exata , conforme perguntado no comentário 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 bytes

puts [*$<].reverse

JavaScript (SpiderMonkey Shell), 38 bytes

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

Bem simples

read() lê um arquivo

readline() lê uma string de STDIN

[...str]irá dividir str em uma matriz de caracteres

reverse() irá reverter a matriz

join`` irá recolher a matriz em uma string

Python 2, 52 bytes

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

C #, 179 171 bytes

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

Lê linhas, colocando-as em uma pilha e depois as grava para trás. Eu usaria o Mathematica para isso, mas ele não tem senso de EOF.

sed, 9 bytes

1!G;h;$!d

Nenhum voto positivo desejado, este é um famoso sed one-liner.

Perl, 16 bytes

print reverse<>

Powershell, 41 bytes

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

Armazena o conteúdo de um arquivo linha por linha a, inverte ae finalmente o imprime.

GolfScript, 7 bytes

n/-1%n*

Teste online aqui .

Burlesco , 6 bytes

ln<-uN

lndivide linhas, <-inverte, uNune linhas e formatos para saída bruta.

Bash, 48 43 caracteres

(Inspirado por Trauma Digital 's resposta Bash . Upvotes para a idéia deve ir até ele.)

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

Exemplo de execução:

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 caracteres

(Inspirado Ed Morton de resposta GNU Awk . CW como eu não se destinam a sequestrar a sua solução.)

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

Observe que, ao alterar RT→, RSele se torna o Awk padrão portátil, mas perde a capacidade de preservar a ausência da nova linha final.

Exemplo de execução:

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 bytes

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

Gema, 25 caracteres

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

Exemplo de execução:

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

Hássio , 90 bytes 86 bytes

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

Veja expandido aqui

sed, 7 bytes

G;h;$!d

Isso funciona para mim (e é a solução mais curta em outro lugar), mas eu realmente não quero descobrir o porquê. Eu apenas brinquei com o famoso truque de 9 bytes até encontrar isso. Eu acho que Ga primeira linha não faz nada?

JavaScript (Node.js), 91 bytes

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

Bash + utilitários comuns, 25

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

Aqui o ^Gé um BELcaractere literal . Estou assumindo que a entrada é apenas ascii imprimível.

Isso trtransforma toda a entrada em uma linha, substituindo novas linhas por BELs, em seguida, revaltera essa linha e, em seguida, trretorna para revvárias linhas , depois altera cada linha novamente, para obter a saída desejada.

MATLAB, 44

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

Divide a sequência em novas linhas, vira a matriz resultante e volta a juntar-se a novos caracteres de linha.

Julia, 65 bytes

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

Isso pega um arquivo como argumento de linha de comando e imprime suas linhas na ordem inversa. As novas linhas à direita são movidas para a frente, ao contrário do tacque é legítimo.

Ungolfed:

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 bytes

Usa as bandeiras re n; lê de stdin.

RVg

A rbandeira lê stdin e armazena-o como uma lista de linhas em g(que é normalmente uma lista de-ar da linha de comando g s). Em seguida, invertemos essa lista e ela é impressa automaticamente. O nsinalizador faz com que as listas sejam produzidas com nova linha como separador.