Pomiędzy pytaniem o kotka a tym pytaniem w U&L o sedmagii, co powiesz na wdrożenie tac?

Cel

Zaimplementuj program, który odwróci i wydrukuje linie w pliku.

Wkład

Plik podany jako nazwa lub przez standardowe wejście

Wydajność

Linie odwrócone do standardowych.

Punktacja

Bajty kodu źródłowego.

GS2, 3 bajty

* +

Te trzy bajty to kolejno linie podzielone, odwrócone i połączone.

Perl, 11 bajtów

$\=$_.$\}{

Zachowuje się dokładnie jak tac. Ten kod wymaga -pprzełącznika, który policzyłem jako 1 bajt.

Przebiegi testowe

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

Jak to działa

Jak wyjaśniono tutaj , -pprzełącznik zasadniczo otacza while (<>) { ... ; print }program, więc kod źródłowy jest równoważny

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

Dla każdego wiersza danych wejściowych wstawiamy bieżącą linię ( $_) do $\(początkowo niezdefiniowana), aktualizując ją o wynik.

Po przetworzeniu wszystkich wierszy printwypisuje wartość zmiennej lokalnej $_(niezdefiniowanej w tym zakresie), a następnie separator rekordów wyjściowych ( $\).

Pyth, 4 bajty

j_.z

.zto wejście oddzielone liniami jako lista, _odwraca je i jłączy znakiem, którym domyślnie jest \n.

FlogScript , 2 bajty

)"

(Wypróbuj na anarchii golfa .)

)Umożliwia --in-out-line-arraytryb, a reszta programu jest "odwrócenie szereg linii.

Siatkówka , 7 bajtów

!rm`.*$

Z jednym wyrażeniem regularnym Retina działa w trybie dopasowania. Zwykle drukuje to tylko liczbę dopasowań, ale !konfigurujemy go tak, aby zamiast tego wyświetlał rzeczywiste dopasowania (oddzielone liniami).

Rzeczywiste wyrażenie regularne jest tylko .*$. .*dopasowuje dowolną linię (potencjalnie pustą), ponieważ .może pasować do dowolnego znaku oprócz linii. Dotrę $za chwilę.

Jak sprawić, by wydrukował mecze w odwrotnej kolejności? Korzystając z trybu dopasowywania od prawej do lewej platformy .NET, aktywowanego za pomocą r. Oznacza to, że silnik wyrażeń regularnych uruchamia się na końcu łańcucha podczas wyszukiwania dopasowań i działa wstecz.

Wreszcie, msprawia, że $dopasowanie jest końcem linii zamiast końca łańcucha. Dlaczego tego potrzebujemy? Problem polega na tym, że .*generuje obce dopasowania. Rozważ podstawienie wyrażenia regularnego

s/a*/$0x/

zastosowane do danych wejściowych baaababaa. Można by pomyśleć, że to przyniesie baaaxbaxbaax, ale tak naprawdę daje baaaxxbaxxbaaxx. Czemu? Ponieważ po dopasowaniu aaakursor silnika znajduje się między aa b. Teraz nie może dopasować więcej as, ale a*jest również zadowolony z pustego ciągu. Oznacza to, że po każdym pojedynczym meczu otrzymujesz kolejny pusty mecz.

Nie chcemy tego tutaj, ponieważ wprowadziłoby to dodatkowe puste linie, dlatego odrzucamy te obce dopasowania (które są na początku linii ze względu na tryb od prawej do lewej), wymagając, aby dopasowania zawierały koniec linia.

Haskell, 34 bajty

main=interact$concat.reverse.lines

[edytować]

Zapisano jeden bajt, zastępując unlinesgo concat.

CJam, 7 bajtów

qN/W%N*

Czyta standardowe wejście, drukuje na standardowe wyjście.

Wyjaśnienie:

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

Pyth, 5 bajtów

jb_.z

To odwraca kolejność linii za pomocą prostego podejścia split-reverse-join, ale nie całkiem jak tac .

Wypróbuj online.

Befunge-93, 17 bajtów

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

Nic szczególnego; po prostu połóż wszystko na stosie, a następnie zdejmij.

Pure Bash (bez zewnętrznych narzędzi), 56

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

Jest to jedna z nielicznych odpowiedzi na dokładną tacemulację, o którą pytano w komentarzu Dennisa :

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

Rubinowy, 16 bajtów

puts [*$<].reverse

JavaScript (SpiderMonkey Shell), 38 bajtów

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

Dość proste

read() czyta plik

readline() odczytuje ciąg ze STDIN

[...str]podzieli str na tablicę znaków

reverse() odwróci tablicę

join`` zwinie tablicę w ciąg

Python 2, 52 bajty

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

C #, 179 171 bajtów

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

Odczytuje wiersze, umieszczając je na stosie, a następnie zapisuje je do tyłu. Użyłbym do tego Mathematiki, ale nie ma poczucia EOF.

sed, 9 bajtów

1!G;h;$!d

To nie jest pożądane, to słynny sed liniowy.

Perl, 16 bajtów

print reverse<>

PowerShell, 41 bajtów

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

Przechowuje zawartość pliku linia po linii a, odwraca ai ostatecznie drukuje.

GolfScript, 7 bajtów

n/-1%n*

Test online tutaj .

Burleska , 6 bajtów

ln<-uN

lndzieli linie, <-odwraca, uNłączy linie i formaty dla surowego wyjścia.

Bash, 48 43 znaków

(Zainspirowany Cyfrowy Trauma „s bash odpowiedź . Upvotes dla idei powinien udać się do niego.)

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

Przykładowy przebieg:

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

(Zainspirowany Ed Morton „s GNU awk odpowiedzi . CW, bo nie ma na celu przejąć jego rozwiązanie).

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

Zauważ, że zmieniając RT→ RSstaje się to przenośny standardowy Awk, ale traci on zdolność do zachowania braku końcowej nowej linii.

Przykładowy przebieg:

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 bajty

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

Gema, 25 znaków

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

Przykładowy przebieg:

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

Wapń , 90 bajtów 86 bajtów

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

Zobacz rozwinięty tutaj

sed, 7 bajtów

G;h;$!d

To działa dla mnie (i jest to najkrótsze rozwiązanie gdzie indziej), ale tak naprawdę nie chcę wiedzieć, dlaczego. Dopiero co pomieszałem ze słynną 9-bajtową sztuczką, dopóki jej nie znalazłem. Zgaduję, Gże pierwsza linia nic nie robi?

JavaScript (Node.js), 91 bajtów

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

Bash + wspólne narzędzia, 25

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

Oto ^Gdosłowna BELpostać. Zakładam, że dane wejściowe można wydrukować tylko w ascii.

Ten transforms całą wejście do jednej linii, zastępując znaki nowej linii z taśm, następnie reverses tę linię, następnie transforms powrotem do multilinii, następnie reverses każdą linię ponownie, aby uzyskać pożądany wynik.

MATLAB, 44

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

Dzieli ciąg w nowych wierszach, odwraca wynikową tablicę, a następnie ponownie dołącza nowe znaki linii.

Julia, 65 bajtów

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

Pobiera to plik jako argument wiersza poleceń i wypisuje jego wiersze w odwrotnej kolejności. Końcowe znaki nowej linii są przenoszone na przód, w przeciwieństwie do tac, co jest zgodne z prawem.

Nie golfowany:

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

Wykorzystuje flagi ri n; czyta ze standardowego.

RVg

The rFlag odczytuje stdin i zapisuje go jako lista wierszy g(który normalnie jest lista linii poleceń ar g ów). Następnie odwracamy tę listę i jest ona automatycznie drukowana. Do nlisty przyczyny flag być wyjście z nowej linii jako separatora.