लिनक्स कमांड एक स्ट्रिंग n बार दोहराने के लिए

Question

क्या कोई अंतर्निहित लिनक्स कमांड है जो एक स्ट्रिंग को आउटपुट करने की अनुमति देता है जो कि इनपुट स्ट्रिंग n है?

Comments

"बिल्ट-इन लिनक्स कमांड" के द्वारा, मेरा मानना ​​है कि आप शेल कमांड का मतलब है, और जब से आप उल्लेख नहीं करते हैं कि आप किस शेल का उपयोग कर रहे हैं, मुझे लगता है कि यह बैश है। आप कमांड लाइन पर "इको $ शेल" टाइप करके इसे चेक कर सकते हैं और आपको वापस "/ बिन / बैश" के समान कुछ मिलना चाहिए। यदि आप ऐसा नहीं करते हैं, तो आपको यह दिखाने के लिए अपने जवाब को संपादित करना चाहिए कि यह क्या दिखाता है। चीयर्स :)

— एड्रियन पेट्रेस्कु

मैंने प्रश्न को "बैश" के साथ टैग किया। मैंने सोचा था कि काफी हो गया होगा।

— GetFree

स्टैक ओवरफ्लो पर संबंधित : stackoverflow.com/q/3211891/2157640

— Palec

Answer 1

adrian@Fourier:~$ printf 'HelloWorld\n%.0s' {1..5}
HelloWorld
HelloWorld
HelloWorld
HelloWorld
HelloWorld
adrian@Fourier:~$

Comments

क्या आप बता सकते हैं कि यह कैसे काम करता है? मैं प्रिंटफ कमांड को समझता हूं क्योंकि यह C / C ++ में एक जैसा है। लेकिन मुझे समझ में नहीं आया कि {1..5} का विस्तार कैसे किया जाता है और यह "% .0s" भाग के साथ कैसे काम करता है।

— GetFree

यह एक हैक का एक सा है :) "Printf 'चलाने की कोशिश करें HelloWorld% d \ n' 1 2 3 4 5" और यह शायद आपके लिए क्लिक करेगा। % .0s ध्वज कुछ भी करने के लिए नहीं है, बस वहाँ तर्क लेने के लिए हो। फिर, यदि बैश को प्रारूप विनिर्देशक की तुलना में अधिक तर्क मिलते हैं, तो यह बस कई प्रतियों को प्रिंट करेगा, जो कि इसकी आवश्यकता के अनुसार कई हैं। तो आपको असर मिलता है। "Printf 'HelloWorld% d% d \ n' 1 2 3 4 5 6" का आउटपुट शायद इसे और भी स्पष्ट कर देता है। उम्मीद है की यह मदद करेगा!

— एड्रियन पेट्रेस्कु

समझा। यह

— प्रिंटफ

(मुझे ध्यान देना चाहिए कि, विशुद्ध रूप से सैद्धांतिक दृष्टिकोण से, यह संभवतया सबसे तेज़ समाधान है क्योंकि यह एकल शेल आदिम का उपयोग करता है - किसी भी बाहरी प्रक्रिया का नहीं। वास्तव में, आइए इसका सामना करते हैं, बैश स्क्रिप्ट का प्रदर्शन वास्तव में मायने नहीं रखता है: )

— एड्रियन पेट्रेस्कु

क्या है के लिए विशिष्ट printfहै कि यह बार-बार प्रारूप स्ट्रिंग, मुक्त करने के लिए "पाशन" करने के लिए अतिरिक्त तर्क लागू होगी। "अधिकता" से मेरा मतलब है कि %प्लेसहोल्डर्स की तुलना में अधिक तर्क हैं ।

— डेनिस विलियमसन

Answer 2

यहाँ एक पुराने ढंग का है जो बहुत पोर्टेबल है:

yes "HelloWorld" | head -n 10

यह ब्रेस विस्तार का उपयोग करते हुए एड्रियन पेट्रेस्कु के उत्तर का एक और पारंपरिक संस्करण है :

for i in {1..5}
do
    echo "HelloWorld"
done

इसके बराबर है:

for i in 1 2 3 4 5

यह पाइक के उत्तर का थोड़ा और संक्षिप्त और गतिशील संस्करण है :

printf -v spaces '%*s' 10 ''; printf '%s\n' ${spaces// /ten}

Comments

हां कमांड का उपयोग करते समय आप नई लाइनों से कैसे छुटकारा पाते हैं?

— GetFree

एक तरीका यह है कि इसे sed -n 'H;${x;s/\n//gp}'या sed -n ':t;${s/\n//gp};N;bt'किसी अन्य के माध्यम से पाइप करना है echo $(yes "HelloWorld" | head -n 10)जो स्ट्रिंग की प्रत्येक प्रतिलिपि के बीच एक स्थान जोड़ता है। फिर भी एक और तरीका यह है tr -d '\n'कि इसके माध्यम से पाइप को अंतिम रूप से समाप्त कर दिया जाए।

— डेनिस विलियमसन

यह बाश शेल में हास्केल की तरह है: हशेल?

— वचर्जिन

हाँ समाधान बहुत साफ है

— सूअर का बच्चा

yesके बाद से मैं एक आदेश (जिसका उत्पादन घटता-बढ़ता है) नकल करना चाहता था समाधान मैं वास्तव में क्या जरूरत थी। इस प्रकार:yes "$(my-command)" | head -n 2

— arnsholt

Answer 3

इसे मानकीकृत किया जा सकता है और इसके लिए अस्थायी चर की आवश्यकता नहीं है, FWIW:

printf "%${N}s" | sed 's/ /blah/g'

या, यदि $Nबैश सरणी का आकार है:

echo ${ARR[@]/*/blah}

Comments

यह सबसे छोटा POSIX 7 समाधान है जो मैंने अब तक देखा है seq, yesऔर {1..5}POSIX 7 नहीं हैं

— Ciro Santilli 中心 P P P

आपको डेटा को printfप्रारूप के प्रारूप में नहीं मिलाना चाहिए । क्या होगा यदि डेटा में प्रारूप स्ट्रिंग हैं? यह "सटीक" (लंबाई) को गतिशील रूप से निर्दिष्ट करने का सही तरीका है: printf '%*s' "$N"- इसे चर में विस्तार को रोकने के लिए एकल उद्धरण में प्रारूप स्ट्रिंग को संलग्न करने की आदत डालें।

— डेनिस विलियमसन

Answer 4

पहले से बताए गए कुछ अच्छे तरीके। seqहालांकि पुराने अच्छे के बारे में नहीं भूल सकता :

[जॉन @ कमाल] $ में मैं `seq 5` के लिए; गूंज "हाय"; किया गया
नमस्ते
नमस्ते
नमस्ते
नमस्ते
नमस्ते

Comments

यह वास्तव में एक शून्य का सम्मान करता है, इसे शून्य मानता है! ( {i..j}ट्रिक कभी भी एक खाली सीमा नहीं लौटाती है।)

— जेल्कालकैट

Answer 5

शायद एक और तरीका जो आपके लिए अधिक सामान्य और उपयोगी हो:

adrian@Fourier:~$ n=5
adrian@Fourier:~$ for (( c=1; c<=n; c++)) ; do echo "HelloWorld" ; done
HelloWorld
HelloWorld
HelloWorld
HelloWorld
HelloWorld
adrian@Fourier:~$ 

बैश शेल उन लोगों की तुलना में अधिक शक्तिशाली है जो सोचते हैं :)

Comments

यह मेरा वोट हो जाता है, क्योंकि यह पूरी तरह से शेल-आंतरिक है; कोई फोर्किंग की आवश्यकता नहीं है।

— ईएसएम

आप किस फोर्किंग की बात कर रहे हैं? मूल उत्तर के लिए किसी की आवश्यकता नहीं है। 'टाइप प्रिंटफ' का आउटपुट 'प्रिंटफ एक शेल बिल्डिन है' और इसलिए यह मूल बैश प्रक्रिया के भीतर चलता है।

— कोडगोमन

यह केवल एक ही अब तक (है yes, printf, for i in {1..5}) है कि यदि nशून्य है, यह रिटर्न रिक्त स्ट्रिंग तुलना के लिए गणितीय संकेतन के कारण 1. इसके अलावा की स्थिति मौजूद बिना, यह 1 से कम करते हैं करने के लिए आसान है (बदलकर जैसे <=करने के लिए <)

— मेहद महमूदीन

Answer 6

आप एक चाल का उपयोग कर सकते हैं। एक खाली चर को प्रतिध्वनित करने से कुछ भी प्रिंट नहीं होता है। तो आप लिख सकते हैं:

echo word$wojek{1..100}

यदि $wojek1 $wojek2... $wojek100गैर-मौजूदा चर हैं, तो आपको अपना शब्द 100 बार बिना किसी और चीज़ के दोहराया जाएगा।

Comments

यह एक बदसूरत बदसूरत हैक है, और फिर भी मैं मदद नहीं कर सकता लेकिन इसे प्यार करता हूं और इसका उपयोग करता हूं।

— 16807

इसे प्यार करना! शायद इरादे को साफ $_करने के बजाय उपयोग करना $wojek।

— मिहाई टोडर

Answer 7

दोहराएँ nबार, बस प्रतीक्षा n-1के बीच अल्पविराम {}:

$ echo 'helloworld'{,,}
helloworld helloworld helloworld

पहली प्रतिध्वनि के बाद दो बार cho हेलोवर्ल्ड ’दोहराता है।

Comments

अच्छा है, लेकिन क्या होगा अगर मैं nएक चर से प्राप्त करना चाहता हूं ?

— GetFree

यह प्रत्येक '

— हेलोवर्ल्ड

ऐसा लगता है कि आप या तो स्ट्रिंग में नई

— सुर्खियाँ नहीं डालते हैं

Answer 8

awk 'BEGIN {while (c++<4) printf "Hello"}'

नतीजा

नमस्ते नमस्ते नमस्ते नमस्ते

Comments

इसे बिना जगाए उपयोग करें: जबकि ((c ++ <5)); प्रिंटफ 'हेलो' करें; किया

— ईएमएफ

Answer 9

मैंने yesसमाधान के साथ टूटी हुई पाइप चेतावनियों का अनुभव किया है , इसलिए यहां एक और अच्छा विकल्प है:

$ seq 4 | sed "c foo"
foo
foo
foo
foo

Answer 10

@pike किस पर आधारित था

स्ट्रिंग इको स्ट्रिंग में हर पात्र के लिए

echo ${target//?/$replace}

=पात्रों के साथ रेखांकित शीर्षक का एक उदाहरण

export heading='ABCDEF'; 
export replace='='; 
echo -e "${heading}\n${heading//?/$replace}"

उत्पादन होगा

ABCDEF
======

यह linux और OS X के बीच का पोर्ट लगता है और इससे मुझे खुशी मिलती है।

एन ज्वॉय!

Answer 11

यदि आप बीएसडी पर हैं, तो आप बस उपयोग कर सकते हैं seq।

$ seq -f "Hello, world" 5
Hello, world
Hello, world
Hello, world
Hello, world
Hello, world

Comments

इसमें seq (GNU coreutils) 8.25, यह seq: format 'Hello, world' has no % directiveएक फॉर्मेटिंग निर्देशन को प्रस्तुत करने के लिए मजबूर करता है। GNU कोरुटिल्स का उपयोग किया जाता है उदा n कई लिनक्स वितरण और सिगविन। उन लोगों के लिए यहाँ जानकारी शामिल है जो यह जानकारी याद कर रहे हैं कि यह केवल BSD seq में काम करता है।

— पेलेक

Answer 12

line="==========================="
line=${line:0:10}
${line//"="/"ten "}

आउटपुट

ten ten ten ten ten ten ten ten ten ten

Comments

शायद एक और अधिक क्रिया उदाहरण: c घोषित करें c = '-----'; c = $ {ग // $ {c: 0: 1} / $ ग}; इको $ c # प्रिंट "-" 25 बार।

— स्टीफन नेदिज़ेल्स्की 23

Answer 13

यह मानते हुए कि आप पर्ल के xऑपरेटर की तरह कुछ चाहते हैं , जहाँ आपको स्वतः पुनरावृत्ति के बीच एक नई रेखा नहीं मिलती है:

x() {
  # usage: x string num
  for i in $(seq 1 $2); do printf "%s" "$1"; done
  # print a newline only if the string does not end in a newline
  [[ "$1" == "${1%$'\n'}" ]] && echo ""
}

x Hi 10  # ==> HiHiHiHiHiHiHiHiHiHi

x $'Hello World!\n' 3

मैंने स्पष्ट रूप से एक forलूप का उपयोग किया है क्योंकि आप {1..$n}बैश में नहीं लिख सकते हैं : ब्रेस का विस्तार चर प्रतिस्थापन से पहले किया जाता है।

Answer 14

बिल्कुल लिनक्स में नहीं बनाया गया है, लेकिन अगर आपके पास अजगर स्थापित है ..

python
>>>var = "string"
>>>var*n

या एक पंक्ति में, जैसा कि टिप्पणीकार ने सुझाव दिया है:

python -c 'print "This is a test.\n" * 10'

Comments

वास्तव में यह उपयोगी नहीं है, क्योंकि इसे आसानी से शेल स्क्रिप्ट में एकीकृत नहीं किया जा सकता है, आदि और चूंकि शेल में स्वयं ऐसा करने के लिए लगभग एक बिलियन तरीके हैं, इसलिए मुझे इसके लिए बड़ी बंदूकें (अर्थात पायथन) लाने का बहुत कम कारण दिखाई देता है। ।

— एड्रियन पेट्रेस्कु

मैं आपके दूसरे बिंदु से सहमत हूं, लेकिन मुट्ठी से नहीं ... यह एक शेल स्क्रिप्ट में एकीकृत करना आसान है: अजगर -c 'प्रिंट "यह एक परीक्षण है। \ n" * 10 "

— लार्क्स

मुझे इस समाधान की पठनीयता पसंद है, मेरे लिए पर्याप्त कारण। ;)

— एलियास

Answer 15

यहां कोई जादू नहीं:

seq 5 | awk '{print "Hello World"}'

Answer 16

इसको आजमाओ:

echo $(for i in $(seq 1 100); do printf "-"; done)

बनाएंगे (सौ डैश):

---