कोड-गोल्फ एस्की आर्ट का आसान तरीका!

Question

कार्य:

इस साइट पर बहुत सारे उत्तर हैं जो इसी की तरह एससीआई कला में व्यवस्थित हैं । आमतौर पर व्यवस्था मैन्युअल रूप से की जाती है, लेकिन क्या इससे कोई कार्यक्रम मदद नहीं करेगा? :)

आपका कार्यक्रम 3 इनपुट लेगा:

• एक एकल पंक्ति के रूप में कोड
• पैटर्न में लाइनों की संख्या (यदि आवश्यक न हो तो छोड़ा जा सकता है)
• पैटर्न खुद, *एस या एक और चार के रूप में

नियम:

• आपको एक प्रोग्राम (एक फ़ंक्शन नहीं) लिखना होगा जो स्टड से पढ़ता है
• पाठ को प्रति पंक्ति बाएँ-से-दाएँ रखा गया है
• यदि पैटर्न को भरने के लिए पर्याप्त पाठ नहीं है, .तो शेष स्थानों में एस डालें
• यदि पैटर्न को भरने के लिए बहुत अधिक पाठ है, तो आउटपुट के बाद इसे प्रिंट करें
• कोड-गोल्फ , इसलिए सबसे छोटा कोड, बाइट्स में जीतता है

नमूना रन:

इनपुट (सटीक फ़िट परीक्षण) :

qwertyuiopasdfghjklzxcvbnm
4
***** * ***
*   * * *
*   * * *
***** * ***

आउटपुट :

qwert y uio
p   a s d
f   g h j
klzxc v bnm

इनपुट (अतिरिक्त वर्ण परीक्षण) :

qwertyuiopasdfghjklzxcvbnm12345
4
***** * ***
*   * * *
*   * * *
***** * ***

आउटपुट :

qwert y uio
p   a s d
f   g h j
klzxc v bnm
12345

इनपुट (अपर्याप्त वर्ण परीक्षण) :

qwertyuiopasdfg
4
***** * ***
*   * * *
*   * * *
***** * ***

आउटपुट :

qwert y uio
p   a s d
f   g . .
..... . ...

Comments

कार्यक्रम के शब्दार्थ को बदलने के बिना रिक्त स्थान और नई सूचियों को डालने की अनुमति कहां है, इस बारे में क्या धारणाएं बनाई जानी चाहिए?

— पीटर टेलर

@PeterTaylor ऐसा लगता है कि कोड रखने / अलग करने के लिए कोई लीव नहीं है, इसलिए मुझे लगता है कि शब्दार्थ को अनदेखा कर दिया गया है?

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

क्या "छोड़े जा सकते हैं" और "या एक और चर" का मतलब है कि हम जिस चीज़ के लिए स्वतंत्र हैं, उसे कहते हैं, निर्दिष्ट करें कि पंक्तियों की संख्या को छोड़ दिया जाना चाहिए और यह कि तारांकन द्वारा प्रतिस्थापित किया जाना चाहिए, कहते हैं, Xहमारे लिए काम करने के लिए कार्यक्रम?

— इल्मरी करोनन

@ बकुरीउ मैं आपकी टिप्पणी नहीं समझता। यदि आप ASCII में एक कार्यक्रम लिखते हैं, तो प्रत्येक वर्ण एक बाइट है। यदि आप UTF-32 में लिखते हैं, तो प्रत्येक वर्ण 4 बाइट्स है। बाइट्स में सबसे छोटा कोड , वर्ण नहीं, वर्तमान कल्पना के अनुसार जीतता है। ऐसा लगता है कि आप एन्कोडिंग एक आवश्यकता बनना चाहते हैं, लेकिन मुझे नहीं लगता कि यह क्यों आवश्यक है। क्या मुझे आपकी टिप्पणी गलत लगी?

— 14'15

कुछ नियमों को याद रखने वाले कुछ उत्तरों के आधार पर, मैंने दो उदाहरण जोड़े हैं और अतिरिक्त स्पष्टता के लिए नियम ब्लॉक के नीचे पूरे उदाहरण ब्लॉक को स्थानांतरित किया है।

— विस्कह

Answer 1

GolfScript, 30 अक्षर

n/(\(;n*'*'/{@.!'.'*+([]+@+}*\

ऑनलाइन चलाएं ।

उदाहरण:

> qwertyuiopasdfghjklzxcvbnm
> 4
> ***** * ***
> *   * * *
> *   * * *
> ***** * ***

qwert y uio
p   a s d
f   g h j
klzxc v bnm

> qwertyuiopasdfghjklzxcvbnm
> 1
> ***** * ***

qwert y uio
pasdfghjklzxcvbnm

> qwerty
> 2
> ***** * ***
> *   * * *

qwert y ...
.   . . .

Answer 2

पर्ल 6: 60 अक्षर EDIT : 38 अंक (नीचे देखें)

  #C#O     D#E#G#O       #L#
#F    #.#S#       T#A#C#K
  get\     .subst(       "*"
,{    shift       BEGIN [
  get\     .comb,\       "."
xx    * ]},       :g)\ .\
  say\     xx get\       ()\
#E    #X#C#       H#A#N#G
  #E#.     #C#O#M#       #!#

यदि आप मेरे भयानक कला कौशल की सराहना नहीं करते हैं, तो यहां गोल्फ है:

get.subst("*",{shift BEGIN [get.comb,"."xx*]},:g).say xx get

यह मूल्यांकन समय के साथ अजीब बातें करता है।

सबसे पहले, BEGINकीवर्ड [get.comb, "." xx *]को पहले "कोड" बनाने वाले वर्णों की सूची को सरणी में डालते हुए मूल्यांकन किया जाता है, इसके बाद अनंत राशि होती है "."।

इसके बाद, getअंत में मूल्यांकन किया जाता है, ASCII कला टेम्पलेट की लाइनों की संख्या प्राप्त करना। xxऑपरेटर कार्यक्रम के पहले भाग इस कई बार दोहराया जाता है। यह अधिक समझ में आता है जब आपको एहसास होता code() xx count()है कि मूल रूप से चीनी के लिए code() for 1..count(): count()पहले मूल्यांकन किया जाना चाहिए।

अंत में, getकार्यक्रम की शुरुआत में ASCII कला टेम्पलेट की एक पंक्ति मिलती है और हर "*"चीज से पहले किए गए सरणी की शुरुआत से हटकर एक मान के साथ हर विकल्प होता है ( {shift BEGIN …})।

संपादित करें:

37 वर्णों तक नीचे पहुंचा, और कमांड लाइन स्विच के लिए एक:

perl6 -pe's:g[\*]=shift BEGIN [get.comb,"."xx*]'

यह मूल के समान अवधारणा है, -pप्रत्येक लाइन पर स्विच करने वाला स्विच ( BEGIN"कोड" में पढ़े जाने के बाद ), और *इसे प्रिंट करने से पहले "कोड" से अगले अक्षर के साथ सभी को प्रतिस्थापित करना। इसके लिए इनपुट प्रारूप में प्रारूप की लाइनों की संख्या शामिल नहीं होनी चाहिए।

Answer 3

रूबी 2.0, 53 ५२ अक्षर

c=gets.chop
$><<gets($n).gsub(?*){c.slice!(0)||?.}+c

युक्ति के अनुसार, 'लाइनों की संख्या' का उपयोग नहीं करता है।

उदाहरण रन:

qwertyuiopasd
***** * ***
*   * * *
*   * * *
***** * ***

आउटपुट:

qwert y uio
p   a s d
.   . . .
..... . ...

Comments

./ascii.rb: line 2: syntax error near unexpected token `(' ./ascii.rb: line 2: `puts gets($n).gsub(?*){c.slice!(0)||?.},c'

— नहीं कि चार्ल्स

@ मुझे लगता है कि रूबी के किसी भी संस्करण में मैंने वह त्रुटि नहीं पाई है जो मैंने स्थापित की है। यहाँ IDEONE पर कोड चल रहा है: ideone.com/3HG3Fb

— पॉल प्रेस्टिज

अजीब। IDEONE ने ठीक काम किया। वैसे भी, आप की जगह एक चार (स्थान) को बचा सकता है puts के साथ $><<और बदलते ,एक करने के लिए अंत में+

— ऐसा नहीं है कि चार्ल्स

@Charles अच्छा कॉल। धन्यवाद!

— पॉल प्रेस्टिज

Answer 4

पॉवरशेल , 63 86 83 82 बाइट्स

+20 बाइट्स धन्यवाद @Veskah

param($s,$p)-join($p|% *ht($s|% Le*)'*'|% t*y|%{if($_-eq42){$_=$s[$i++]}"$_."[0]})

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

कम गोल्फ वाला:

param($string,$pattern)

$chars = $pattern |
    % PadRight ($string|% Length) '*' |
    % toCharArray |
    % {
        if($_-eq42){$_=$string[$i++]}    # $_ can become $null
        "$_."[0]                         # $_ or '.' if $_ is $null
    }
-join($chars)

Answer 5

जाप , 18 बाइट्स

sVè-)iVr-@t°J1 ª'.

कोशिश करो

Comments

sVl)iVr-@t°J1 ª'.17 के लिए काम करता है

— अज्ञानता

@EododimentofIgnorance, जो 4 के नियम पर विफल होगा।

— Shaggy

Answer 6

टी-एसक्यूएल, 142 बाइट्स

@ यह इनपुट टेक्स्ट है

@ पैटर्न है

DECLARE @h varchar(max)='qwertyuiopasdfg'
DECLARE @ varchar(max)='
***** * ***
*   * * *
*   * * *
***** * ***'

WHILE @ like'%*'SELECT @=left(@,charindex('*',@)-1)+left(@h+'.',1)+stuff(@,1,charindex('*',@),''),@h=substring(@h,2,999)PRINT
concat(@,'
'+@h)

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

Answer 7

पर्ल ५ -plF , 51 बाइट्स

$_=join'',<>;s/\*/@F?shift@F:'.'/ge;$\=$/.join'',@F

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

Comments

आप सही हे; मुझे वह आवश्यकता याद आ गई। यह अब तय हो गया है।

— Xcali

Answer 8

जावास्क्रिप्ट - 199

text="qwertyuiopasdfghjklzxcvbnm";
pattern="***** * ***\n*   * * *\n*   * * *\n***** * ***";

function p(a,c){z=c.length,y=a.length,x=0;for(i=z;i-->0;)if(c[i]=="*")x+=1;if(x-y>0)for(i=x-y;i-->0;)a+=".";for(;i++<x;)c=c.replace(new RegExp("[*]"),a[i]);console.log(c);console.log(a.substring(x))}

p(text,pattern);

पाठ इनपुट में अतिरिक्त वर्णों को आउटपुट करता है यदि पैटर्न में उपयोग नहीं किया जाता है, तो गद्देदार "" का उपयोग करता है। अगर पर्याप्त नहीं है।

संपादित करें: पाठ और पैटर्न को स्वीकार करने वाले एक फ़ंक्शन के रूप में संशोधित

Comments

अच्छा ... लेकिन यह हार्ड-कोडित इनपुट का उपयोग करता है।

— TheDoctor

मुझे यकीन नहीं था कि कैसे जेएस से स्टड को संभालना है, खासकर नईलाइन्स के साथ। सुझाव?

— मैट

@ मैट नोड? मकड़ीनुमा बन्दर?

— नहीं कि चार्ल्स

शायद इसे एक समारोह बना ...

— TheDoctor

136:function p(a,c){x=c.split(s='*').length-1;for(i=x-a.length;i--;)a+='.';for(;i++<x;)c=c.replace(s,a[i]);console.log(c+'\n'+a.substring(x))}

— माइकल एम।

Answer 9

जावास्क्रिप्ट (ईएस 6) - 96 87

r=(c,p)=>{c=0+c;console.log(p.replace(/\*/g,t=>(c=c.substr(1),c[0]||'.'))+c.substr(1))}

नोट: ओपी द्वारा सुझाए गए अनुसार , मैं एक फ़ंक्शन का उपयोग कर रहा हूं। लेकिन अगर इसके लिए एक कार्यक्रम की आवश्यकता है, तो यहां 93 वर्णों का समाधान है ।

c=0+(x=prompt)();p=x();console.log(p.replace(/\*/g,t=>(c=c.substr(1),c[0]||'.'))+c.substr(1))

EDIT1: प्रमुख परिवर्तन, मुझे नहीं पता कि मुझे पहली बार यह एहसास क्यों नहीं हुआ: P सेव्ड 40 चार्ट्स।

---

उपयोग :

// r(code, pattern)
r("qwertyuiopasdfghjklzxcvbnm", "***** * ***\n*   * * *\n*   * * *\n***** * ***\n** ** **)

---

टेस्ट इनपुट : (कल्पना के अनुसार बिना वैकल्पिक विकल्प के)

qwertyuiopasdfghjklzxcvbnm
***** * ***
*   * * *
*   * * *
***** * ***
** ** **

आउटपुट :

qwert y uio
p   a s d
f   g h j
klzxc v bnm
.. .. ..      // not much text was there to fill *s - replaced with dots as per spec

---

अ-कोड कोड :

function run(code, pattern){
  code = "0" + code;  // prepend a zero; useful for the substring operation ahead

  pattern = pattern.replace(/\*/g, function(){  // replace the dots
    // by removing the first letter of code
    // and replacing dot with the first-letter of leftover code 
    // and if it isn't there (code finished)
    // return a dot

    code = code.substr(1); 
    return c[0] || '.';
  });
  }

  // after this operation; code contains the last letter of the org. code

  console.log(  p +  // the pattern has now code
                "\n" +   // and a newline
                c.substr(1) // if there is more than one letter of code left; display it
             );
}

---

उपयोगकर्ताओं के किसी भी सुझाव को सुनना बहुत अच्छा होगा :)

Answer 10

पर्ल, 70 अक्षर

@_=split'',<>=~s/\n//r;<>;print/\*/?shift@_||'.':$_ for map{split''}<>

या, सीमा जांच के बिना, 56 वर्ण

@_=split'',<>;<>;print/\*/?shift@_:$_ for map{split''}<>

ध्यान दें, यह कोड कल्पना के अनुसार दूसरी पंक्ति का उपयोग नहीं कर रहा है, और इसे तीन वर्णों से छोटा किया जा सकता है <>;

Answer 11

दे घुमा के, 166 156 111 106

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

read -n999 -d/ i p
while [[ $p =~ @ && -n $i ]];do
p="${p/@/${i:0:1}}"
i=${i:1}
done
tr @ .<<<"$p"
echo $i

चेतावनी: यह प्रोग्राम एक फ़ाइल का उपयोग करता है जिसे कहा जाता है p। प्रोग्राम को निष्पादित करने के बाद, हटाएं p- यह प्रोग्राम को दूसरी बार आपके द्वारा चलाए जाने पर भ्रमित करेगा।

यहां ज्यादातर काम इनके द्वारा किया जाता है

p="${p/@/${i:0:1}}"
i=${i:1}

पहली पंक्ति @कोड के पहले चरित्र के साथ कला में पहले स्थानापन्न करती है । दूसरी पंक्ति कोड के पहले वर्ण को हटा देती है।

यदि आकृति को भरने के लिए पर्याप्त कोड नहीं है, तो मुख्य एएससीआई आर्ट आउटपुट द्वारा एक नई रेखा मुद्रित की जाती है echo $i।

Answer 12

C, 98 , 91 वर्ण

यहां 100 अक्षरों के नीचे एक बहुत सीधा-सीधा सी समाधान है। यह लाइन काउंट इनपुट का उपयोग नहीं करता है। (एक दूसरा अनावश्यक हो जाता है () की आवश्यकता होगी)।

char b[999],*s;c;main(){gets(s=b);while(~(c=getchar()))putchar(c^42?c:*s?*s++:46);puts(s);}

ungolfed:

char b[999],*s;c;
main(){
    gets(s=b);
    while(~(c=getchar()))
        putchar(c^42?c:*s?*s++:46);
    puts(s);
}

Comments

आप 7 बाइट्स को बचाने के puts(s)बजाय उपयोग कर सकते हैं printf("%s",s)।

— nyuszika7h

@ nyuszika7h धन्यवाद! लेकिन मुझे नहीं पता कि क्या अतिरिक्त \nसमस्या है।

— मार्केफिएंट

Answer 13

पायथन 2.7, 165 155 150 138 119 अक्षर

ठीक है, बहुत ज्यादा, लेकिन मुझे लगता है कि यह पायथन के साथ करने का सबसे कठिन तरीका है।

import sys
r=raw_input
l=list(r())
w=sys.stdout.write
for c in"\n".join([r()for _ in[1]*input()]):w(c=='*'and(l and l.pop(0)or'.')or c)
w("".join(l))

संपादित करें: कम कार्यात्मक बाइट्स के साथ नए कार्यात्मक 1.0.1 संस्करण:

Edit2: map(r,['']*input()) इसके बजाय [r()for _ in[1]*input()]अप्रयुक्त आयात को हटा दिया गया है

Edit3: एक चरित्र '>'*input()को ['']*input()बचाने और पैटर्न के लिए शीघ्र चरित्र जोड़ने के बजाय :)

r=raw_input
l=list(r())
print''.join(map(lambda c:c=='*'and(l and l.pop(0)or'.')or c,"\n".join(map(r,'>'*input())))+l)

Comments

आप 9 बाइट्स को बचाने के (['.']+l).pop(0)बजाय उपयोग कर सकते हैं (len(l)and l.pop(0)or'.')। और 1 बाइट बचाने के input()बजाय int(r())।

— nyuszika7h

के लिए धन्यवाद input! दुर्भाग्य से आपकी पहली सलाह काम नहीं करती है क्योंकि यह डॉट्स को स्ट्रिंग की लंबाई> 0 तक आउटपुट करती है।

— avall

मैं देखता हूं कि मेरा सुझाव सही क्यों नहीं है। (l+['.']).pop(0)इसके बजाय कोशिश करें , लेकिन अगर वह भी काम नहीं करता है, तो आप l andइसके बजाय का उपयोग करके 4 बाइट्स बचा सकते हैं len(l)and।

— nyuszika7h

(l+['.']).pop(0)से तत्वों को दूर नहीं करता lतो केवल पहला वर्ण छपा है लेकिन lहालत काम करता है :)

— avall

Answer 14

C # (विजुअल C # इंटरएक्टिव कंपाइलर) , 122 बाइट्स

var n=ReadLine();int k=0;foreach(var z in In.ReadToEnd())Write(z>33?(n+new string('.',999))[k++]:z);Write(n.Substring(k));

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

Comments

ऐसा करने के लिए बारीकियों और अन्य उत्तरों की कमी के कारण, आप संभवतः "\n"+अतिरिक्त वर्णों को एक ही पंक्ति में जोड़ने की कोशिश कर सकते हैं

— Veskah

Answer 15

05AB1E , 18 17 15 बाइट्स

s0¢.$«0¹S.;0'.:

पहले इनपुट के रूप में कोड लेता है, दूसरे के रूप में पैटर्न ( 0इसके बजाय #)।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

उलटे क्रम में इनपुट्स लेने से 18 15 बाइट्स विकल्प:

0¢.$¹ì0IS.;0'.:

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

स्पष्टीकरण:

s                # Swap with implicit inputs, so the stack order is now: [code, pattern]
 0¢              # Count the amount of "0" in the pattern
   .$            # Remove that many leading characters from the code
     «           # Append it to the (implicit) pattern input
      0¹S.;      # Replace every "0" one by one with the characters of the first code input
           0'.: '# Then replace any remaining "0" with "."
                 # (after which the result is output implicitly as result)