Между вопросом о котенке и появлением этого вопроса в U & L о какой-то sedмагии, как насчет реализации tac?

Задача

Реализуйте программу, которая перевернет и напечатает строки в файле.

вход

Файл, предоставленный как имя или через стандартный ввод

Выход

Линии, перевернутые, чтобы выровнять.

счет

Байты исходного кода.

GS2, 3 байта

* +

Три байта - это по порядку разделенные линии, обратные и соединительные строки.

Perl, 11 байт

$\=$_.$\}{

Ведет себя точно так же, как tac. Для этого кода требуется -pпереключатель, который я посчитал 1 байтом.

Тестовые прогоны

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

Как это работает

Как объясняется здесь , -pпереключатель в основном while (<>) { ... ; print }охватывает программу, поэтому исходный код эквивалентен

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

Для каждой строки ввода мы добавляем текущую строку ( $_) к $\(изначально неопределенному), обновляя последнюю с результатом.

После обработки всех строк printпечатается значение локальной переменной $_(не определено в этой области), за которым следует разделитель выходных записей ( $\).

Pyth, 4 байта

j_.z

.zявляется вводом, разделенным строками в виде списка, _переворачивает его и jсоединяет его символом, который по умолчанию является \n.

FlogScript , 2 байта

)"

(Попробуйте на анархии гольф .)

Режим )enable --in-out-line-array, а остальная часть программы - "реверсирование массива строк.

Сетчатка , 7 байт

!rm`.*$

Retina работает в режиме Match с одним регулярным выражением. Обычно это просто печатает количество совпадений, но при этом !мы настраиваем его для печати реальных совпадений (разделенных переводом строки).

Фактическое регулярное выражение просто .*$. .*соответствует любой строке (потенциально пустой), потому что .может соответствовать любому символу, кроме перевода строки. Я вернусь $через минуту.

Как мы заставим его печатать спички в обратном порядке? Используя .NET режим сопоставления справа налево, активируется с помощью r. Это означает, что механизм регулярных выражений запускается в конце строки при поиске совпадений и работает в обратном направлении.

И, наконец, mделает $матч конец строки , а не в конце строки. Зачем нам это вообще нужно? Беда в том, что .*генерирует посторонние совпадения. Рассмотрим подстановку регулярных выражений

s/a*/$0x/

применяется к входу baaababaa. Вы могли бы подумать, что это даст baaaxbaxbaax, но на самом деле это дает вам baaaxxbaxxbaaxx. Зачем? Потому что после сопоставления aaaкурсор двигателя находится между aи b. Теперь он не может больше соответствовать as, но a*также удовлетворен пустой строкой. Это означает, что после каждого совпадения вы получаете еще одно пустое совпадение.

Мы не хотим этого здесь, потому что это введет дополнительные пустые строки, поэтому мы отбрасываем эти посторонние совпадения (которые находятся в начале строк, из-за режима справа налево), требуя, чтобы совпадения включали конец линия.

Haskell, 34 байта

main=interact$concat.reverse.lines

[редактировать]

Сохраняется один байт путем замены unlinesна concat.

CJam, 7 байтов

qN/W%N*

Читает стандартный вывод, выводит на стандартный вывод.

Объяснение:

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

Pyth, 5 байт

jb_.z

Это меняет порядок строк с помощью простого подхода разделения-обратного соединения, но не совсем так, как TAC .

Попробуйте онлайн.

Befunge-93, 17 байт

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

Здесь нет ничего особенного; просто положите все в стек, а затем вытолкните.

Pure Bash (без внешних утилит), 56

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

Это один из немногих ответов для точной tacэмуляции, о чем спрашивается в комментарии Денниса :

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

Рубин, 16 байт

puts [*$<].reverse

JavaScript (SpiderMonkey Shell), 38 байт

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

Довольно просто

read() читает файл

readline() читает строку из STDIN

[...str]разделит str на массив символов

reverse() обратит массив

join`` объединит массив в строку

Python 2, 52 байта

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

C #, 179 171 байт

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

Читает строки, помещая их в стек, а затем записывает их назад. Я бы использовал Mathematica для этого, но он не имеет смысла EOF.

sed, 9 байт

1!G;h;$!d

Никакого upvote не хотел, это знаменитый сед-лайнер.

Perl, 16 байт

print reverse<>

Powershell, 41 байт

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

Сохраняет содержимое файла построчно a, переворачивает aи, наконец, печатает его.

GolfScript, 7 байт

n/-1%n*

Онлайн тест здесь .

Бурлеск , 6 байтов

ln<-uN

lnразбивает линии, <-переворачивает, uNобъединяет строки и форматы для необработанного вывода.

Баш, 48 43 персонажа

(Вдохновленный ответом Digital Trauma 's Bash . Ответы за идею должны пойти к нему.)

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

Образец прогона:

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 символов

(Вдохновленный Ed Мортон «s GNU Awk ответ . CW , как я не намеревался похитить его решение.)

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

Обратите внимание, что при изменении RT→ RSэто становится переносимым стандартным Awk, но теряет способность сохранять отсутствие последнего перевода строки.

Образец прогона:

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.

СНОБОЛ, 42 байта

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

Гема, 25 знаков

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

Образец прогона:

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

Калий , 90 байт 86 байт

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

Смотрите расширенный здесь

sed, 7 байт

G;h;$!d

Это работает для меня (и это самое короткое решение в других местах), но я действительно не хочу выяснять, почему. Я просто возился со знаменитым 9-байтовым трюком, пока не нашел это. Я думаю, Gчто первая строка ничего не делает?

JavaScript (Node.js), 91 байт

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

Баш + коммунальные услуги, 25

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

Здесь ^Gбуквальный BELхарактер. Я предполагаю, что ввод только для печати ASCII.

Это trанонсирует весь ввод в одну строку, заменяя символы новой строки на BEL, затем revперебрасывает эту строку, затем trвозвращает обратно в многострочное, затем revснова перебирает каждую строку, чтобы получить желаемый результат.

МАТЛАБ, 44

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

Разбивает строку на новые строки, переворачивает результирующий массив, а затем соединяется с символами новой строки.

Юлия, 65 байт

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

Это принимает файл в качестве аргумента командной строки и печатает его строки в обратном порядке. Конечные символы новой строки перемещаются на фронт, в отличие от того tac, что законно.

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])

Пип , 3 + 2 = 5 байт

Использует rи nфлаги; читает со стандартного ввода.

RVg

rФлага считывает стандартный ввод и сохраняет его в виде списка линий в g(который , как правило , список командной строки ар г ы). Затем мы переворачиваем этот список, и он автоматически печатается. В nсписках флагов причины для вывода с новой строки в качестве разделителя.