Stretchy सांप चुंबन बनाओ

57

एक खिंचाव वाला सांप कुछ इस तरह दिखता है:

<||=|||:)~

|एक खिंचाव वाले सांप में ऊर्ध्वाधर सलाखों ( ) का प्रत्येक अलग क्रम , जिसे एक खिंचाव वाले हिस्से के रूप में जाना जाता है , व्यक्तिगत रूप से इसकी चौड़ाई के दोगुने तक बढ़ जाती है, और एक बार विस्तारित स्लैश ( /, \) के साथ खींचा जाता है ।

ऊपर विशेष सांप के दो ऐसे खिंचाव वाले हिस्से होते हैं, जो इसे चार संभव बनाते हैं:

<||=|||:)~

</\/\=|||:)~

<||=/\/\/\:)~

</\/\=/\/\/\:)~

कम से कम खिंचे हुए पोज़ में एक स्ट्रेपी स्नेक का सामान्य रूप इस रेगेक्स द्वारा परिभाषित किया गया है :

<(\|+=)*\|+:\)~

जिसे शब्दों में कहा जा सकता है:

<, के दृश्यों के किसी भी संख्या के बाद |'s में शामिल हो गए के साथ =संकेत, जिसके बाद :)~।

तो <|:)~और <||:)~और <|=|:)~और <|=|=||=|||||=||:)~लचीला सांप हैं, लेकिन <=:)~और <=|:)~और <||=:)~और <|==||:)~नहीं कर रहे हैं।

स्ट्रेची सांपों को दाएं के बजाय बाएं का सामना करना पड़ सकता है, जैसे ~(:|||=||>। रूप एक ही हैं, बस प्रतिबिंबित।

चुनौती

एक प्रोग्राम लिखें जो दो स्ट्रेची सांपों की एकल पंक्ति स्ट्रिंग में एक दूसरे का सामना कर रहे हों, बीच में कुछ संख्या में रिक्त स्थान के साथ। दोनों सांप अपने कम से कम फैला हुआ मुद्रा में होंगे (सभी ऊर्ध्वाधर पट्टियाँ, कोई स्लैश नहीं)। स्ट्रिंग दाएं-मुंह वाले सांप की पूंछ के साथ शुरू होगी और बाएं-मुंह वाले सांप की पूंछ के साथ समाप्त होगी (आप वैकल्पिक रूप से मान सकते हैं कि एक अनुगामी न्यूलाइन भी है)।

उदाहरण के लिए, यहां सांपों के बीच पांच स्थानों के साथ एक संभावित इनपुट है:

<|=||:)~.....~(:||||>

मैं .स्पष्टता के लिए वास्तविक स्थान वर्णों के बजाय अवधियों ( ) का उपयोग कर रहा हूं ।

सांपों के बीच शून्य स्थान भी मान्य इनपुट है:

<|=||:)~~(:||||>

हम कहते हैं कि सांप रहे चुंबन जब अपनी जीभ को इस तरह छू रहे हैं।

आपका कार्यक्रम (ओवरलैपिंग के बिना) सांप इस तरह दोनों का लचीला भागों के कुछ संयोजन का विस्तार करने की सांप उन दोनों के बीच संभव रिक्त स्थान और उनमें कम है, जरूरत है यानी ऐसी है कि सांप संभव के रूप में चुंबन के रूप में करीब हैं ।

दोनों सांपों की पूंछ तय हो गई है, लेकिन उनके सिर और शरीर हिल सकते हैं - दाएं-मुंह वाले सांप के लिए दाएं, बाएं-बाएं सांप के लिए - क्या खिंचाव के हिस्सों को बढ़ाया गया है।

अपने कार्यक्रम के उत्पादन में एक पंक्ति स्ट्रिंग (प्लस वैकल्पिक अनुगामी newline) के रूप में, संभव के रूप में चुंबन कि बढ़ाया गया है लचीला भागों के लिए खड़ी सलाखों के स्थान पर तैयार की स्लैश बारी के साथ के पास सांप से पता चलता है।

उदाहरण के लिए, <|=||:)~.....~(:||||>(ऊपर से) के लिए आउटपुट होगा:

</\=||:)~~(:/\/\/\/\>

यह वह जगह है ही यहाँ समाधान क्योंकि लचीला भागों बढ़ाया का कोई अन्य संयोजन के साथ, सांप या तो ओवरलैप या होगा आगे चुंबन से दूर।

यदि कई समाधान संभव हैं, तो आउटपुट उनमें से कोई भी हो सकता है।

उदाहरण के लिए, यदि इनपुट थे

<|=||:)~.....~(:|||=|>

आउटपुट हो सकता है

<|=/\/\:)~~(:/\/\/\=|>

या

</\=||:)~~(:/\/\/\=/\>

याद रखें कि यह हमेशा सांप को चूम बनाने के लिए संभव नहीं होगा, लेकिन आप अब भी अधिक से अधिक निकट लाने के लिए की जरूरत है।

उदाहरण के लिए, यदि इनपुट थे

<||=||||:)~...~(:||>

आउटपुट हो सकता है

</\/\=||||:)~.~(:||>

या

<||=||||:)~.~(:/\/\>

सांप को पहले से ही चुंबन रहे हैं, तो उत्पादन इनपुट के रूप में ही किया जाएगा। जैसे

<|=||:)~~(:||||>

सामान्य तौर पर, आउटपुट इनपुट के समान होगा यदि किसी भी खिंचाव वाले हिस्से का विस्तार सांपों को ओवरलैप कर देगा। जैसे

<|||=|||:)~..~(:||||=|||||=||||||>

टिप्पणियाँ

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

स्कोरिंग

यह कोड-गोल्फ है । बाइट्स में सबसे कम सबमिशन जीतता है। टाईब्रेकर पहले जवाब है।

code-golf  ascii-art  string  arithmetic 
— केल्विन के शौक
स्रोत
17
Snex शिक्षा 101 - ठीक से चुंबन कैसे
— अनुकूलक
45
"हम कहते हैं कि सांप चुंबन कर रहे हैं जब अपनी जीभ को इस तरह छू रहे हैं।" मैं क्या पढ़ रहा हूँ ...
— 9
8
तो सांप केवल फ्रेंच करते हैं?
— ऑप्टिमाइज़र
3
@PeterTaylor खैर, "मिरर किया हुआ", "उलटा" नहीं (अन्यथा या तो के लिए समान >नहीं होगा ) और , लेकिन वह यह भी कहता है कि "यह केवल महत्वपूर्ण है कि ऊर्ध्वाधर पट्टियों के अनुक्रम में स्लैश वैकल्पिक रूप से प्रतिस्थापित किए जाते हैं। उनका क्रम। बड़े पैमाने पर सांप या आगे या पीछे की ओर झपकी आना पहली बात नहीं है। " <()
— मार्टिन एंडर
7
@qwr इमेजिनेशन।
— केल्विन के शौक

जवाबों:

9

सीजेएम, 87 71 70 68 बाइट्स

l:L"|"f&Qa%_,Y\m*\f{.{_,"/\\"*?}L'|%.\s" /"1$fe=:-\a+}${0a>}=~S%\S**

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

l:L        e# Read a line from STDIN and save it in L.
"|"f&      e# Intersect each character with the string "|".
           e# This pushes either "|" or "".
Qa%        e# Split the resulting array at runs of "".
_,         e# Compute the length of the resulting array (A).
           e# This yield K, the number of stretchy parts.
Y\m*       e# Push the array of all vectores in {0,1}^K.
\f{        e# For each vector V in {0,1}^K, push V and A; then:
  .{       e#   For each C in V and the corresponding P in A:
    _,     e#     Compute the length of the stretchy part P.
    "/\\"* e#     Repeat "/\" that many times.
    ?      e#     If C, select P; else, select "/\"*length(P).
  }        e#   This modifies A.
  L'|%     e#   Split L at runs of vertical lines.
  .\s      e#   Interleave the chunks of L and the modified A. Sringify.
           e#   In each iteration, this constructs a different modification of L,
           e#   with some stretched out stretchy parts.
  " /"1$   e#   Push " /" and a copy of the modified L.
  fe=      e#   Calculate the number of spaces and slashes in the modifed L.
  :-       e#   Subtract the number of occurrences.
  \a+      e#   Construct the array [difference modified-L].
}          e#
$          e# Sort the array (by final number of spaces).
{0a>}=     e# Find the first element greater than [0].
           e# This skips over too far stretched snakes, where the number of
           e# slashes is less than the number of spaces.
~          e# Dump the difference (D) and modified L on the stack.
S%         e# Split L at runs of spaces.
\S*        e# Construct a string of D spaces.
*          e# Join the split L, delimiting by D spaces.
— डेनिस
स्रोत
19

रेटिना , 209 107 99 97 92 बाइट्स

.(?=(.+)(?<=(?=<((\|+|(?<-5>\|(?=\1())?)+)[^|]+)+$(?(5)!)).+( )+\S+))\4
/ \
+` (.*~|~.*) 
$1

गणना के उद्देश्यों के लिए, प्रत्येक पंक्ति एक अलग फ़ाइल में जाती है, लेकिन आप -sध्वज के साथ एक फ़ाइल से कोड चला सकते हैं ।

.NET रेगेक्स और रेटिना की सबसे अच्छी विशेषताओं को एक साथ लाना: समूहों को संतुलित करना, मनमाने ढंग से लंबाई दिखना और बार-बार रीजेस्ट प्रतिस्थापन।

अनिवार्य रूप से, लंबे रेगेक्स एक वैध समाधान को एन्कोड करता है और रेगेक्स इंजन का बैकट्रैकर मेरे लिए सबसे इष्टतम में से एक पाता है।

व्याख्या

सबसे पहले, आइए विचार करें कि हम रेगेक्स के साथ एक वैध समाधान (जरूरी नहीं कि सही आउटपुट का उत्पादन कैसे करें) पा सकते हैं। हम खिंचाव वाले हिस्सों को गिनने में मदद करने के लिए .NET के बैलेंसिंग समूहों का उपयोग कर सकते हैं । निम्नलिखित सरल रीगेक्स पर विचार करें:

\S+( )+.+(?<=(?(1)!)^([^|]+(\|+|(?<-1>\|)*))+>)

हम इसे संक्रमित कर सकते हैं।

\S+( )+.+

यह पूरी स्ट्रिंग से मेल खाता है, 1इनपुट में प्रत्येक स्थान के लिए समूह स्टैक पर एक कैप्चर को आगे बढ़ाता है। हम उस स्टैक का उपयोग यह सुनिश्चित करने के लिए करेंगे कि खिंचाव वाले हिस्से वास्तव में उन समूहों में कैप्चर किए गए स्थान को भर दें।

आगे एक खोजबीन है। पकड़ यह है कि .NET में राइट से लेफ्ट तक लुकबाइंड्स का मिलान किया जाता है (इसलिए कि आपको उन्हें कैसे पढ़ना चाहिए)। यह हमें दूसरी बार स्ट्रिंग को पार करने का अवसर देता है, यह पता लगाता है कि क्या स्ट्रेची भाग का एक उपसमूह है जो मिलान किए गए रिक्त स्थान की संख्या के लिए है। दाईं-बाईं ओर से खोजबीन के माध्यम से जाना:

>

यह सिर्फ यह सुनिश्चित करता है कि हम वास्तव में स्ट्रिंग (सांप की पूंछ) के अंत से शुरू कर रहे हैं।

(
  [^|]+
  (
    \|+
  |
    (?<-1>\|)+
  )
)+

प्रत्येक खिंचाव वाले हिस्से के लिए, यह या तो बिना कुछ किए पूरे भाग से मेल खाता है ( \|+), या यह पूरे भाग से मेल खाता है जबकि स्टैक को बंद करके पॉपिंग 1( (?<-1>\|)*)। इस विकल्प के होने से यह सुनिश्चित होता है कि हम केवल एक खिंचाव वाले हिस्से को पूरी तरह से बढ़ा सकते हैं या इसे अपरिवर्तित छोड़ सकते हैं, और जैसे सामान प्राप्त नहीं कर सकते |/\|। फिर हम अगले स्ट्रेची भाग के साथ आगे बढ़ते हैं [^|]+।

(?(1)!)^

अंत में, हम यह सुनिश्चित करते हैं कि हमने पूरे स्ट्रिंग (दोनों सांपों) को पीछे छोड़ दिया है, और यह स्टैक 1पूरी तरह से खाली है। यानी हमने स्ट्रेच वाले हिस्से का एक सबसेट पाया है, जो पहले पकड़े गए स्थानों की संख्या के बराबर है।

Backtracker स्ट्रिंग के माध्यम से आगे और पीछे जाएगा, जब तक कि सबसेट योग समस्या हल नहीं होती है, अपरिवर्तित और विस्तारित भागों के सभी संयोजनों की कोशिश कर रहा है। यदि इस तरह का सबसेट मौजूद नहीं है, तो लुकअप विफल हो जाएगा। यह बैकट्रैकर को \S+( )+.+भाग में वापस जाने और एक स्थान को कम से कम कैप्चर करने का प्रयास ( )+करेगा (जो .+इसके बजाय केवल कवर करेगा )। +इसलिए हम लालच के कारण अधिक से अधिक रिक्त स्थान भरने का प्रयास करते हैं।

आप इस दृष्टिकोण की वैधता की जाँच इस थोड़े संशोधित प्रतिस्थापन के साथ कर सकते हैं:

\S+(( )+).+(?<=(?(2)!)^([^|]+(\|+|(?<-2>\|)*))+>)
=$1=

जो आपको =spaces=उन रिक्त स्थानों की संख्या के साथ एक स्ट्रिंग देगा जो दिए गए साँपों से भरे जा सकते हैं।

मुझे वास्तव में सही |एस का विस्तार करने के लिए कुछ और प्रवंचना को जोड़ना होगा । मूल रूप से, मैं उन सभी |एस को बदलना चाहता हूं जो (?<-1>\|)+शाखा का उपयोग करके मेल खाते थे । यह विचार एक व्यक्तिगत चरित्र से मेल खाता है, सॉल्वर को एक नज़र में रखता है और एक ध्वज सेट करता है यदि मैच उस शाखा के अंदर होता है। यदि वह ध्वज सेट नहीं किया गया था तो हम अन्य पात्रों के प्रतिस्थापन से बचने के लिए मैच को अंत में अमान्य कर देते हैं।

ऐसा करने के लिए, हम नेस्टेड लुकराउंड का एक गुच्छा उपयोग करते हैं। फिर से, .NET की वैरिएबल-लेंथ लुकबाइंड को राइट से लेफ्ट से मैच किया जाता है, इसलिए अगर हम लुकहेड और लुकबाइंड करते हैं, तो हम रेजेक्स इंजन को कई बार स्ट्रिंग को ट्रैवस कर सकते हैं। गोल्फिंग कारणों से, सॉल्वर मेरे वास्तविक समाधान में उल्टा होता है (अंत में शुरू होता है, दायें से बायें स्थान को उठाता है, और फिर बायें से दायें सम को हल करते हुए), लेकिन अन्यथा सॉल्वर की संरचना बिल्कुल एक जैसी होती है । चलो पूर्ण रेगेक्स को विच्छेदित करते हैं:

.(?=(.+)...)

हम एक एकल वर्ण से मेल खाते हैं, फिर स्ट्रिंग के शेष भाग पर कब्जा करते हैं और कर्सर को स्ट्रिंग के अंत तक ले जाते हैं। हम इस समूह का उपयोग 1बाद में सॉल्वर में जांचने के लिए करेंगे कि क्या हम मैच की स्थिति में हैं।

(?<=....+( )+\S+)

यह ऊपर के साधारण सॉल्वर के पहले भाग की तरह है, सिवाय इसके कि हम रिक्त स्थान को दाएं से बाएं उठाएं। रिक्त स्थान की संख्या पहले की तरह ही काम करती है, सिवाय इसके कि 5अब हम समूह का उपयोग कर रहे हैं।

(?=<((\|+|(?<-5>\|(?=\1())?)+)[^|]+)+$(?(5)!))

यह पहले की तरह ही है, सिवाय इसके कि हम बाएं से दाएं जा रहे हैं, और जब भी हम |विस्तार शाखा में मैच करते हैं , हम जांचते हैं कि क्या यह सही से मिलान किया जा रहा है

(?=\1())?

यह एक वैकल्पिक लुकहेड है। यह 1फिर से समूह से मेल खाने की कोशिश करता है (जो, यहां, केवल तभी संभव है जब हम चरित्र के मिलान के बाद सही हों), और यदि हम करते हैं, तो हम समूह में एक खाली स्ट्रिंग कैप्चर करते हैं 4, जो इंगित करता है कि हमने वर्तमान चरित्र को एक में पाया विस्तारित बिट्स की। यदि \1मेल नहीं खाता है, 4तो कुछ भी कैप्चर नहीं करेगा, और यह ?सुनिश्चित करता है कि फेल होने वाला लुकहैड सॉल्वर को बिल्कुल प्रभावित नहीं करेगा।

अंत में, सभी समाधान किए जाने के बाद, हम सिर्फ \4इस बात की जांच करते हैं कि क्या इस लुकहेड का उपयोग किया गया था। यदि हां, तो हम वर्तमान चरित्र को बदलना चाहते हैं /\।

एक कठिनाई बनी हुई है: रिक्त स्थान की सही मात्रा को निकालना। ऐसा करने का सबसे छोटा तरीका जो मैंने अब तक पाया है, उसके साथ एक स्थान सम्मिलित करना है /\और फिर एक अलग चरण में उन मार्कर स्थानों में से प्रत्येक के लिए जीभ के बीच एक स्थान से छुटकारा पाना है:

+` (.*~|~.*) 
$1
— मार्टिन एंडर
स्रोत
6

रूबी 191 187 186 170 162

->t{s=r=t.size
i=m=t[o=/ +/].size
(0...2**t.scan(y=/\|+/).size).map{|n|q=-1
x=t.gsub(y){|r|n[q+=1]<1?r:'\/'*r.size}
d=i+s-x.size
d<0||d<m&&r=x.gsub(o,' '*m=d)}
r}

यह एक फ़ंक्शन है जो एक स्ट्रिंग को पैरामीटर के रूप में लेता है और एक स्ट्रिंग लौटाता है।

ऑनलाइन परीक्षण: http://ideone.com/uhdfXt

यहाँ पठनीय संस्करण है:

# enumerates the possible states for any string containing snakes
COMBINATIONS =-> snake {
  expandable_fragments = snake.scan /(\|+)/

  (0...2**(expandable_fragments.size)).map{ |i|
    x=-1
    snake.gsub(/\|+/){|r| i[x+=1]>0 ? '\/'*r.size : r}
  }
}

# finds the configuration in which snakes are closest to each other
KISS=
-> input {
  result = input
  s = input.size
  initial_distance = min_distance = input[/ +/].size

  COMBINATIONS[input].map{|c|
    distance = initial_distance + s - c.size
    if distance > -1 && distance < min_distance
      min_distance = distance
      result = c.gsub(/ +/,' '*distance)
    end
  }

  result
}

गोल्फ संस्करण में, मुख्य KISSफ़ंक्शन ऊपर फ़ंक्शन के बराबर है , और COMBINATIONSफ़ंक्शन इनबिल्ड है।

— क्रिस्टियन लुपस्कू
स्रोत
इनपुट पर विफल रहता है <|=||:)~~(:||||>, जो कल्पना का उल्लेख वैध इनपुट है।
— वैल्यू इंक
6

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

from itertools import*
f=lambda s:min([c.replace(".","",c.count("X"))for c in map("".join,product(*map({"|":"|X"}.get,s,s)))if{c.count("X")>c.count("."),"|X"in c,"X|"in c}=={0}],key=len).replace("X","/\\")

एक लैम्ब्डा होने से साफ-सुथरा और सभी दिखता है, लेकिन मैं लगभग निश्चित हूं कि यह जाने का सबसे अच्छा तरीका नहीं है। लेकिन मैं इसे पोस्ट कर रहा हूं क्योंकि यह सब मुझे अब तक मिला है जो आधा सभ्य दिखता है।

यह अमान्य कॉन्फ़िगरेशन को फ़िल्टर करने के |साथ /\, सभी संभव प्रतिस्थापन पर एक सरल जानवर बल है। केवल साफ सा मुझे लगता है कि हम वास्तव में किसी भी स्थान नहीं लेते है |साथ /\सीधे - हम पहले की जगह |के साथ Xऔर एक बूंद ., हर प्रतिस्थापन के लिए बीच में से सभी वैध तार से अधिक न्यूनतम लंबाई स्ट्रिंग ले तो की जगह Xके साथ /\।

मैंने पुनरावर्ती सहित कुछ अन्य दृष्टिकोणों की कोशिश की, लेकिन वे बहुत गन्दा हो गए। मैंने यह भी सीखा कि re.splitवर्तमान में खाली तारों पर विभाजित नहीं होता है, जो दुर्भाग्यपूर्ण था, क्योंकि मेरे विचारों में से एक \bशब्द सीमाओं पर विभाजित करना शामिल था ।

— Sp3000
स्रोत
5

गणितज्ञ, 381 बाइट्स

StringReplace[MapAt[StringReplace[#,"|"->"/\\"]&,StringSplit[#<>"="<>#2,"="],#3]~StringRiffle~"=",")="->")~"<>If[#4>0,"."~StringRepeat~#4,""]<>"~"]&[#1,#3,Sequence@@Function[{l,s},{#,#2-Total@Extract[l,#]}&[Flatten[l~Position~#~Take~#2&@@@Tally@#&@@Select[Subsets@l,Total@#<=s&]~MaximalBy~Total,1],s]][StringLength/@StringCases[#1<>#3,"|"..],StringLength@#2]]&@@#~StringSplit~"~"&

शुद्ध कार्य स्ट्रिंग को अपने तर्क के रूप में लेता है। उम्मीद .के बजाय सांप के बीच।

मुझे नहीं लगता था कि यह बुरा होगा ... यहाँ मैंने जो कुछ किया था उससे पहले कि मैंने इसे एक साथ तोड़ा और सब कुछ संक्रमित कर दिया।

f[lhs_, rhs_, 
  spaces_] := {StringLength /@ StringCases[lhs <> rhs, "|" ..], 
  StringLength@spaces}

g[barLens_, 
   spaceLen_] := {#, #2 - Total@Extract[barLens, #]} & @@ {Flatten[
     Take[Position[barLens, #], #2] & @@@ 
      Tally[First[
        MaximalBy[Select[Subsets[barLens], Total@# <= spaceLen &], 
         Total]]], 1], spaceLen};

h[lhs_, rhs_, partspec_, newSpaceLen_] := 
 StringReplace[
  StringRiffle[
   MapAt[StringReplace[#, "|" -> "/\\"] &, 
    StringSplit[lhs <> "=" <> rhs, "="], partspec], "="], 
  ")=" -> ")~" <> 
    If[newSpaceLen > 0, StringRepeat[".", newSpaceLen], ""] <> "~"]

 h[#1, #3, Sequence @@ g @@ f[#1, #3, #2]] & @@ 
     StringSplit[#, "~"] &

यहाँ एक उदाहरण रन-थ्रू स्पष्टीकरण के साथ दिया गया है:

Input: "<|=||:)~.....~(:||||>"
@Call StringSplit[#, "~"] &, yielding  {"<|=||:)", ".....", "(:||||>"}
@@Apply h[#1, #3, Sequence @@ g @@ f[#1, #3, #2]] &, but first
Set arguments: h["<|=||:)", "(:||||>", Sequence @@ g @@ f["<|=||:)", "(:||||>", "....."]]
@Call f, yielding {{1, 2, 4}, 5} = {# of bars in each segment, # of spaces}
@@Apply g, let's trace from the interior:
Subsets[barLens] = all subsets of {1, 2, 4}
Select those subsets whose sum is less than # of spaces {{},{1},{2},{4},{1,2},{1,4}}
MaximalBy Total, yielding a list of all subsets whose sum is maximal {{1, 4}}
First of these subsets, can be any of them {1, 4}
Tally the subset, yielding frequencies of each {{1, 1}, {4, 1}}
@@@Apply Take[Position[barLens, #], #2] & at the first level, yielding
    {Take[Position[{1, 2, 4}, 1], 1], Take[Position[{1, 2, 4}, 4, 1]]}
    which takes the first 1 positions of 1 and the first 1 positions of 4, yielding
    {{{1}},{{3}}}
Flatten at the first level, yielding {{1}, {3}}
Create a list {{{1}, {3}}, 5}
@@Apply {#, #2 - Total@Extract[barLens, #]} &, inserting arguments:
    {{{1}, {3}}, 5 - Total@Extract[{1, 2, 4}, {{1}, {3}}]} = {{{1}, {3}}, 0}
    where the second element becomes the # of spaces left over.
Done with g, it returned {{{1}, {3}}, 0}
@@Apply Sequence, splicing the return of g into h, yielding the
@Call, h["<|=||:)", "(:||||>", {{1}, {3}}, 0]; let's start from the interior
StringSplit the concatenated "<|=||:)=(:||||>" with delimiter "=", {"<|","||:)","(:||||>"}
MapAt the part specification {{1}, {3}} and StringReplace at those indices any | with /\
    yielding {"</\","||:)","(:/\/\/\/\>"}
StringRiffle together, inserting back the delimiter "=", yielding "</\=||:)=(:/\/\/\/\>"
StringReplace ")=" with ")~", concat the new number of spaces, concat "~"
Yields "</\=||:)~~(:/\/\/\/\>", done.
— jcai
स्रोत
आसानी से 355 से कम होने के साथ शुरू करने a=StringReplace;b=StringSplit;c=StringLength;d=Total;और फिर उन लोगों को प्रतिस्थापित करने की आवश्यकता है जो अंदर कहीं और हैं:a=StringReplace;b=StringSplit;c=StringLength;d=Total;a[MapAt[a[#,"|"->"/\\"]&,b[#<>"="<>#2,"="],#3]~StringRiffle~"=",")="->")~"<>If[#4>0,"."~StringRepeat~#4,""]<>"~"]&[#1,#3,Sequence@@Function[{l,s},{#,#2-d@Extract[l,#]}&[Flatten[l~Position~#~Take~#2&@@@Tally@#&@@Select[Subsets@l,d@#<=s&]~MaximalBy~d,1],s]][c/@StringCases[#1<>#3,"|"..],c@#2]]&@@#~b~"~"&
— एलेक्स मीबुर्ग
3

प्रोलॉग (ECLiPSe), 438 बाइट्स

मेरे अन्य उत्तर गलत समस्या (शोर के लिए खेद) को हल कर रहे थे। यहाँ प्रोलॉग में एक और प्रयास है जो वास्तव में सभी नियमों का सम्मान करता है।

:-lib(fd).
a([],[]).
a([H|T],L):-append(H,X,L),a(T,X).
s(E,Z,X,Y,L):-length(E,L),a([[60],M,[58,41,126],T,[126,40,58],W,[62]],E),checklist(=(32),T),length(T,Z),b(M,X-[]),b(W,Y-[]).
b(I,[K:M|R]-E):-(I:K=[47,92|L]:s;I:K=[124|L]:n),M#=N+1,N#>=0,b(L,[K:N|R]-E).
b([61|L],[_:0|R]-E):-b(L,R-E).
b([],[_:0|E]-E).
d(_:N,Y:N):-Y=s;Y=n.
s(W,P):-string_list(W,E),s(E,_,X,Y,L),minimize((maplist(d,X,U),maplist(d,Y,V),s(K,Q,U,V,L)),Q),string_list(P,K).

टेस्ट

(प्रारूप: इनपुट, आउटपुट, न्यूलाइन)

<===:)~         ~(:>
<===:)~         ~(:>

<|||:)~         ~(:||||=|>
</\/\/\:)~ ~(:/\/\/\/\=/\>

<=|=:)~         ~(:||||=|>
<=/\=:)~   ~(:/\/\/\/\=/\>

<===|:)~         ~(:||=|>
<===/\:)~     ~(:/\/\=/\>

<|=|=|||=|:)~         ~(:=|>
</\=/\=/\/\/\=/\:)~  ~(:=/\>

<||||||:)~         ~(:=|>
</\/\/\/\/\/\:)~  ~(:=/\>

<||||||:)~         ~(:||>
</\/\/\/\/\/\:)~ ~(:/\/\>

<||=||||:)~ ~(:||>
<||=||||:)~ ~(:||>

<||=||||:)~   ~(:||>
</\/\=||||:)~ ~(:||>

<||=||||:)~    ~(:||>
</\/\=||||:)~~(:/\/\>

<||=||||:)~~(:||>
<||=||||:)~~(:||>

स्पष्टीकरण

  • मुख्य विधेय है s/2, जो इनपुट को पहले तर्क के रूप में लेता है और दूसरे तर्क (दोनों तार) के साथ परिणाम को अक्षम करता है। इनपुट, चरित्र कोड की एक सूची में बदल जाती है E।

  • फिर, s(E,Z,X,Y,L)सूची को निम्नलिखित तत्वों में नष्ट करता है:

    • Z सांपों के बीच रिक्त स्थान की संख्या

    • Xऔर Y, बाएं और दाएं निकायों का सार प्रतिनिधित्व

      एक निकाय का प्रारूप एक सूची n:Nया s:Nभाव है, जहां Nएक सकारात्मक लंबाई है; nसाधन normalऔर sसाधन stretched।

    • L सूची की कुल लंबाई

इस बारे में दिलचस्पs/5 है कि यह दोनों तरीके से चलता है , अर्थात हम एक साँप का निर्माण कर सकते हैं यदि अन्य तर्क दिए गए हों:

    s(E,5,[n:3],[s:2,n:7,s:1],_),string_list(S,E).

... unifies `S` with `"<|||:)~     ~(:/\\/\\=|||||||=/\\>"` (backslashes are quoted). This is due to how `b/2` is written, which can parse the character list or generate it.
  • हम संशोधित बाएं और दाएं निकायों का निर्माण करते हैं जहां प्रत्येक भाग या तो सामान्य या फैला हुआ होता है, जबकि Qनए सांपों को अलग करने वाले स्थान को कम करता है । गणना की गई स्ट्रिंग की कुल लंबाई बाध्य है ताकि खोज समाप्त हो जाए।
— कोर निपात
स्रोत
1

पायथन 2.7.3 427 421 400 371 बाइट्स

import re,itertools as K
g,o,k='\|+',len,raw_input()
d=k.count(' ')
if d==0:exit(k)
p,x,y,s=re.sub,0,0,map(o,re.findall(g,k))
for e in [A for w in range(o(s)+1)for A in K.combinations(s,w)]:
 v=sum(e)
 if v==d or x<v<d:x,y=v,list(e)
print p(" +",' '*(d-x),p(g,lambda m:('/\\'*o(m.group(0))if y.remove(o(m.group(0)))or True else 1)if o(m.group(0))in y else m.group(0),k))

गैर-गोल्फ कोड यहाँ - 

#!/usr/bin/env python
import sys
import re

def find_dist_combo(li, d):
    #Listing all combinations
    from itertools import combinations as c
    max_dist = -1
    max_dist_combo = []
    for p_len in xrange(1,len(li)+1):
        for e in c(li, p_len):
            e_sum = sum(e)
            cond1 = e_sum == d
            cond2 = max_dist < e_sum < d
            if cond1 or cond2:
                max_dist = e_sum
                max_dist_combo = list(e)
                if cond1:
                    return (max_dist, max_dist_combo)
    return (max_dist, max_dist_combo)

def snakes_foreplay(snakes):
    #find distance
    distance = snakes.count(" ")

    #already kissing
    if distance == 0:
        return snakes

    #find num_stretches
    stretch = map(len, re.findall("\|+", snakes))

    #find lowest combination of numbers
    (e_dist, res_stretch) = find_dist_combo(stretch, distance)

    def sub_callback(m):
        s = m.group(0)
        l = len(s) 
        if l in res_stretch:
            res_stretch.remove(l)
            return '/\\'*l
        return s

    #Resultant substitution
    res_snakes = re.sub("\s+", " "*(distance - e_dist), re.sub("\|+", sub_callback, snakes))

    return res_snakes

if __name__ == "__main__":
    for s in [ip.strip() for ip in sys.stdin]:
        print snakes_foreplay(s)

गोल्फ समाधान का परीक्षण - 

$ python stretchy_snakes.py
[In]  <=  <|=||:)~     ~(:||||>
[Out] =>  </\=||:)~~(:/\/\/\/\>

$ python stretchy_snakes.py
[In]  <=  <|=||:)~             ~(:||||>
[Out] =>  </\=/\/\:)~      ~(:/\/\/\/\>

$ python stretchy_snakes.py
[In]  <=  <|=||:)~     ~(:|||=|>
[Out] =>  </\=||:)~~(:/\/\/\=/\>

$ python stretchy_snakes.py
[In]  <=  <||=||||:)~   ~(:||>
[Out] =>  </\/\=||||:)~ ~(:||>

$ python stretchy_snakes.py
[In]  <=  <|=||:)~~(:||||>
[Out] =>  <|=||:)~~(:||||>

निश्चित रूप से यह बेहतर किया जा सकता है (मैं यह पता नहीं लगा सकता कि कैसे :))।
मुझे पता है कि क्या मैंने गोल्फ खेलते समय कुछ भी याद किया है (यह मेरा पहला कोडगोल्फ है, मैं कुछ बेवकूफ कर सकता हूं: पी)

— कामेहामेहा
स्रोत
@ Sp3000 एक अच्छा है। बदला exitके लिए sys.exit()(भूल गया exitथा)। और आप सही हैं, __import__हटाया जा सकता है, जो कि 20 वर्णों की तरह समाप्त हो गया :)
— कम्मेहा
btw अंगूठे का नियम: अलियासिंग के लिए आपको > 6वर्णों की आवश्यकता होती है यदि आप इसे दो बार उपयोग करते हैं, > 3तो चार बार यदि आप इसे तीन बार उपयोग करते हैं। मुझे यकीन नहीं है कि f=' 'उपनाम इसके लायक है (मैं दो बार गिनता हूं)
— Sp3000
@ Sp3000 हां आप सही हैं। पहले के संस्करण में मैंने उस चर का तीन बार उपयोग किया था। मुझे बाइट्स की एक और जोड़ी बचा ली :) :)
— कमेहामे
1

05AB1E , 93 बाइट्स

#õKDεγʒ'|å]©ε€gxøDgU`XG‘]`âDε˜ODI„| Ãg>‹*}ZQÏε˜ε®˜NèDgyÊi„/\y∍]н©J'/¢Ið¢αð×ý'|¡õK®.ιJIðå≠iI

रास्ता बहुत लंबा ..>>

यह ऑनलाइन का प्रयास करें या सभी प्रकार के परीक्षण की पुष्टि या सभी प्रकार के परीक्षण के लिए सभी संभव परिणामों की पुष्टि ।

स्पष्टीकरण:

#õK                   # Split the (implicit) input by one or multiple adjacent spaces
                      # (we now have both snakes as separated items
                      #  - if any spaces were in the input-string)
   D                  # Duplicate this list
    ε                 # Map both snakes to:
     γ                #  Split the snake into chunks of the same character-type
      ʒ'|å]          '#  And only leave the chunks of "|" characters
    ©                 #  Store this list in variable `r` (without popping)
     ε                #  Map the "|" chunks of both snakes again:
      €g              #  Get the length of each chunk of "|"
        xø            #  Pair each length with double itself
          DgU`XG‘   #  Create all possible combinations for the current snake
     ]`â              # After the map: create all possible combinations for both snakes
        ε             # Map over each possible combination
         ˜O           #  Get the flattened sum
            I„| Ãg    #  Count the amount of "|" and spaces in the input
                  >‹  #  Check if it's smaller than or equal to this sum
                      #  (1 if truthy; 0 if falsey)
           D        * #  And multiply it by the sum
        }ZQ           # After the map, get the positions of the largest flattened sum,
                      # still below (or equal to) the amount of "|" and spaces combined
       D   Ï          # And only keep those combinations
ε                     # Then map over the remaining combinations
 ˜ε                   #  Flatten it, and map over each value `y`
   ®˜Nè               #   Get the `N`'th part of the snakes
                      #   (where `N` is the index of the map for the current combination)
       D              #   Duplicate this "|"-part
        gyÊi          #   If the length of this "|"-part is not equal to the map-value:
            „/\       #    Push the string "/\"
               y∍     #    Extended to a size equal to the map-value
                      #   (implicit else:
                      #    use the duplicated value)
]н                    # After the map: only leave the first (since we don't have
                      # to output all possibilities)
 ©                    # Store it in variable `r` (without popping)
  J'/¢               '# Count the amount of "/" in it
      Ið¢             # Count the amount of spaces in the input
         α            # Get the difference between those
          ð×ý         # And join the list of snakes by that many spaces
'|¡õK                '# Then split by one or multiple adjacent "|"
     ®.ι              # Interleave it with the modified parts of variable` r`
        J             # And join everything together to a single string
Iðå≠i                 # If the input didn't contain any spaces:
     I                #  Output the input instead
                      # (implicit else:
                      #  output the top of the stack before this if)
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.