तारांकन के 10 ग्रिड द्वारा 10 प्रिंट करें

83

पृष्ठभूमि

यह छोरों के लिए प्रदर्शित करने के लिए एक मानक पाठ्यपुस्तक उदाहरण है।

यह पहला कार्यक्रम है जो मैंने तब सीखा जब मैंने 10 साल पहले प्रोग्रामिंग सीखना शुरू किया था।

कार्य

आपको यह सटीक पाठ प्रिंट करना है:

**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

ऐनक

  • आपके पास अतिरिक्त अनुगामी newlines हो सकते हैं।
  • आपके पास प्रत्येक पंक्ति के अंत में अतिरिक्त अनुगामी स्थान (U + 0020) हो सकते हैं, जिसमें अतिरिक्त अनुगामी न्यूलाइन्स भी शामिल हैं।

स्कोरिंग

यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब।

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

कोड स्निपेट दिखाएं

code-golf  kolmogorov-complexity 
— लीक नन
स्रोत
2
@DylanMeeus "आप इस सटीक पाठ को प्रिंट करने के लिए हैं :"
— लीक नून
13
@DylanMeeus चूँकि देव उपकरण के साथ करना है जो बार-बार कंसोल आउटपुट को छुपाता है, और जावास्क्रिप्ट कंसोल के मूल निवासी नहीं है और यह पूरी तरह से जावास्क्रिप्ट युक्ति में नहीं है - साथ ही तथ्य यह है कि सुविधा को बंद किया जा सकता है - मुझे लगता है कि स्वीकार्य होना चाहिए। सभी ब्राउज़र इसे इस तरह से ध्वस्त नहीं करेंगे।
— १२:
6
@LeakyNun लीडरबोर्ड स्निपेट कृपया!
— dkudriavtsev 22
2
इस चालान के बारे में सबसे दिलचस्प चीजों में से एक यह है कि आपकी भाषा के आधार पर ********** कम हो सकता है फिर एक लूप। मुझे आश्चर्य होता है जब किसी दिए गए भाषा के लिए 1 या 2 छोरों के बीच स्विच करना बेहतर होता है।
— dwana
1
आप कहते हैं कि नई लाइनें अनुगामी स्वीकार्य हैं। क्या प्रमुख न्यूलाइन भी स्वीकार्य हैं?
— अल्बर्ट रेनशॉ

जवाबों:

70

सी (जीसीसी), 41 39 बाइट्स

main(i){for(;++i<puts("**********"););}
— orlp
स्रोत
सी का क्या संस्करण?
— ज़ैबिस
@Zaibis gcc पर ठीक काम करता है: coliru.stacked-crooked.com/a/848cb22a00c35c29 ।
— orlp
4
अच्छा लग रहा है, अच्छा ol 'ANSI C.
— YSC
4
main(i){while(11-i++)puts("**********");}एक वैकल्पिक, एक ही लंबाई है।
— YSC
6
मुझे puts()(और प्रारंभिक मूल्य के i) से वापसी का चतुर उपयोग पसंद है ।
— टॉबी स्पाइट
65

बैश + कोरुटिल्स, 19 बाइट्स

मैं 'हाँ' का उपयोग करके बैश में सामान दोहराना पसंद करता हूँ।

yes **********|head

मैंने @ नील के सुझाव से 2 बाइट्स बचाए। लेकिन जब निर्देशिका जहां आप यह कमांड चला रहे हैं, उसमें केवल 'से शुरू होने वाली फाइलें नहीं होती हैं।' डॉट आपको तारों के *साथ संलग्न करने की आवश्यकता है "।

बैश + कोरुटिल्स, 21 बाइट्स

yes "**********"|head
— CousinCocaine
स्रोत
2
महान विचार का उपयोग करने के लिए yes। हम आमतौर पर ऐसे समाधानों को "बैश + कोर्यूटिल्स" के रूप में लेबल करते हैं।
— 14 अक्टूबर को मैनटवर्क
8
यह अच्छा है कि संयोगवश 10 पंक्तियों के लिए डिफ़ॉल्ट रूप से होता है head।
— डिजिटल ट्रॉमा
3
क्या आप यह मांग कर दो बाइट्स बचा सकते हैं कि वर्तमान निर्देशिका की कोई भी फाइल a से शुरू होनी चाहिए .?
— नील
@ नील, क्या आपकी टिप्पणी मेरे उत्तर के लिए उल्लेखित है? यदि हां, तो मुझे यह नहीं मिला :)
— CousinCocaine
1
आप yes \**********|headफ़ाइलों पर प्रतिबंध के बिना भी लिख सकते हैं ।
— फ्लोरियन एफ
50

विम, १३ im बाइट्स

5 बाइट्स @Lynn की बदौलत बची

qqi*␛9.o␛q9@q 


10i*␛Y9p

10i*␛10 बार डालें *, और Y9pलाइन को कॉपी करके 9 बार पेस्ट करें।

— TuxCrafting
स्रोत
8
10i*♥Y9pकाम करता है।
— लिन
1
वह पागल है vi।
— nbubis
मुझे लगता है कि आप टेक्स्ट संपादकों के लिए बाइट्स के बजाय कीस्ट्रोक्स की गिनती कर सकते हैं, जिसका मतलब है कि <ESC> छोटा होगा।
— एडिसन
1
क्यों ♥ और ␛ नहीं?
— सीएल।
1
मैंने yy9pखुद को इस्तेमाल किया होगा , लेकिन एक चरित्र को बचाने के लिए राजधानियों का उपयोग करके अच्छा काम किया है!
— जो जेड।
49

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

VT*T\*

TPyth में 10 है, Vabस्टेटमेंट b aटाइम निष्पादित करता \*है, तारांकन वर्ण स्थिर है, और *एक स्ट्रिंग को गुणा करना ( ) और एक पूर्णांक उस स्ट्रिंग n को दोहराता है। V10 पंक्तियों के साथ पाइथ के अंतर्निहित मुद्रण को मुद्रित किया जाता है।

— orlp
स्रोत
40

Hexagony, 37 35 34 31

10"+}(=${";<$<1}42/.0@_=<>\;>(_

विस्तारित:

   1 0 " +
  } ( = $ {
 " ; < $ < 1
} 4 2 / . 0 @
 _ = < > \ ;
  > ( _ . .
   . . . .

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

मूल रूप से सिर्फ दो छोरों के लिए दस से शून्य तक की गिनती होती है, जो आंतरिक लूप पर एक तारांकन प्रिंट करता है, और बाहरी लूप पर एक नई रेखा।

स्पष्टीकरण:

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

सबसे पहले, कोड पूरी तरह से रैखिक स्मृति आरंभीकरण चलाता है। कोड बाहर काम करता है होना करने के लिए: 10"+}42। यह देखने के लिए पास के किनारों की मेमोरी सेट करता है:

10 \ / 10
    |
   42

42 तारांकन वर्ण के लिए ASCII कोड है, और दो दसियों का उपयोग हमारे लूप काउंटर के रूप में किया जाएगा। ध्यान दें कि मेमोरी पॉइंटर वर्तमान में दो दहाई से दूर की ओर इशारा करता है, इसलिए पीछे की ओर बढ़ना हमें दसियों में से एक पर डाल देगा।

अगला, हम astersisk प्रिंटिंग लूप शुरू करते हैं। रैखिक, कोड की तरह दिखता है ;".._(:। यह एक तारांकन चिह्न को प्रिंट करता है, मेमोरी पॉइंटर को पीछे की ओर ले जाता है और बाईं ओर अंत में मूल्य को घटाता है। एक पुनरावृत्ति के बाद, स्मृति इस तरह दिखाई देगी:

10 \ / 9
    |
   42

फिर हम लूप की स्थिति को मारते हैं: नीचे-सबसे बाईं ओर >। यदि हम जिस बढ़त को घटाते हैं वह अभी भी सकारात्मक है तो हम चारों ओर उछलते हैं और {हमें वापस 42 पर ले जाने के लिए निष्पादित करते हैं। फिर हम एक को मारते हैं $और मुद्रण लूप की शुरुआत में वापस आ जाते हैं ;, को छोड़ कर <। यदि मान शून्य था, तो हम दूसरे लूप में जाते हैं।

बाहरी लूप हाल ही में शून्य मेमोरी एज को दस पर रीसेट करने से शुरू होता है (यह 10कोड में है, दक्षिण-पश्चिम में जा रहा है)। फिर, हम इस दस को ASCII वर्ण के रूप में प्रिंट करते हैं, जो एक नई पंक्ति है। इसके बाद, हम दूसरे मेमोरी एज पर जाते हैं और इसे {(घटाते हैं और फिर नोज के एक समूह में कितनी मात्रा में निष्पादित करते हैं =${_=:। अब इस लूप के एक पुनरावृत्ति के बाद, मेमोरी इस तरह दिखाई देगी:

 9 \ / 10
    |
   42

इस बार, स्मृति ऊपर की ओर नौ से ऊपर आरेख में भंडारण कर रही है। अगला हम निष्पादित करते हैं <जो बाहरी लूप के लिए लूप की स्थिति के रूप में कार्य करता है। यदि मूल्य गैर-शून्य था, तो हम कुछ दर्पणों के चारों ओर उछलते हैं, फिर "चलती दक्षिण-पश्चिम में षट्भुज के शीर्ष पर प्रवेश करने के बाद फिर से सार्थक निर्देशों को निष्पादित करना शुरू करते हैं । यह हमें 42 पर फिर से पीछे और बाईं ओर ले जाने का कारण बनता है, लेकिन अंदर की ओर का सामना करना पड़ रहा है। फिर =हमारी दिशा को फ़्लिप करता है, आंतरिक लूप को फिर से शुरू करने के लिए राज्य को ठीक से रीसेट करता है। यदि किनारे को शून्य पर सेट किया गया था, तो निर्देश सूचक थोड़ा रोमांच पर जाता है जो कार्यक्रम से बाहर निकलने तक कुछ भी नहीं करता है।

एडवेंचर इंस्ट्रक्टर पॉइंटर से शुरू होता है, जो उत्तर-पूर्व की ओर बढ़ते हुए, कार्डिनल दिशाओं की सुरक्षा की अवहेलना करता है। यह बहादुरी से एक दर्पण को अनदेखा करता है जो उसके विचलन ( /) के साथ जुड़ा होता है और वीरतापूर्वक एक ट्रम्पोलिन से छलांग लगाता है ($) दूसरे के घातक जाल को पूरी तरह से विकसित करना, पूरी तरह से समान ट्रैम्पोलिन। एकतरफा षट्भुज किनारों की शून्यता को देखते हुए, सूचक, एक पल के लिए लड़खड़ाए बिना, दो खाली किनारों को एक साथ जोड़ता है, वर्तमान किनारे को उनकी राशि पर सेट करता है: 0 (बढ़त वास्तव में पहले से शून्य थी, लेकिन सूचक को पसंद है विश्वास है कि यह बहुत महत्वपूर्ण था)। चूंकि किनारे शून्य है, सूचक सड़क में कांटे पर एक बाएं मोड़ बनाता है, एक रहस्यमय जंगल (हेक्सटन के) में चल रहा है। वहां, यह अपने आप को अव्यवस्थित, आगे और पीछे की ओर और आगे की ओर बढ़ता हुआ पाता है, जब तक कि यह स्मृति में उसी स्थान पर हवा नहीं उठाता जब तक यह शुरू हुआ। यह सोचते हुए कि समस्या यह होनी चाहिए कि वर्तमान धार पिछली बार शून्य पर सेट की गई थी, सूचक ने बहादुरी से पौधे लगाए1वर्तमान धार में। फिर, रईस पॉइंटर दूसरे रास्ते की जाँच करता है, एक के साथ रखी ... एक जाल! वर्तमान बढ़त कम हो गई है और शून्य पर वापस सेट है! पॉइंटर, घटनाओं के चौंकाने वाले मोड़ से घबराकर, वापस वर्तमान में नकारात्मक को स्थापित करने वाले जाल में ठोकर खाता है। संक्रमित, सूचक तुलनात्मक रूप से सुखद जंगल में लौटने का प्रयास करता है, केवल यह ध्यान देने के लिए कि चूंकि वर्तमान किनारे सकारात्मक नहीं है, रास्ते अभी तक फिर से स्थानांतरित हो गए हैं और सूचक खुद को एक गुफा में चलते हुए पाता है। और एक गुफा से मेरा मतलब है कि एक विशाल षट्भुज कीड़ा का मुंह। असहाय, सूचक अपनी मरणासन्न साँस के साथ कामुकता को शाप देता है। साथ ही, कार्यक्रम समाप्त होता है।

— FryAmTheEggman
स्रोत
मुझे उम्मीद है कि एक सूचक को निगलने के साथ कृमि ठीक था। उन चीजों से चोट लग सकती है ।
— जोफान
3
सबसे दिलचस्प लिखने के लिए +1 - केवल मैंने कभी पढ़ा हेक्सागोनी स्पष्टीकरण। मैं बहुत तनाव महसूस करता था जब किनारा कम हो गया था!
— जो
37

Emacs, 10 8 कीस्ट्रोक्स

F3 C-1 0 * ENTER F4 C-9 F4

व्याख्या

F3             Starts a macro recording
C-1 0 *        Apply 10 times command '*': prints 10 asterix'
ENTER          Insert new line
F4             Stops the macro record
C-9 F4         Apply 9 times the macro

दो कीस्ट्रोक्स को बचाने के लिए सीन के लिए धन्यवाद, C-udigitसाथ बदलने का सुझाव C-digit।

— YSC
स्रोत
9
+1, मैं हमेशा वोट दें पाठ संपादक जवाब (भले ही मैं खुद को एक vim पुरुष के और अधिक कर रहा हूँ) :)
— DJMcMayhem
1
यदि C-uकेवल एक कीस्ट्रोके के रूप में गिना जाता है, तो आप इसके बजाय और इसके बजाय C-1 C-0(या M-1 M-0) लिखकर दो स्ट्रोक काट सकते हैं । C-u 1 0C-9C-u 9
— शॉन
15
+1 क्योंकि आपको इसे लिखने के लिए emacs का उपयोग करके नुकसान उठाना पड़ा।
— Addison
1
वैकल्पिक रूप से (कुछ भी नहीं बचाता है) रेखा पुनरावृत्ति को मैक्रो के अंदर किया जा सकता है:F3 C-1 0 * ENTER C-1 0 F4
— जोनाथन कैरोल
@JonathanCarroll हाँ अगर हम 10 से अधिक लाइनें प्रिंट करना चाहते हैं तो बाइट्स को
— बचाएंगे
29

जेली , 7 बाइट्स

”*x⁵Ṅ9¡

क्या चल रहा है?

”*x⁵Ṅ9¡  - No arguments
”*       - character literal, *
  x      - multiply (dyadic operation)
   ⁵     - integer literal, 10 (we have now constructed the string '**********')
    Ṅ    - Print & linefeed (monadic operation)
     9   - integer literal, 9
      ¡  - Repeat n times (n is 9 as the first Ṅ is not a repeat)

इसे tryitonline पर टेस्ट करें

— जोनाथन एलन
स्रोत
9
मैं वास्तव में पसंद है Ṅ9¡।
— डेनिस
सूची संस्करण: ”*ẋ⁵Wẋ⁵।
— आउटगॉल्फ
@EriktheGolfer आपको Y"इस सटीक पाठ को प्रिंट करने के लिए" की आवश्यकता होगी
— जोनाथन एलन
@JonathanAllan यह अपने आप में एक सूची है, हालांकि। इसका अर्थ "इस सटीक पाठ को प्रिंट करना" नहीं है, लेकिन, यदि आप इस पर काम करना चाहते हैं, तो आप इसका उपयोग करेंगे।
— आउटगॉल्फ
26

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

,('*'*10)*10

10स्ट्रिंग गुणन का उपयोग करके लंबाई के तार के तार का निर्माण करता है। एनेक्स बनाने के लिए अल्पविराम में पार्स और फ़ीड में एनकैप्सुलेट करता है। हम उस तत्व से मिलकर 10-तत्व के सरणी का निर्माण करने के लिए सरणी गुणा का उपयोग करते हैं (अर्थात, तार के तार का 10-तत्व का सरणी)। यह पाइपलाइन पर छोड़ दिया गया है, और आउटपुट निहित है (चूंकि Write-Outputएक सरणी के लिए डिफ़ॉल्ट न्यूलाइन-अलग है, हमें यह मुफ्त में मिलता है - स्पष्टीकरण के लिए @ जॉय के लिए धन्यवाद)।

पुराना, 14 बाइट्स

0..9|%{'*'*10}

पूरा कार्यक्रम। से लूप्स 0के लिए 9एक के माध्यम से ForEach-Objectपाश |%{...}। प्रत्येक पुनरावृत्ति, हम एक 10स्ट्रिंग की लंबाई बनाने के लिए स्ट्रिंग गुणन का उपयोग करते हैं *। परिणामी तार को पाइप लाइन पर छोड़ दिया जाता है, और अंत में आउटपुट निहित है (चूंकि Write-Outputएक सरणी के लिए डिफ़ॉल्ट न्यूलाइन-अलग है, हम इसे मुफ्त में प्राप्त करते हैं - स्पष्टीकरण के लिए @ जॉय के लिए धन्यवाद)।

— AdmBorkBork
स्रोत
5
मुझे यह पसंद है, क्योंकि शक्तियां इतनी क्रिया प्राप्त कर सकती हैं। फिर भी यह सुरुचिपूर्ण और संक्षिप्त है।
— dwana
खैर, तकनीकी रूप से सरणी कभी भी एक के माध्यम से पारित नहीं होती है ToString, यह लिखने-आउटपुट करने के लिए तत्व द्वारा अनियंत्रित और पारित तत्व है। संदर्भों में जहां सरणी को एक स्ट्रिंग में परिवर्तित किया जाता है, आपको इसके तत्व अलग-अलग मिलते हैं।
— जॉय
@ जोई आह, निष्पक्ष, यह एक बेहतर तरीका है। मैं शब्दांकन (और मेरे उत्तर टेम्पलेट ;-)) को संपादित करूँगा।
— AdmBorkBork 14
1
मैं यहाँ पक्षपाती हो सकता हूँ क्योंकि मैं एक PowerShell कार्यान्वयन के साथ शामिल हूं इसलिए मुझे बहुत कुछ सीखना था कि वास्तव में इंटरप्रेटर के अंदर क्या होता है;)
— जॉय
25

वी , 7 बाइट्स

10é*10Ä

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

एक उत्तर के रूप में के बारे में सीधा हो सकता है।

स्पष्टीकरण:

10      "10 times:
  é*    "insert an asterisk
    10Ä "make 10 copies of the current line

गैर-प्रतिस्पर्धी संस्करण (5 बाइट्स):

10O±*

स्पष्टीकरण:

10O     " Insert the following on the next ten lines:
   ±    "   10 copies of
    *   "   an asterisk

बग के कारण चुनौती पोस्ट किए जाने पर यह काम नहीं करता था।

— DJMcMayhem
स्रोत
पॉइंट ऑफ़ ऑर्डर: é और Ä मल्टीबाइट कैरेक्टर हैं (कम से कम यूटीएफ -8 में, जैसा कि आपने उन्हें यहां दिया है) इसलिए यह प्रोग्राम 9 बाइट्स लंबा है।
— लूट
6
@rob वे यहाँ utf-8 में एन्कोडेड हैं, क्योंकि यह ब्राउज़र के काम करने का तरीका है। वी "लैटिन 1" एन्कोडिंग का उपयोग करता है, जहां वे E9और C4क्रमशः।
— DJMcMayhem
21

जेलिफ़िश , 12 10 बाइट्स

2 बाइट बचाने के लिए ज़गरब को धन्यवाद।

P$'*
 &;10

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

व्याख्या

अधिक पारंपरिक अंकन का उपयोग करते हुए, यह कार्यक्रम निम्नलिखित अभिव्यक्ति का प्रतिनिधित्व करता है:

P( $( &;(10), '* ) )

&;एक एकल मूल्य लेता है और दो बार उस मूल्य के साथ एक जोड़ी बनाता है, इसलिए &;(10)हमें देता है [10 10]। फिर $पुन: आकार दिया जाता है जो तारांकन के 10x10 ग्रिड बनाता है। अंत में, Pसरणी को "मैट्रिक्स प्रारूप" में प्रिंट करता है जो प्रत्येक स्ट्रिंग को अपनी लाइन पर प्रिंट करता है।

— मार्टिन एंडर
स्रोत
20

HTML और CSS, 104 60 बाइट्स

p::after{content:"**********"
<p><p><p><p><p><p><p><p><p><p>
स्निपेट का विस्तार करें

मैं अनिश्चित हूँ अगर बाइट की गिनती सही है (जैसा कि मैं <style>सीएसएस के लिए टैग नहीं गिन रहा हूं । यदि मुझे HTML प्रीप्रोसेसर का उपयोग किया गया है, तो HTML को भी छोटा किया जा सकता है, लेकिन अगर मैं नियम तोड़ रहा हूं तो मैं अनिश्चित हूं।

मैनटवर्क और बिजनेस कैट को धन्यवाद।

36 बाइट्स की मेरी जेड प्रविष्टि देखें

— ʰᵈˑ
स्रोत
आप स्वयं समापन को छोड़ सकते हैं /और एक ही पंक्ति में सभी टैग लिख सकते हैं। लेकिन टैग को बदलने के लिए बेहतर है <p>क्योंकि यह जोड़ने की जरूरत है भले ही यह छोटा है p{margin:0}।
— मैनटवर्क
2
यह वैध सीएसएस नहीं है। आपको समापन ब्रैकेट की आवश्यकता है!
— रिचर्ड हैमिल्टन
25
@ रीचर्ड हैमिल्टन वैध सीएसएस और कामकाजी सीएसएस एक ही चीज नहीं हैं
— भूमिगत
1
@ क्लेमेंटनर्मा इसके बाद किसी को कोड क्यों डालना चाहिए?
— आउटगॉल्फ
2
आप अंतिम >मुझे विश्वास है कि छोड़ सकते हैं
— 12M2121
16

अजगर 2, 22 21 बाइट्स

print('*'*10+'\n')*10
— shooqie
स्रोत
print(("*"*10+'\n')*10)मेरे लिए काम किया।
— पाईपी
6
@ डिंपी यही वजह है कि आप आमतौर पर पायथन 2 में गोल्फिंग से बेहतर हैं - आपको कॉल करते समय कोष्ठक की आवश्यकता नहीं है print।
— शुकी
@shooqie आप Python2 के उपयोग से Python3 समाधान को नहीं हरा सकते हैं। Python2 और Python3 अलग-अलग भाषाएं हैं। तुम भी Python2 समाधान की तुलना Pyth जैसी विशेष गोल्फ भाषा से नहीं कर सकते।
— एल्फ
16

MATLAB, 14 बाइट्स

repmat('*',10)
— PieCot
स्रोत
मेरे पास इसका परीक्षण करने के लिए MATLAB नहीं है, इसलिए मैं अनिश्चित हूं यदि यह *s के बीच रिक्त स्थान है ।
— आउटगॉल्फ
@EriktheGolfer स्पष्ट रूप से नहीं :)
— PieCot
matमैट्रिक्स का सुझाव देता है, इसीलिए मैंने पूछा।
— एग्री द आउटगोलर
2
@EriktheGolfer मुझे माफ करना, मैं अशिष्ट था। मैट, वास्तव में, एक मैट्रिक्स को संदर्भित करता है, लेकिन इस मामले में चार का एक मैट्रिक्स है, जो स्ट्रिंग्स का एक सरणी है (प्रत्येक पंक्ति एक स्ट्रिंग की तरह है)। तो, एक ही पंक्ति के तत्वों के बीच रिक्त स्थान के बिना, आउटपुट मैट्रिक्स को पंक्ति के लिए एक पंक्ति मुद्रित किया जाता है।
— 15
16

एपीएल , 9 बाइट्स

कभी बनाए गए सभी एपीएल पर काम करता है।

10 10⍴'*'

10 10 दस पंक्तियाँ और दस स्तंभ

⍴ चक्रीय रूप से आर एपटिंग

'*' एक तारा

TryAPL ऑनलाइन!

— एडम
स्रोत
यह ध्यान देने योग्य है कि यह समाधान Dyalog-specific नहीं है; यह GNU APL के साथ भी काम करता है।
— 1:67 पर Arc676
3
@ Arc676 सच। वास्तव में, यह अब तक बने सभी एपीएल पर काम करता है।
— आदम
argh, मैं सिर्फ एक और बाइट की जरूरत है ... मैं लगभग "प्रारूप" चाल के साथ आप को हराया:∘.⊢⍨⍕⍨,⍨5
— ngn
@ बहुत बढ़िया है!
— आदम
14

जावा 7, 63 बाइट्स

void f(){for(int i=0;i++<10;)System.out.println("**********");}

लातों के लिए। मैं इसे छोटा करने के लिए कोई तरकीब नहीं खोज सकता। 100-लूप के लिए तर्क जोड़ने की कोशिश करना या मुद्रण के बजाय एक स्ट्रिंग वापस करना बस खराब हो जाता है।

— Geobits
स्रोत
1
यदि आप iएक वर्ग चर के रूप में घोषित करते हैं, तो आप इसे एक बाइट से दाढ़ी कर सकते हैं (यह चूक 0):int i;void f(){for(;i++<10;)System.out.println("**********");}
— shooqie
1
जब तक कि मैं फंक्शन में कहीं नहीं करता, बचत को नकारते हुए पुन: प्रयोज्यता को तोड़ता i=0।
— जियोबिट्स
3
+1 लगता है कि आप वास्तव में सही हैं कि यह सबसे छोटा है .. पुनरावर्ती 65 बाइट्स है int i=10;void f(){System.out.println("**********");if(i-->0)g();}:; एक से एक पुनरावर्ती 67 बाइट्स हैं int i=99;void f(){System.out.print(i%10<1?"*\n":"*");if(i-->0)g();}:; स्ट्रिंग-निर्माता के साथ स्ट्रिंग-कंस्ट्रक्टर का उपयोग करना 82 बाइट्स है void g(){System.out.print(new String(new char[10]).replace("\0","**********\n"));}:; और एक String.format 81 बाइट्स है void g(){System.out.print(String.format("%010d",0).replace("0","**********\n"));}:। आह ठीक है, हमने कोशिश की। ;)
— केविन क्रूज़सेन
2
लेकिन क्या यह वर्ग की घोषणा को जोड़ने के बिना गिनती करता है? सबसे छोटा जावा 7 पूर्ण कार्यक्रम क्या है जो यह कर सकता है?
— jsbueno 12
1
आपको आयात विवरण को गिनना होगा, इसलिए यह यहां बचत के लिए काम नहीं करेगा।
— जियोबिट्स
14

रूबी, 15 अक्षर

puts [?**10]*10

नमूना रन:

bash-4.3$ ruby -e 'puts [?**10]*10'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********
— आदमी काम पर है
स्रोत
क्या आप समझा सकते हैं ?**10? यह वास्तव में दस तारांकनों का एक तार पैदा करता है, लेकिन मैं स्पष्ट नहीं हूँ कि कैसे ...
— erich2k8
3
?चरित्र शाब्दिक अंकन तो है, ?* == '*'। 2nd *है String.*विधि हां, तो ?**10 == '*'.*(10)।
— manatwork
डर मुझे अभी भी समझ में नहीं आता क्यों ? किसी भी चीज़ का शाब्दिक अंकन होता है, लेकिन शायद कुछ सवाल अनुत्तरित रह जाते हैं। ;)
— erich2k8
क्षमा करें, मुझे इस पर कोई संदर्भ नहीं मिल रहा है। बस रूबी सिंटेक्स है, जो अनुमति देता है स्ट्रिंग के 1 अक्षर लंबे होने की स्थिति में विभिन्न स्ट्रिंग शाब्दिक अधिसूचनाओं को प्लस एक की : ?निशान के समापन जोड़ी की आवश्यकता के बिना चरित्र द्वारा पीछा किया जाने वाला ?निशान।
— मैनटवर्क
1
मैंने इसे यहाँ संदर्भ में पाया: ruby-doc.org/core-2.3.0/doc/syntax/literals_rdoc.html There is also a character literal notation to represent single character strings, which syntax is a question mark (?) followed by a single character or escape sequence that corresponds to a single codepoint in the script encoding:
— erich2k8
13

नोटपैड, 34 31 कीस्ट्रोक्स

**********
^A^C↓^V^A^C↓^V^V^V^V

^ Ctrl को दर्शाता है- <निम्नलिखित वर्ण> कीपर्स, ↓ up क्रमशः ऊपर और नीचे कीज हैं।

3 सहेजे गए कीस्ट्रोक्स के लिए क्रिप्टो को सहारा।

— मीका डोंब्रोव्स्की
स्रोत
2
इसे गिनने के लिए आपको कीस्ट्रोक्स का उपयोग करना चाहिए।
— लीक नून
1
वह Shift + अप है। Ctrl + Up कुछ और है।
— नील
1
31 कीस्ट्रोक्स**********↵^A^C↓^V^A^C↓^V^V^V^V
— क्रिप्टो
1
26 कीस्ट्रोक्स*****^A^C^V^V↵^A^C^V^A^C^V^V^V^V^V
— एंडी
5
23 कीस्ट्रोक्स**^A^C^V^V^V^V^V↵^A^C^V^V^A^C^V^V^V^V^V
— एंडी
13

इमोजीकोड , 54 बाइट्स

🏁🍇🔂i⏩0 10🍇😀🔤**********🔤🍉🍉

स्पष्टीकरण:

🏁🍇                        👴 The beginning of program.
    🔂 i ⏩ 0 10 🍇          👵 This is called a "range".
                          It basically starts with i=0 and increments until i=10, then exits. 👵
        😀 🔤**********🔤    👵 😀 is printing class.
                          The 🔤s make the characters they surround string literals. 👵
    🍉                     👴 End of range
🍉                         👴 End of program
— betseg
स्रोत
2
मैं 54 utf-8 बाइट्स गिनता हूं।
— कॉनर ओ'ब्रायन
यह भाषा वेंड्स 7 से नफरत करती है ...
— जॉन ड्वोरक
10

05AB1E, 7 बाइट्स

TF'*T×,

व्याख्या

TF      # 10 times do:
  '*T×  # repeat asterisk 10 times
      , # print with newline

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

— Emigna
स्रोत
1
т'*×Tô»एक और पूरी तरह से अलग एक योग्य है।
— मैजिक ऑक्टोपस Urn
TLú'*ζ»जिप-फिलर का उपयोग करना एक और विचार था ... हालांकि एक बुरा।
— मैजिक ऑक्टोपस Urn
10

आर, 27 29 बाइट्स

cat(rep('\r**********\n',10))

एक वैकल्पिक उत्तर (34 बाइट्स) है: cat(rep('**********',10),sep='\n')

— मैमी
स्रोत
यह पहले को छोड़कर सभी लाइनों की शुरुआत में एक अतिरिक्त स्थान जोड़ता है ( यहां देखें )।
— प्लेनैपस
धन्यवाद, यह जोड़ने का काम करता है \r।
— मामी
1
एक अन्य विकल्प, बहुत सारे (37) बाइट्स: cat(matrix('*',10,10),fill=10,sep='') आर-फिडल
— जोनाथन कैरोल
एक अन्य विकल्प, 29 बाइट्स भी:write(rep("*",100),"",10,,"")
— Giuseppe
1
और write(rep("**",50),1,5,,"")27 बाइट्स है और पहली गाड़ी वापसी से बचा जाता है।
— जे।
9

PHP, 32 बाइट्स

for(;$i++<10;)echo"**********
";

(संस्करण 32 बाइट्स - के साथ लिखा गया था echo)

<?=str_repeat("**********
",10);

(संस्करण 33 बाइट्स)

<?=str_pad("",110,"**********
");

(संस्करण 33 बाइट्स)

for(;$i++<110;)echo$i%11?"*":"
";

(संस्करण 35 बाइट्स)

for(;$i++<10;)printf("%'*10s
",'');

(संस्करण 38 बाइट्स)

<?=($a=str_repeat)($a("*",10)."
",10);
— क्रिप्टो
स्रोत
3
दूसरे को 32 बाइट्स के लिए गोल्फ दिया जा सकता है :<?=str_repeat("**********↵",10);
— सम्मिलित करें
1
जैसा कि आपके पास पहले से ही विकल्पों का एक अच्छा संग्रह है, यहाँ मज़े के लिए एक और है: echo chunk_split(str_repeat("*",100),10);अब तक का सबसे लंबा, मेरी दृष्टि में यह इसे करने का PHP तरीका है।
— मैनटवर्क
: विन-1252 एन्कोडिंग के साथ एक बाइट कम किया जा सकता है for(;++$i<111;)echo$i%11?~Õ:~õ;याfor(;++$i<11;)echo~ÕÕÕÕÕÕÕÕÕÕõ;
— aross
33 बाइट्स के लिए एक और मोडुलो वेरिएंट for(;$i++<110;)echo"*↵"[$i%11<1];:। और उस संग्रह में एक 37 बाइट्स समाधान जोड़ने के लिए for(;$i++<110;)echo chr($i%11?42:10);:।
— टाइटस
8

ब्रेनफक, 46 43 बाइट्स

+[[---<]+[-->]<]<<[--<<++..........-->>>.<]

इसे ऑनलाइन आज़माएं!एक टेप के साथ दुभाषिया की आवश्यकता होती है जो बाईं ओर खुला होता है और इसमें 8-बिट कोशिकाएं होती हैं।

इस कार्यक्रम का पहला भाग +[[---<]+[-->]<]टेप सेट करता है जैसे:

[255, 250, 245, ... 15, 10, 5, 0, 250, 240, 230, ..., 40, 30, 20, 10, 0]
                                                                      ^

यह आउटपुट तारांकन के लिए 40 ( *, ASCII 42), 20 को लूप काउंटर के रूप में उपयोग करने के लिए, और 10 को न्यूटलाइन आउटपुट के लिए उपयोग करने के लिए देता है।

— Sp3000
स्रोत
7

जावास्क्रिप्ट (ईएस 6), 37 बाइट्स

console.log(`**********
`.repeat(10))

सीधा सा जवाब।

— ASCII-केवल
स्रोत
5
कठबोली आप का उपयोग करके 6 बचा सकता है alert?
— केविन एल
1
संभवतः आप शीर्षक को हटाकर console.log()और निर्दिष्ट करके 13 बाइट्स बचा सकते हैं REPL।
— पैट्रिक रॉबर्ट्स
6

चेडर, 21 20 बाइट्स

print('*'*10+'
')*10

फिर भी एक और सीधा जवाब।

— ASCII-केवल
स्रोत
4
1 बाइट बचाने के लिए एक शाब्दिक न्यूलाइन का उपयोग करें
— लीके नून
2
->हो सकता है कि यह प्रिंट के बजाय एक फ़ंक्शन का उपयोग करें ?
— 19
6

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

putStr$[0..9]>>"**********\n"

<list1> >> <list2>की (length <list1>)प्रतियां बनाता है <list2>।

— nimi
स्रोत
6

आर, 35 33 32 बाइट्स

Ô R, आप कभी-कभी बहुत अधिक क्रियाशील होते हैं ।

for(i in 1:10)cat(rep("*",10),"\n")

दिलचस्प बात यह है कि catफ़ंक्शन का कोई मूल्य नहीं है (यह NULLSTDOUT को प्रदान करता है), इसलिए आप सोमेथिग की तरह नहीं कर सकते हैं rep(cat(rep))), जो मजेदार हो सकता है!

संपादित करें:
@LeakyNun, -2 बाइट्स द्वारा प्रस्तावित नया समाधान ।

for(i in 1:10)cat("**********\n")

संपादित करें: इसे केवल 1 बाइट द्वारा, @ user5957401 द्वारा छोटा किया जा रहा है

for(i in 0:9)cat("**********\n")
— फ़्रेडरिक
स्रोत
3
for(i in 1:10)"**********\n"
— लीक नून
1
@LeakyNun: सादगी की कुंजी है! मैं catफिर भी, अन्यथा यह कुछ भी नहीं पैदा करता था।
— Frédéric
cat(rep("**********\n",10))
— लीकी नून
@LeakyNun यह वांछित उत्पादन नहीं करेगा: यहाँ देखें । डिफ़ॉल्ट विभाजक catएक स्थान है, इसलिए यह आउटपुट है।
— प्लेनैपस
5

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

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है। अग्रणी लाइनफीड महत्वपूर्ण है।


10$**
.
$_¶

पहला चरण दस तारांकनों की एक स्ट्रिंग लिखता है, दूसरा चरण प्रत्येक तार को पूरे स्ट्रिंग और एक लाइनफ़ीड के साथ बदलता है। यह दो अनुगामी रेखाओं को प्रिंट करता है।

— मार्टिन एंडर
स्रोत
5

जे , १० 9 बाइट्स

1 बाइट @ Adám को धन्यवाद।

10 10$'*'

ऑनलाइन दुभाषिया ।

व्याख्या

10 10ऑपरेटर को आयाम निर्दिष्ट करता है $जो निर्दिष्ट आयामों के साथ एक सरणी बनाता है।

— लीक नन
स्रोत
1
इसके अलावा 9 बाइट्स:'*'$~,~10
— Conor O'Brien
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.