ระหว่างคำถามลูกแมวและเห็นคำถามนี้ที่ 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 ไบต์

)"

(ลองบนอนาธิปไตยกอล์ฟ )

)ช่วยให้--in-out-line-arrayโหมดและส่วนที่เหลือของโครงการคือ"ย้อนกลับอาร์เรย์ของเส้น

เรติน่า 7 ไบต์

!rm`.*$

ด้วย regex เพียงครั้งเดียว Retina ทำงานในโหมดจับคู่ โดยปกติแล้วจะพิมพ์จำนวนการแข่งขัน แต่ด้วย!การกำหนดค่าให้เราพิมพ์การแข่งขันที่แท้จริงแทน (คั่นด้วย linefeeds)

regex .*$ที่เกิดขึ้นจริงเป็นเพียง .*ตรงกับบรรทัดใด ๆ (อาจว่างเปล่า) เนื่องจาก.สามารถจับคู่อักขระใด ๆ ยกเว้น linefeeds ฉันจะไป$ในนาทีเดียว

เราจะทำให้มันพิมพ์การแข่งขันในสิ่งที่ตรงกันข้ามได้อย่างไร โดยการใช้โหมดการจับคู่ .NET rขวาไปซ้ายเปิดใช้งานด้วย ซึ่งหมายความว่าเอ็นจิ้น regex เริ่มต้นที่ส่วนท้ายของสตริงเมื่อค้นหารายการที่ตรงกัน

ในที่สุดการmทำให้$ตรงกับจุดสิ้นสุดของบรรทัดแทนส่วนท้ายของสตริง ทำไมเราถึงต้องใช้มัน? ปัญหาคือการ.*สร้างการแข่งขันที่ไม่เกี่ยวข้อง พิจารณาการทดแทน regex

s/a*/$0x/

baaababaaนำไปใช้ในการป้อนข้อมูล คุณจะคิดว่านี้จะให้ผลผลิตbaaaxbaxbaaxแต่จริง ๆ baaaxxbaxxbaaxxแล้วมันจะช่วยให้คุณ ทำไม? เพราะหลังจากที่ตรงกับaaaเคอร์เซอร์ของเครื่องยนต์อยู่ระหว่างและa bตอนนี้มันไม่สามารถจับคู่อีกaต่อไป แต่a*ก็ยังพอใจกับสตริงที่ว่างเปล่า ซึ่งหมายความว่าหลังจากทุกการแข่งขันคุณจะได้รับการจับคู่ที่ว่างเปล่าอีกครั้ง

เราไม่ต้องการที่นี่เพราะมันจะแนะนำบรรทัดว่างเพิ่มเติมดังนั้นเราจึงยกเลิกการจับคู่ที่ไม่เกี่ยวข้อง (ซึ่งเป็นจุดเริ่มต้นของบรรทัดเนื่องจากโหมดจากขวาไปซ้าย) โดยกำหนดให้การจับคู่นั้นรวมถึงจุดสิ้นสุดของ เส้น.

Haskell, 34 ไบต์

main=interact$concat.reverse.lines

[แก้ไข]

ที่บันทึกไว้หนึ่งไบต์โดยการแทนที่ด้วยunlinesconcat

CJam, 7 ไบต์

qN/W%N*

อ่าน stdin พิมพ์ไปที่ stdout

คำอธิบาย:

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

Pyth, 5 ไบต์

jb_.z

นี่เป็นการกลับคำสั่งของเส้นด้วยวิธีการแยกกลับเข้าร่วมง่าย ๆ แต่ไม่เหมือนแทค

ลองออนไลน์

Befunge-93, 17 ไบต์

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

ไม่มีอะไรแฟนซีที่นี่; เพียงวางทุกอย่างลงในสแต็กจากนั้นเปิดออก

Pure Bash (ไม่มียูทิลิตี้ภายนอก), 56

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

นี่คือหนึ่งในไม่กี่คำตอบที่จะทำการtacจำลองที่ถูกต้องตามที่ถามในความคิดเห็นของ 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.
$ 

ทับทิมขนาด 16 ไบต์

puts [*$<].reverse

JavaScript (SpiderMonkey Shell), 38 ไบต์

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

ค่อนข้างง่าย

read() อ่านไฟล์

readline() อ่านสตริงจาก STDIN

[...str]จะแบ่งstrเป็นอาร์เรย์ของ chars

reverse() จะย้อนกลับอาร์เรย์

join`` จะ collpase อาร์เรย์เป็นสตริง

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

ไม่ต้องมีการลงคะแนนนี่เป็นเซดซับหนึ่งที่โด่งดัง

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รวมเส้นและรูปแบบสำหรับเอาต์พุตดิบ

Bash, 48 43 ตัวอักษร

(ได้รับแรงบันดาลใจจากคำตอบของBashของDigital Trauma การอัปเดตความคิดควรไปหาเขา)

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 ตัวอักษร

(แรงบันดาลใจจากเอ็ดมอร์ตัน '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.

SNOBOL ขนาด 42 ไบต์

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

Gema, 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

Hassium , 90 Bytes 86 Bytes

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

Bash + ยูทิลิตี้ทั่วไป, 25

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

ที่นี่ ^Gเป็นตัวอักษรBELตัวอักษร ฉันสมมติว่าการป้อนข้อมูลเป็น ASCII ที่พิมพ์ได้เท่านั้น

นี่เป็นการtrเปลี่ยนรูปแบบอินพุตทั้งหมดเป็นหนึ่งบรรทัดโดยแทนที่บรรทัดใหม่ด้วย BELs แล้วrevเปลี่ยนเป็นบรรทัดนั้นจากนั้นtrเปลี่ยนกลับเป็นหลายrevบรรทัดจากนั้นแทรกแต่ละบรรทัดอีกครั้งเพื่อรับเอาต์พุตที่ต้องการ

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

Pip , 3 + 2 = 5 ไบต์

ใช้rและnธง อ่านจาก stdin

RVg

rธงอ่าน stdin และเก็บไว้เป็นรายการของสายในg(ซึ่งเป็นปกติของรายการบรรทัดคำสั่ง AR กรัม s) จากนั้นเราจะกลับรายการนั้นและพิมพ์อัตโนมัติ nรายการสาเหตุธงที่จะส่งออกที่มีการขึ้นบรรทัดใหม่เป็นตัวคั่น