"टैक" लागू करें: रिवर्स में एक फ़ाइल से लाइनें प्रिंट करें

Question

बिल्ली के बच्चे के सवाल के बीच और यू एंड एल में कुछ sedजादू के बारे में इस सवाल को देखते हुए , कैसे लागू किया जाए tac?

---

लक्ष्य

एक प्रोग्राम को लागू करें जो एक फाइल में लाइनों को उल्टा और प्रिंट करेगा।

---

इनपुट

एक फ़ाइल, एक नाम के रूप में या मानक इनपुट के माध्यम से प्रदान की जाती है

---

उत्पादन

लाइनों, उलट, मानक बाहर करने के लिए।

---

स्कोरिंग

स्रोत कोड के बाइट्स।

Comments

tacएक अजीब सा है जब यह लाइनिंग फीडफुल की बात आती है। यह a\nb\n(अनुगामी लाइनफीड) को ( b\na\nऔर a\nbअनुगामी लाइनफीड को) में बदल देता है ba\n। क्या यह है कि हमारे कोड को कैसे व्यवहार करना चाहिए?

— डेनिस

संबंधित

— मार्टिन एंडर

इसके अलावा, अगर हमें टैक के व्यवहार को दोहराना है, तो एक 3 बाइट बैश जवाब जो निष्पादित करता tacहै, केवल कुछ ही समय होता है ...

— डेनिस

@ इस बिंदु पर डेनिस शायद अपरिभाषित छोड़ने के लिए सबसे अच्छा है।

— निक टी

@ डेनिस मेरे लिए मायने रखता है। किसी फ़ाइल की पंक्तियों को क्षैतिज पंक्तियों के रूप में देखें, जो सभी के साथ समाप्त हो रही हैं \n। tacइन पंक्तियों के क्रम को उलट देता है। यदि \nफ़ाइल के बीच में से एक हटा दिया जाता है, तो इसे समाप्त की गई पंक्ति अगली पंक्ति में शामिल हो जाती है, लेकिन अंतिम पंक्ति के मामले में, इसमें शामिल होने के लिए अगली पंक्ति नहीं है।

— ब्लैकलाइट शाइनिंग

Answer 1

जीएस 2, 3 बाइट्स

* +

तीन बाइट्स क्रम में, विभाजित लाइनों, रिवर्स, और लाइनों में शामिल हैं।

Answer 2

पर्ल, 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चर $_विभाजक ( $\) द्वारा स्थानीय चर (इस दायरे में अपरिभाषित) के मूल्य को प्रिंट करता है ।

Comments

यह समझाने के लिए कि यह कैसे काम करता है?

— xebtl

@xebtl Evilly -pस्विच जोड़ने से आपका कोड एक लूप में शुरू होता है जो शुरू होता है while(<>){और समाप्त होता है } continue { print }, जो केवल संशोधन करके इनपुट को फ़िल्टर करने की अनुमति देता है $_। $\=$_.$\आउटपुट रिकॉर्ड टर्मिनेटर के लिए इनपुट की प्रत्येक पंक्ति को प्रस्तुत करता है, और समय से पहले }{पर्ल-आपूर्ति whileब्लॉक को समाप्त करता है , इसलिए continueब्लॉक अब इसके साथ संलग्न नहीं है। तो इनपुट की सभी पंक्तियों को $\रिवर्स ऑर्डर में जोड़ दिया जाता है, फिर अंत में continue { print }" $_रनिंग ", "कुछ भी नहीं" को प्रिंट करता है ( इनपुट के अंत के बाद अपरिभाषित हो जाएगा), लेकिन के एक टर्मिनेटर के साथ $\।

— हॉब्स

@xebtl grr, टिप्पणियों में कोड स्वरूपण थोड़ा टूटा हुआ लगता है जहां बैकस्लैश और बैकटिक्स एक दूसरे के पास आते हैं। शायद आप अनुमान लगा सकते हैं कि मैं क्या कहना चाह रहा था।

— हॉब्स

@primo पहला उदाहरण दिखाता है कि इस मामले में क्या होता है। आउटपुट अजीब होगा, लेकिन बिल्कुल टैक की तरह।

— डेनिस

@ डेनिस इस पुस्तक के

— msh210

Answer 3

अजगर, 4 बाइट्स

j_.z

.zएक सूची के रूप में लाइनों द्वारा अलग किया गया इनपुट है, _इसे उलटता है और jइसे एक चरित्र द्वारा जोड़ता है, जो डिफ़ॉल्ट रूप से है \n।

Answer 4

FlogScript , 2 बाइट्स

)"

(पहनकर देखो अराजकता गोल्फ ।)

)सक्षम बनाता है --in-out-line-arrayमोड, और कार्यक्रम के बाकी है ", लाइनों की सरणी पीछे।

Comments

आर्ग, तुम मुझे इसे हरा!

— mbomb007 10

Answer 5

रेटिना , 7 बाइट्स

!rm`.*$

एक एकल रेगेक्स के साथ, रेटिना मैच मोड में चलता है। यह आम तौर पर मैचों की संख्या को प्रिंट करता है, लेकिन साथ! हम वास्तविक मैचों को प्रिंट करने के लिए कॉन्फ़िगर करते हैं (इसके बजाय लाइनफीड द्वारा अलग)।

वास्तविक रेगेक्स मात्र है .*$। .*किसी भी लाइन (संभावित रूप से खाली) से मेल खाता है, क्योंकि .लाइनफीड को छोड़कर किसी भी चरित्र से मेल खा सकता है। मैं ले आता हूँ$ एक मिनट में ।

हम इसे रिवर्स में मैचों को कैसे प्रिंट करते हैं? .NET के दाएं-से-बाएं मिलान मोड का उपयोग करके, के साथ सक्रिय किया गयाr । इसका मतलब है कि रेग्क्स इंजन मैच की तलाश में स्ट्रिंग के अंत में शुरू होता है और पीछे की ओर काम करता है।

अंत में, स्ट्रिंग के अंत के बजाय मैच को एक पंक्ति का अंत mबनाता है । हमें भी इसकी आवश्यकता क्यों है? मुसीबत यह है कि बाहर के मैचों को उत्पन्न करता है। रेगेक्स प्रतिस्थापन पर विचार करें$.*

s/a*/$0x/

इनपुट पर लागू किया गया baaababaa। आपको लगता है कि यह उपज होगा baaaxbaxbaax, लेकिन यह वास्तव में आपको देता है baaaxxbaxxbaaxx। क्यूं कर? क्योंकि मिलान aaaके बाद इंजन का कर्सर aऔर के बीच होता है b। अब यह किसी भी अधिक मेल नहीं खा सकता है a, लेकिन a*एक खाली स्ट्रिंग के साथ भी संतुष्ट है। इसका मतलब है, हर एक मैच के बाद आपको एक और खाली मैच मिलेगा।

हम यहां यह नहीं चाहते हैं, क्योंकि यह अतिरिक्त खाली लाइनों को पेश करेगा, इसलिए हम उन एक्सट्रॉनिक मैचों (जो दाएं-से-बाएं मोड के कारण लाइनों की शुरुआत में हैं) को त्याग देते हैं, उस मैचों को समाप्त करने की आवश्यकता होती है रेखा।

Answer 6

हास्केल, 34 बाइट्स

main=interact$concat.reverse.lines

[संपादित करें]

के unlinesसाथ बदलकर एक बाइट को बचाया concat।

Answer 7

सीजेएम, 7 बाइट्स

qN/W%N*

स्टड पढ़ता है, प्रिंट करने के लिए प्रिंट करता है।

स्पष्टीकरण:

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

Answer 8

अजगर, 5 बाइट्स

jb_.z

यह एक साधारण विभाजन-रिवर्स-जॉइन दृष्टिकोण के साथ लाइनों के क्रम को उलट देता है, लेकिन टैक की तरह नहीं ।

इसे ऑनलाइन आज़माएं।

Answer 9

बेफुज -93, 17 बाइट्स

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

यहाँ कुछ भी नहीं फैंसी; बस स्टैक पर सब कुछ डाल दिया, फिर इसे पॉप।

Answer 10

शुद्ध बैश (कोई बाहरी उपयोगिताओं नहीं), 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.
$ 

Comments

अच्छा और प्रेरणादायक ।

— मैनटवर्क

Answer 11

रूबी, 16 बाइट्स

puts [*$<].reverse

Answer 12

जावास्क्रिप्ट (स्पाइडरमोनीक शेल), 38 बाइट्स

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

बहुत साधारण

---

read() एक फ़ाइल पढ़ता है

readline() स्टैडिन से एक स्ट्रिंग पढ़ता है

[...str]बंट जाएगा str वर्ण की एक सरणी में

reverse() सरणी को उलट देगा

join`` सरणी को स्ट्रिंग में तब्दील कर देगा

Answer 13

पायथन 2, 52 बाइट्स

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

Comments

क्या इनपुट () स्टड से एक पंक्ति नहीं पढ़ता है?

— लिन

@ मौरिस ने इसे संपादित किया

— बीटा

किस बारे में import sys;print sys.stdin.read()[::-1]?

— आहार विशेषज्ञ

@ डिएटर जो प्रत्येक चरित्र को उलट देता है, चुनौती उलटी होने के लिए सिर्फ पंक्तियों के लिए कहती है

— बीटा

ठीक है मेरा बुरा - यह ध्यान से नहीं पढ़ा, क्षमा करें

— डायटर

Answer 14

सी #, 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 का कोई अर्थ नहीं है।

Answer 15

sed, 9 बाइट्स

1!G;h;$!d

कोई उत्थान नहीं चाहता था, यह एक प्रसिद्ध सेड वन-लाइनर है।

Comments

यदि यह आपका अपना काम नहीं है, तो मैं आपके उत्तर को सामुदायिक विकि बनाने का सुझाव देता हूं।

— lirtosiast

Answer 16

पर्ल, 16 बाइट्स

print reverse<>

Comments

@ डेनिस उफ़, अब उल्टा हो गया।

— स्टीव

Answer 17

पॉवरशेल, 41 बाइट्स

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

किसी फ़ाइल लाइन की सामग्री को लाइन में स्टोर करता है a, उलटा करता है aऔर अंत में प्रिंट करता है।

Answer 18

GolfScript, 7 बाइट्स

n/-1%n*

ऑनलाइन परीक्षण यहाँ ।

Answer 19

बर्लेस्क , 6 बाइट्स

ln<-uN

lnकच्चे माल के लिए लाइनों को विभाजित करता है, <-उलटता है, uNलाइनों और प्रारूपों को जोड़ता है।

Answer 20

बैश, 48 43 अक्षर

( डिजिटल ट्रॉमा के बैश जवाब से प्रेरित है । विचार के लिए विचार उसके पास जाने चाहिए।)

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.

Comments

मुझे लगता है कि आप mapfile -c1 -Cfइसके बजाय कर सकते हैं mapfile -c1 -Cf a।

— डिजिटल ट्रामा

सही बात। मैंने इस बीच भी इसका पता लगाया, बस उस मुश्किल के आसपास कुछ करने की कोशिश की -C।

— मैनटवर्क

Answer 21

GNU Awk, 27 वर्ण

( एड मॉर्टन के GNU Awk जवाब से प्रेरित । सीडब्ल्यू। जैसा कि मैंने उसका समाधान अपहरण करने का इरादा नहीं किया है।)

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

Comments

आप "% s"

— Ninjalj

@injalj, केवल अगर हम मान सकते हैं कि इनपुट में कभी भी "%" नहीं होगा।

— मैनटवर्क

Answer 22

SNOBOL, 42 बाइट्स

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

Answer 23

गामा, 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

Answer 24

हासियम , 90 बाइट्स 86 बाइट्स

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

यहां विस्तार देखें

Comments

मैं आप forवाक्यविन्यास को गाली देकर इसे बहुत छोटा कर सकता हूं । यहाँ

— FryAmTheEggman

अच्छी कॉल @FryAmTheEggman! मैंने इसे जोड़ा।

— जैकब मिसिरियन

Answer 25

sed, 7 बाइट्स

G;h;$!d

यह मेरे लिए काम करता है (और यह कहीं और सबसे छोटा समाधान है), लेकिन मैं वास्तव में यह नहीं जानना चाहता कि क्यों। मैं बस प्रसिद्ध 9-बाइट चाल के साथ गड़बड़ कर दिया जब तक मुझे यह नहीं मिला। मुझे लगता है Gकि पहली लाइन आईएनजी कुछ भी नहीं है?

Comments

वास्तव में कुछ करता है: आपका कोड आउटपुट के अंत में एक अतिरिक्त नई लाइन तैयार करता है। ( Gपैटर्न स्पेस के लिए एक न्यूलाइन और होल्ड स्पेस की सामग्री को जोड़ता है। खाली होल्ड स्पेस की सामग्री को लागू करना वास्तव में हानिरहित है, न्यूलाइन अभी भी संलग्न है।)

— मैनटवर्क

Answer 26

जावास्क्रिप्ट (Node.js), 91 बाइट्स

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

Comments

क्या आपका मतलब console.log((require('fs').readFileSync(process.argv[2])+"").split(d="\n").reverse().join(d))(92 बाइट्स) था? आपका वर्तमान कोड लाइनों को उलट नहीं करता है।

— टूथब्रश

Answer 27

बैश + आम उपयोगिताओं, 25

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

यहाँ ^Gएक शाब्दिक हैBEL चरित्र है। मुझे लगता है कि इनपुट केवल मुद्रण योग्य है।

यह trबीईएल के साथ newlines को प्रतिस्थापित करके पूरे इनपुट को एक पंक्ति में ansforms करता है, फिर revउस लाइन को फिर से trबनाता है , फिर ansforms को मल्टीलाइन में वापस करता है, फिर revप्रत्येक पंक्ति को फिर से erses करता है, ताकि वांछित आउटपुट प्राप्त कर सके।

Answer 28

MATLAB, 44

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

स्ट्रिंग को नई लाइनों पर विभाजित करता है, परिणामस्वरूप सरणी को फ़्लिप करता है, फिर नई लाइन वर्णों के साथ जुड़ता है।

Answer 29

जूलिया, 65 बाइट्स

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

यह कमांड लाइन तर्क के रूप में एक फाइल लेता है और रिवर्स ऑर्डर में इसकी लाइनें प्रिंट करता है। अनुगामी newlines को सामने की ओर ले जाया जाता है, इसके विपरीत 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])

Answer 30

पिप , 3 + 2 = 5 बाइट्स

rऔर nझंडे का उपयोग करता है ; स्टड से पढ़ता है।

RVg

rध्वज में लाइनों की सूची के रूप में stdin और यह भंडार पढ़ता है g(जो आम तौर कमांड लाइन ar की एक सूची है जी रों)। फिर हम उस सूची को उल्टा करते हैं, और यह स्वतः-मुद्रित होता है। nझंडा कारणों सूचियों एक विभाजक के रूप में न्यू लाइन के साथ उत्पादन किया जाना है।