Arasında yavru soru ve görme U & L bu soruyu bazıları hakkında sednasıl uygulanması hakkında, büyü tac?

Amaç

Bir dosyadaki satırları ters çevirecek ve yazdıracak bir program uygulayın.

Giriş

Bir ad veya standart giriş yoluyla sağlanan bir dosya

Çıktı

Satırlar ters çevrildi, standartlaştırıldı.

puanlama

Kaynak kodun baytları.

GS2, 3 bayt

* +

Üç bayt sırayla, satırları bölün, satırları ters çevirir ve satırlardır.

Perl, 11 bayt

$\=$_.$\}{

Aynen gibi davranır tac. Bu kod -p1 bayt olarak saydığım anahtarı gerektiriyor .

Test çalıştırması

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

Nasıl çalışır

As açıkladı Burada , -panahtar temelde sarar while (<>) { ... ; print }kaynak kodu eşdeğerdir, böylece program etrafında

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

Her girdi satırı için, geçerli satırı ( $_) için $\(başlangıçta tanımsız) olarak hazırlıyoruz, ikincisini sonuçla güncelliyoruz.

Tüm satırlar işlendikten sonra print, yerel değişkenin değerini $_(bu kapsamda tanımlanmamış) ve ardından çıkış kayıt ayırıcısını ( $\) yazdırın .

Pyth, 4 bayt

j_.z

.zSatırlarla liste halinde ayrılan giriş, _onu ters çevirir ve jvarsayılan olarak olduğu gibi bir karakterle birleştirir \n.

FlogScript , 2 bayt

)"

( Anarşi golfü deneyin .)

)Sağlayan --in-out-line-arraybir mod ve programın geri kalanı "hat dizi ters.

Retina , 7 bayt

!rm`.*$

Tek bir regex ile, Retina Maç modunda çalışır. Bu normalde yalnızca eşleşme sayısını yazdırır, ancak !bunun yerine gerçek eşleşmeleri yazdırmak üzere yapılandırırız (satır beslemeleri ile ayrılmış).

Gerçek regex sadece .*$. .*satırlar .dışında herhangi bir karakterle eşleşebileceğinden herhangi bir satırla eşleşebilir (potansiyel olarak boş) . $Bir dakika içinde içeri gireceğim.

Kibritleri tersten nasıl yazdırabiliriz? .NET'in sağdan sola eşleme modunu kullanarak, ile etkinleştirilir r. Bu, regex motorunun, eşleşmeleri ararken geriye doğru çalıştığı ve dizenin sonunda başladığı anlamına gelir.

Son olarak, mmake $eşleşmeyi dizenin sonu yerine satırın sonuna getirir . Neden buna ihtiyacımız var? Sorun, .*yabancı eşleşmeler yaratmasıdır. Regex ikamesini düşünün

s/a*/$0x/

girişe uygulanır baaababaa. Bunun sonuç vereceğini düşünürsün baaaxbaxbaax, ama aslında sana verir baaaxxbaxxbaaxx. Niye ya? Çünkü aaamotorun imleci eşleştikten sonra ave arasındadır b. Şimdi daha fazla as eşleşemiyor, ancak a*boş bir dize ile de tatmin oluyor. Bu, her bir maçtan sonra başka bir boş maç elde edeceğiniz anlamına gelir.

Bunu istemiyoruz, çünkü ek boş satırlar ortaya koyacağından, bu yabancı eşleşmeleri ( satırın başlangıcında , sağdan sola modu nedeniyle) eşleştirmelerin sona ermesini isteyerek atarız. çizgi.

Haskell, 34 bayt

main=interact$concat.reverse.lines

[Düzenle]

Değiştirerek bir bayt Kaydedilen unlinesile concat.

CJam, 7 bayt

qN/W%N*

Stdin okur, stdout'a yazdırır.

Açıklama:

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

Pyth, 5 bayt

jb_.z

Bu, satırların sırasını basit bir ayrık-ters-birleştirme yaklaşımıyla tersine çevirir, ancak tam olarak tac değildir .

Çevrimiçi deneyin.

Befunge-93, 17 bayt

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

Burada hiçbir şey fantezi değil; Sadece her şeyi yığına koyun, sonra çıkarın.

Saf Bash (harici yardımcı program yoktur), 56

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

Bu, Dennis'in yorumundatac sorulduğu gibi, tam bir emülasyon yapmak için verilen birkaç cevaptan biri :

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

Yakut, 16 bayt

puts [*$<].reverse

JavaScript (SpiderMonkey Kabuğu), 38 bayt

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

Oldukça basit

read() bir dosyayı okur

readline() STDIN'den bir dize okur

[...str]str'yi bir karakter dizisine böler

reverse() diziyi tersine çevirir

join`` diziyi bir dizgeye sıkıştırır

Python 2, 52 bayt

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

C #, 179 171 bayt

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

Çizgileri okur, bunları bir yığına yerleştirir ve sonra geriye doğru yazar. Bunun için Mathematica'yı kullanırdım, ancak EOF anlayışı yok.

sed, 9 bayt

1!G;h;$!d

İstenmeyen bir oylama yok, bu meşhur bir tek gömlek.

Perl, 16 bayt

print reverse<>

Powershell, 41 bayt

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

Bir dosyanın içeriğini satır satır asaklar, tersine çevirir ave sonunda yazdırır.

GolfScript, 7 bayt

n/-1%n*

Çevrimiçi test burada .

Burlesque , 6 bayt

ln<-uN

lnsatırları böler, <-tersine çevirir, uNham çıktı için çizgileri ve biçimleri birleştirir.

Bash, 48 43 karakter

(Esinlenerek Dijital Travma 'ın Bash cevap . Fikir için upvotes ona gitmelidir.)

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

Örnek çalışma:

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 karakter

(Esinlenerek Ed Morton 'ın GNU Awk cevap ben onun çözümünü kaçırma amaçlandığı gibi. CW.)

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

Bunu değiştirerek RT→ RSbunun taşınabilir bir standart Awk olduğunu ancak son satırın yokluğunu koruma yeteneğini kaybettiğini unutmayın.

Örnek çalışma:

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 bayt

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

Gema, 25 karakter

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

Örnek çalışma:

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 Bayt 86 Bayt

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

Burada genişletilmiş bakın

sed, 7 bytes

G;h;$!d

This works for me (and it's the shortest solution elsewhere), but I don't really want to find out why. I just messed around with the famous 9-byte trick until I found this. I guess Ging the first line does nothing?

JavaScript(Node.js), 91 Bytes

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

Bash + common utilities, 25

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

Here the ^G is a literal BEL character. I'm assuming the input is only printable ascii.

This transforms the entire input to one line by replacing newlines with BELs, then reverses that line, then transforms back to multiline, then reverses each line again, to get the desired output.

MATLAB, 44

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

Splits the string at new lines, flips the resulting array, then rejoins with new line characters.

Julia, 65 bytes

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

This takes a file as a command line argument and prints its lines in reverse order. Trailing newlines are moved to the front, unlike tac, which is legit.

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

Uses the r and n flags; reads from stdin.

RVg

The r flag reads stdin and stores it as a list of lines in g (which is normally a list of command-line args). We then reverse that list, and it is auto-printed. The n flag causes lists to be output with newline as a separator.