वेव-पार्टिकल ड्यूलिटी बाद में प्रोग्रामेटिक रूप से

30

एक प्रोग्राम या फ़ंक्शन लिखें जो एक गैर-रिक्त एकल-पंक्ति स्ट्रिंग में लेता है। स्ट्रिंग या तो शून्य या अधिक एक अवधि (एक के बाद रिक्त स्थान हो जाएगा कण जैसे), .या          ., या स्ट्रिंग एक का एक अनुक्रम या अधिक आगे बारी और वापस स्लैश (एक हो जाएगा लहर ) है कि या तो एक के साथ शुरू कर सकता है, इस तरह के के रूप में \या /\/या \/\/\/\/\/\/।

किसी भी स्थिति में, कण / तरंग को एक इकाई द्वारा दाईं ओर प्रचारित करें ।

विशेष रूप से, कण मामले में, पहले एक स्थान डालें ., इसे एक स्थान पर दाईं ओर ले जाएं, फिर परिणामी स्ट्रिंग को आउटपुट करें। उदाहरण के लिए:

.→ →  .
 .→   .
  .→    .
   .→     .
    .→      .
     .→       .
      .→        .
       .→        .

तरंग मामले में, /या तो या \उचित रूप से संलग्न करें ताकि लहर बारी-बारी से बनी रहे और यह लंबाई एक से बढ़े, फिर परिणामी स्ट्रिंग को आउटपुट करें। उदाहरण के लिए:

/→ → /\
\→ \/
/\→ /\/
\/→ \/\
/\/→ /\/\
\/\→ \/\/
/\/\→ /\/\/
\/\/→\/\/\

या तो मामले में, आउटपुट में अनुगामी स्थान नहीं हो सकता है लेकिन वैकल्पिक अनुगमन नई लाइन की अनुमति है।

बाइट्स में सबसे छोटा कोड जीतता है।

code-golf  string  ascii-art 
— केल्विन के शौक
स्रोत
टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।
— डेनिस

जवाबों:

16

सी, 69 बाइट्स

p;f(char*s){p=s[strlen(s)-1]^46;p^=p?93:3022856;printf("%s%s",s,&p);}

इसके लिए थोड़ा-सा एंडियन मशीन और टर्मिनल के आउटपुट की आवश्यकता होती है जो ASCII एस्केप कोड का समर्थन करता है।

p=s[strlen(s)-1]^46 इनपुट स्ट्रिंग के अंतिम ASCII कोड को पकड़ता है, और इसे डॉट के ASCII कोड के साथ XORs करता है।

p^=p?93:3022856कारण pहोगा p^93यदि ASCII कोड स्लैश (बैक) स्लैश नहीं है, जहां p^46^93 == p^115, जो आगे और पीछे स्लैश के बीच टॉगल करेगा। यदि pडॉट है, तो यह इसके बजाय होगा 3022856, जो कि इसके लिए थोड़ा-सा है "\b ."।

printf("%s%s",s,&p);पूर्णांक के बाद इनपुट स्ट्रिंग को प्रिंट करता है p, जिसे थोड़ा-सा एंडियन बाइट स्ट्रिंग के रूप में व्याख्या किया जाता है।

— orlp
स्रोत
1
यह शुद्ध प्रतिभा है।
— लीक
आप को बदल कर एक बाइट बचा सकता है 3022856के साथ '. \b', एक multibyte चरित्र शाब्दिक। बहुत बढ़िया जवाब!
— क्वेंटिन
किसी को भी इस के एक संस्करण है कि किसी भी stdlib सामान का उपयोग नहीं करता है के साथ आ सकता है? :)
— टायलर Y86
12

जेली , 17 14 बाइट्स

ṪO*2.ị“ .\/\”ṭ

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

यह काम किस प्रकार करता है

ṪO*2.ị“ .\/\”ṭ  Main link. Argument: s (string)

Ṫ               Tail; pop and yield the last character.
 O              Ordinal; map “./\” to [46, 47, 92].
  *2.           Elevate the code point to the power 2.5.
                This maps [46, 47, 92] to [14351.41, 15144.14, 81183.84].
     ị“ .\/\”   Index into that string.
                Jelly's indexing is modular, so this takes the indices modulo 5,
                which gives [1.41, 4.14, 3.84].
                Also, for a non-integer index, ị retrieves the elements at both
                adjacent integer indices (1-based). Here, these are [1, 2], [4, 5],
                and [3, 4], so we get " .", "/\", or "\/".
             ṭ  Tack; append the characters to the popped input string.
— डेनिस
स्रोत
7

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

l)_'.={S\}"\/"?|

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

यह काम किस प्रकार करता है

l                 Read a line from STDIN.
 )_               Shift out the last character and copy it.
   '.=            Compare the copy with a dot.
              ?   If the last character is a dot:
      {S\}            Push " " and swap the dot on top.
          "\/"    Else, push "\/".
               |  Perform set union, ordering by first occurrence.
                    " " '.  | -> " ."
                    '/ "\/" | -> "/\"
                    '\ "\/" | -> "\/"
— डेनिस
स्रोत
1
स्वयं पर ध्यान दें: जानें कि सेट कैसे काम करता है। ऐसा लगता है जहां खदान की तुलना में अधिकांश बाइट्स बचाए गए थे।
— Zwei
6

पायथन, 41 बाइट्स

lambda s:[s+'\/'[s[-1]>'/'],' '+s][s<'/']

Casework। क्रमबद्ध क्रम का उपयोग करता है ' ', '.', '/', '\'। रिक्त स्थान और अवधि के लिए, एक स्थान पूर्व निर्धारित करता है। अन्यथा, पिछले चरित्र के विपरीत एक स्लैश या ब्लैकस्लैश जोड़ता है।

— XNOR
स्रोत
5

अजगर, 44 42 बाइट्स

lambda s:s[:-1]+"\/ /\."[-ord(s[-1])&3::3]

अंतिम वर्ण को दो वर्णों के पत्राचार सेट के साथ बदल देता है। ideone लिंक

(-2 बाइट्स @ @ xsot की छोटी मैपिंग फ़ंक्शन के लिए धन्यवाद)

— Sp3000
स्रोत
-ord(s[-1])&33 अलग-अलग सूचकांक भी देता है।
— xsot
@xsot ओह अच्छा, मैंने सोचा नहीं था &!
— Sp3000
इस बार कोई मेम? : '(
— थ्रीएफएक्स
5

गेम मेकर लैंग्वेज, 107 बाइट्स

s=argument0;if string_pos(" ",s)return " "+s;if string_pos(s,string_length(s))="/"s+="\"else s+="/"return s
— Timtech
स्रोत
5

विम, 27 23 कीस्ट्रोक्स

पहले कभी भी विम का उत्तर दें, वास्तव में भी कभी भी विम का उपयोग नहीं किया है।

A/<esc>:s#//#/\\<cr>:s#\./# .<cr>

यह कैसे काम करता: यह एक संलग्न कर देता है /पंक्ति के अंत में, बाद के चरणों //के लिए /\, बाद के चरणों ./के लिए .

— विनाशकारी नींबू
स्रोत
/उदाहरण के लिए, यदि आप किसी भिन्न सीमांकक का उपयोग करते हैं, तो आप बच निकलने से बच सकते हैं s#//#/\\ ।
— m-chrzan
धन्यवाद, मुझे पता नहीं था कि ऐसा कुछ भी नहीं है
— विनाशकारी नींबू
4

MATL , 19 बाइट्स

t47<?0w}'\/'yO)o)]h

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

व्याख्या

t        % Input string implicitly. Duplicate
47<      % Are entries less than 47 (i.e dot or spaces)?
?        % If all are
  0      %   Push a 0. When converted to char it will be treated as a space
  w      %   Swap, so that when concatenated the space will be at the beginning
}        % Else
  '\/'   %   Push this string
  y      %   Duplicate the input string onto the top of the stack
  O)     %   Get its last element
  o      %   Convert to number    
  )      %   Use as (modular) index to extract the appropripate entry from '\/'
]        % End
h        % Concatenate string with either leading 0 (converted to char) or
         % trailing '\'  or '/'. Implicitly display
— लुइस मेंडो
स्रोत
3

CJam, 35 26 25 बाइट्स

डेनिस के लिए 9 बाइट्स से बचाए गए

1 और बाइट को बचाया, डेनिस के लिए भी धन्यवाद

q:I'.&SI+IW='/=I'\+I'/+??

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

शायद खराब गोल्फिंग है, लेकिन मैं सीजेएम से बहुत परिचित नहीं हूं। यह देखने का एक बेहतर तरीका है कि कोई तत्व किसी सरणी में है या नहीं, लेकिन मैं उसके लिए कोई ऑपरेटर नहीं ढूंढ सकता।

स्पष्टीकरण:

q:I e# take input
'.& e# push union of input and ".", effectively checking if input contains it
SI+ e# push string with space in beginning
IW='/= e# push 1 if the last chsaracter in the input is /
I'\+ e# push the input with a \ appended
I'/+ e# push the input with a / appended
? e# ternary if to select correct /
? e# ternary if to select final result
— Zwei
स्रोत
1
Wशुरू में है -1और ?ब्लॉक और अन्य स्टैक आइटम के साथ काम करता है, इसलिए आप q:I'.#)SI+IW='/=I'\+I'/+??
— डेनिस
1
यह जांचने के लिए कि क्या एक चरित्र स्ट्रिंग से संबंधित है, आप उनके साथ अंतर कर सकते हैं &।
— डेनिस
मैं CJam लोल में बहुत बुरा हूं
— Zwei
2

सी, 85 बाइट्स

j;f(char*n){j=strlen(n)-1;printf("%s%s",n[j]<47?" ":n,n[j]==46?n:n[j]==47?"\\":"/");}

Ideone

मैं लगभग 20 घंटे तक नहीं सोया, मेरा कोड शायद बहुत बड़ा हो सकता है।

— betseg
स्रोत
2

मतलाब, 74 71 62 57 बाइट्स

@(s)[s(1:end-1) ' .'+(s(1)>46)*'/.'+(s(end)>47)*[45 -45]]

यह s(1)पहले चरित्र के आधार पर अंतिम दो वर्णों की गणना करता है - यह निर्धारित करने के लिए कि क्या हम \/मामले से निपट रहे हैं , और वर्णों के s(end)लिए सही ट्यूपल बनाने के लिए अंतिम \/चरित्र।

— pajonk
स्रोत
2

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

\.
 .
/$
/\^H
\\$
\/

^Hबीएस बाइट का प्रतिनिधित्व करता है। इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत
बैकस्पेस वर्ण क्यों?
— राबर्ट फ्रेजर
इसके बिना, अगला प्रतिस्थापन पीछे के बैकलैश से मेल खाएगा। उदाहरण के लिए, इनपुट /बन जाएगा /\/।
— डेनिस
2

> <> , 47 बाइट्स

i:0(?\
*=?$r\~:1[:"./ \/"{=?@r=?$r~~]:48
l?!;o>

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

पहली पंक्ति एक मानक> <> इनपुट लूप है। दूसरी पंक्ति / \अंतिम इनपुट वर्ण के आधार पर उपयुक्त चरित्र को स्ट्रिंग में संलग्न करने के लिए चुनती है । इसके अलावा, यदि अंतिम इनपुट चरित्र ए था ., तो शीर्ष दो तत्व स्विच किए जाते हैं। अंत में, स्टैक सामग्री को रिवर्स में प्रिंट किया जाता है।

— सोक
स्रोत
2

जावास्क्रिप्ट, 79 70 65 58 बाइट्स

(a,b="/\\/",i=b.indexOf(a[a.length-1]))=>i<0?" "+a:a+b[i+1]
— kamoroso94
स्रोत
1
बदलें b.charAt(i+1)के साथ b[i+1]कुछ बाइट्स को बचाने के लिए। इसके अलावा, यह सभी परीक्षण मामलों के लिए काम नहीं करता है। \/उदाहरण के लिए, `/ \` देता है।
— user2428118
@ user2428118 धन्यवाद, बग निश्चित और कोड छोटा!
— kamoroso94
1
एक डिफ़ॉल्ट मान के साथ init bऔर iparams के रूप में: (a,b=...,i=...)=>बचने के लिएreturn
— charlie
आह हाँ, मैं उस नई सुविधा के बारे में भूल गया। { }साथ ही इस वजह से भी निकालने में सक्षम था ।
— kamoroso94
वास्तव में, कुछ और कदमों के साथ, आप @ TylerY86 के उत्तर में अभिसरण करेंगे
— charlie
2

हास्केल, 46 45 44 बाइट्स

f z@(x:_)|x<'/'=' ':z|x<'0'='\\':z|1<2='/':z

तथ्य का लाभ लेता है कि < .< /< 0< \दो बाइट्स को बचाने के लिए ASCII तालिका में

— BlackCap
स्रोत
1

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

lambda x:x[:-1]+(" .","\/","/\\")[ord(x[-1])/46+(-1,1)[ord(x[-1])%46>0]]

किसी भी मदद और अधिक गोल्फ बहुत सराहना की जाएगी!

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

— डैनियल
स्रोत
1

SQF, 91

फंक्शन-ए-ए-फाइल फॉर्मेट का उपयोग करना:

s=_this;switch(s select[(count s)-1])do{case".":{" "+s};case"\":{s+"/"};case"/":{s+"\"};}

के रूप में बुलाओ "STRING" call NAME_OF_COMPILED_FUNCTION

— Οurous
स्रोत
1

पर्ल, 30 + 1 ( -p) = 31 बाइट्स

s/\./ ./,s|/$|/\\|||s|\\$|\\/|

आवश्यकताओं -pऔर -M5.010या -Eचलाने के लिए:

perl -pE 's/\./ ./,s|/$|/\\|||s|\\$|\\/|' <<< ".
  .
    .
/
/\/"

चुनौती के सीधे आगे कार्यान्वयन। (ध्यान दें कि ||अंतिम दो रेगेक्स के बीच में हैं or, क्योंकि यह पढ़ना मुश्किल हो सकता है, इसलिए तीन रेगेक्स हैं: s/\./ ./और s|/$|/\\|, और s|\\$|\\/|)

— बापू
स्रोत
1

PowerShell v2 +, 59 58 52 51 बाइट्स

param($n)(" $n","$n/","$n\")['.\/'.IndexOf($n[-1])]

इनपुट लेता है $n, यह एक सरणी इंडेक्स ऑपरेशन को डंप करता है। हम सरणी सूचकांक के आधार पर की तत्व का चयन ['.\/'.IndexOf($n[-1])- यानी, इनपुट का अंतिम वर्ण के आधार पर $n, इस का परिणाम देगा 0, 1या 2। यह सरणी के उपयुक्त स्ट्रिंग से मेल खाती है। किसी भी मामले में, परिणामी स्ट्रिंग को पाइप लाइन पर छोड़ दिया जाता है और मुद्रण निहित होता है।

परीक्षण के मामलों

PS C:\Tools\Scripts\golfing> 0..7|%{' '*$_+'.'}|%{"$_ => "+(.\wave-particle-duality.ps1 "$_")}
. =>  .
 . =>   .
  . =>    .
   . =>     .
    . =>      .
     . =>       .
      . =>        .
       . =>         .

PS C:\Tools\Scripts\golfing> '/,\,/\,\/,/\/,\/\,/\/\,\/\/'-split','|%{"$_ => "+(.\wave-particle-duality.ps1 "$_")}
/ => /\
\ => \/
/\ => /\/
\/ => \/\
/\/ => /\/\
\/\ => \/\/
/\/\ => /\/\/
\/\/ => \/\/\
— AdmBorkBork
स्रोत
1

सी #, 80 63 बाइट्स

s=>{var c=s[s.Length-1];retu‌​rn c<'/'?" "+s:c>'/'?s+"/":s+"\\‌​";}
— downrep_nation
स्रोत
क्या आप इसे लैम्ब्डा अभिव्यक्ति का उपयोग करके काम करने के लिए प्राप्त कर सकते हैं?
— TylerY86
s=>{var c=s[s.Length-1];return c<'/'?" "+s:c>'/'?s+"/":s+"\\";}63 dotnetfiddle.net/8x79az
— TylerY86
s=>{var c=s[s.Length-1];return c<47?' '+s:s+(c>47?'/':'\\');}61 dotnetfiddle.net/ykKIL1
— टायलर Y86
आपके लिए एक 46 बाइट प्रतियोगी जोड़ा। :)
— TylerY86
1

लिनक्स पर एआरएम मशीन कोड, 50 बाइट्स

हेक्स डंप:

b580 1e41 f811 2f01 2a00 d1fb 3901 780b 1a0a 4601 2001 2704 df00 2000 a103 2202 f013 0303 2b03 4159 df00 bd80 2e202f5c 5c2f

पहली पोस्ट यहाँ, आशा है कि मैं यह सही कर रहा हूँ। यह 32-बिट एआरएम असेंबली है, विशेष रूप से थम्ब -2। इनपुट स्ट्रिंग एक NUL- टर्मिनेटेड स्ट्रिंग है जिसे r0 के माध्यम से लिया जाता है, आउटपुट को stdout में प्रिंट किया जाता है। सी-सिंटैक्स में, फ़ंक्शन का प्रोटोटाइप शून्य func_name (char * string) होगा। यह AAPCS (ARM कॉलिंग कन्वेंशन) की शिकायत है, अगर ऐसा नहीं होता तो 2 बाइट्स को बंद किया जा सकता था।

यहाँ समतुल्य असेंबली है, टिप्पणी के साथ कि क्या हो रहा है:

    @Input: r0 is char* (the string)
    @Output: Modified string to console
    push {r7,lr} @Save r7 and the link register
    subs r1,r0,#1 @Make a copy of the char*, subtracting because we're
    @going to pre-increment.
    loop: @This loop is a little strlen routine
            ldrb r2,[r1,#1]! @In C-syntax, r2=*++r1;
            cmp r2,#0
            bne loop
    @Now r1 points to the null character that terminates the string
    subs r1,r1,#1 @Make r1 point to the last character
    ldrb r3,[r1] @Load the last character into r3
    subs r2,r1,r0 @r2=length(r0) - 1;
    mov  r1,r0 @r0 holds the original char*
    movs r0,#1 @1 is the file descriptor for stdout
    movs r7,#4 @4 is write
    swi #0

    @Now all the characters from the initial string have been printed,
    @except for the last one, which is currently in r3.

    movs r0,#1 @1 is stdout, have to reload this since the system call
    @returns in r0.
    adr r1,msg @Load msg into r1 (the pointer to the string)
    movs r2,#2 @We're going to print two more characters.

    @Now the bit magic. The ascii codes for '\', '.', and '/' map onto
    @0, 2, and 3 when bitwise anded with 3 (0b11).
    @This will be the offset into our string. However, since we must print
    @2 characters, we need our offsets to be 0, 2, and 4.
    @Therefore, we only set the carry if our value is >=3, then add with
    @carry (adcs). Thus we get the correct offset into the string msg.
    ands r3,r3,#3
    cmp r3,#3 @Sets carry if r3>=3
    adcs r1,r1,r3 @Add the offset to r1
    swi #0 @Make the system call
    pop {r7,pc} @Return and restore r7
msg:
    .ascii "\\/ ./\\" @The three different sequences of 2 characters that
    @can go at the end.
— इयान चबाना
स्रोत
1

ECMAScript 6/2015 (जावास्क्रिप्ट), 41 बाइट्स

s=>s<'/'?' '+s:s+'\\/'[s.slice(-1)>'/'|0]

अच्छा कैच नील।

— TylerY86
स्रोत
आपका आउटपुट गलत लगता है। स्लैश के लिए, आपके कोड को अगले स्लैश को जोड़ना चाहिए, न कि इसे प्रीपेन्ड करें।
— डेनिस
समायोजित उत्तर।
— टायलर Y86
क्यों नहीं +(s+1)?
— नील
अब भी बेहतर है s<'/'।
— नील
1

आर, 119 बाइट्स

a=scan(,"");if((q=strsplit(a,"")[[1]][nchar(a)])=="."){cat(" ",a,sep="")}else{s=switch(q,"/"="\\","/");cat(a,s,sep="")}

अधूरा:

a=scan(,"")
if((q=strsplit(a,"")[[1]][nchar(a)])==".")
    cat(" ",a,sep="")

else
s=switch(q,"/"="\\","/")
cat(a,s,sep="")
— फ़्रेडरिक
स्रोत
1

SED, 41 36 27

7 बचाया चार्ली के लिए धन्यवाद 

 s|\.| .|;s|/$|/\\|;t;s|$|/|

3 प्रतिस्थापन का उपयोग करता है:
s/\./ ./यदि कोई जगह है तो एक स्थान जोड़ता है .
s|/$|/\\|, परिसीमन के बजाय s|$|/|उचित
उपयोग को अंतिम स्लैश में जोड़ता है|/

t दूसरी रेग्क्स से मेल खाती है, तो यह अंत तक शाखाएं ताकि यह दूसरे स्लैश को न जोड़े

— रिले
स्रोत
मैं लगभग एक समान समाधान के लिए आया था: s/\./ ./;s./$./\\.;t;s.$./.- यह 27 बाइट्स है। तीसरे प्रतिस्थापन को सरल बनाया गया है और मेरे सिस्टम पर -reइसकी आवश्यकता नहीं है। इसके अलावा, मैं इनपुट स्पेस में नेत्रहीन रहने के .बजाय उपयोग करता हूं #। ; ओ)
— चार्ली
1

टर्टलाड , 32 बाइट्स ( नॉनकमेटिंग )

l!-[*+.r_]l(/r'\r)(\r'/)(." .")$

स्पष्टीकरण:

[implicit]                       first cell is an asterisk

l                                move left, off the asterisk, so the '[*+.r_]' loop runs
 !                               take input into string var, char pointer=0, 1st char
  -                              decrement char pointer, mod length input             

   [*    ]                       while current cell isn't *:
     +.                          increment string pointer, and write the pointed char
       r_                        move right, write * if pointed char is last char, else " "

          l                      move left

           (/    )               if the current cell is /
             r'\r                move right, write /, move right

                  (\   )         If the current cell is \
                    r'/          move right, write /

                        (.    )  If the current cell is .
                          " ."   Write " .", the first space overwriting the existing '.'

                               $ Program won't remove leading spaces when printing

    [implicit]                   Program prints grid after finishing execution
— विनाशकारी नींबू
स्रोत
1

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

String c(String i){return i.contains(".")?" "+i:i+(i.endsWith("/")?92:'/');}

बहुत सीधा।

Ungolfed और परीक्षण कोड:

इसे यहाँ आज़माएँ।

class M{
  static String c(String i){
    return i.contains(".")
            ? " " + i
            : i + (i.endsWith("/")
                    ? 92
                    : '/');
  }

  public static void main(String[] a){
    System.out.println(c(" ."));
    System.out.println(c("  ."));
    System.out.println(c("   ."));
    System.out.println(c("    ."));
    System.out.println(c("     ."));
    System.out.println(c("      ."));
    System.out.println(c("       ."));
    System.out.println(c("        ."));
    System.out.println(c("/"));
    System.out.println(c("\\"));
    System.out.println(c("/\\"));
    System.out.println(c("\\/"));
    System.out.println(c("/\\/"));
    System.out.println(c("\\/\\"));
    System.out.println(c("/\\/\\"));
    System.out.println(c("\\/\\/"));
  }
}

आउटपुट:

  .
   .
    .
     .
      .
       .
        .
         .
/\
\/
/\/
\/\
/\/\
\/\/
/\/\/
\/\/\
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.