প্রসারিত সাপকে চুম্বন করুন

57

একটি প্রসারিত সাপ দেখতে এমন কিছু দেখাচ্ছে:

<||=|||:)~

প্রসারিত অংশ| হিসাবে পরিচিত একটি প্রসারিত সাপের মধ্যে উল্লম্ব বারগুলির ( ) প্রতিটি পৃথক ক্রম পৃথকভাবে এর প্রস্থের দ্বিগুণ পর্যন্ত প্রসারিত হয় এবং একবারে প্রসারিত স্ট্র্যাশ ( , ) দিয়ে অঙ্কিত হয় ।/\

উপরের বিশেষ সাপটিতে এরকম দুটি প্রসারিত অংশ রয়েছে যা এটিকে চারটি সম্ভাব্য পোজ দেয়:

<||=|||:)~

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

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

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

তার সর্বনিম্ন প্রসারিত ভঙ্গিতে প্রসারিত সাপের সাধারণ রূপটি এই রেজেক্স দ্বারা সংজ্ঞায়িত করা হয় :

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

যা কথায় কথায় বলা যেতে পারে:

<, ক্রমের সাথে যে কোন সংখ্যার দ্বারা অনুসরণ |'s যোগদান সঙ্গে =চিহ্ন, দ্বারা অনুসরণ :)~।

সুতরাং <|:)~এবং <||:)~এবং <|=|:)~এবং <|=|=||=|||||=||:)~প্রসার প্রবণ সাপ আছে, কিন্তু <=:)~এবং <=|:)~এবং <||=:)~এবং <|==||:)~হয় না।

প্রসারিত সাপগুলি ডান, এর পরিবর্তে বাম মুখোমুখি হতে পারে ~(:|||=||>। ফর্মগুলি একই, কেবল মিরর করা।

চ্যালেঞ্জ

একটি প্রোগ্রাম লিখুন যা একে অপরের মুখোমুখি দুটি প্রসারিত সাপের এক লাইনের স্ট্রিংয়ের মধ্যে নিয়ে যায় যার মাঝে কয়েকটি স্পেস থাকে। উভয় সাপ তাদের সর্বনিম্ন প্রসারিত ভঙ্গিতে থাকবে (সমস্ত উল্লম্ব বার, কোনও স্ল্যাশ)। স্ট্রিংটি ডান-মুখের সাপের লেজ দিয়ে শুরু হবে এবং বাম-মুখের সাপের লেজ দিয়ে শেষ হবে (আপনি বিকল্পভাবে ধরে নিতে পারেন একটি অনুবর্তনযোগ্য নিউলাইনও রয়েছে)।

উদাহরণস্বরূপ, সাপের মধ্যে পাঁচটি স্পেস সহ একটি সম্ভাব্য ইনপুট এখানে রয়েছে:

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

আমি .স্পষ্টতার জন্য প্রকৃত স্থান অক্ষরের পরিবর্তে পিরিয়ড ( ) ব্যবহার করছি ।

সাপের মধ্যে শূন্যস্থানগুলি বৈধ ইনপুট:

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

আমরা বলি যে সাপগুলি যখন তাদের জিভগুলি স্পর্শ করে তখন তারা চুমু খাচ্ছে।

আপনার প্রোগ্রামে উভয় সাপের বিস্তৃত অংশের কিছু সংশ্লেষ প্রসারিত করা দরকার যে সাপগুলির মধ্যে সম্ভব সংখ্যক স্পেস রয়েছে (ওভারল্যাপিং ছাড়াই), যেমন সাপ যতটা সম্ভব চুম্বনের কাছাকাছি ।

উভয় সাপের লেজ স্থির থাকলেও তাদের মাথা এবং দেহ নড়াচড়া করতে পারে - ডান মুখের সাপটির জন্য ডানদিকে, বাম-মুখী সাপের জন্য বাম - প্রসারিত অংশগুলি প্রসারিত করা হয়েছে তার অনুসারে।

আপনার প্রোগ্রামের আউটপুটটি হ'ল সিঙ্গল লাইনের স্ট্রিং (প্লাস traচ্ছিক ট্রেলিং নিউলাইন) যা সাপগুলিকে যতটা সম্ভব চুম্বনের কাছে দেখায়, প্রসারিত অংশগুলির জন্য উল্লম্ব বারগুলির জায়গায় বিকল্প স্ল্যাশ আঁকা থাকে।

উদাহরণস্বরূপ, <|=||:)~.....~(:||||>(উপরে থেকে) এর আউটপুটটি হবে:

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

এখানে কেবলমাত্র এটিই সমাধান কারণ প্রসারিত অংশগুলির অন্য কোনও সংমিশ্রণের সাথে সাপগুলি চুম্বন থেকে দূরে সরে যাবে বা আরও দূরে থাকবে।

যদি একাধিক সমাধান সম্ভব হয় তবে আউটপুট তাদের মধ্যে যে কোনও একটি হতে পারে।

উদাহরণস্বরূপ, যদি ইনপুটটি ছিল

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

আউটপুট হতে পারে

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

অথবা

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

মনে রাখবেন যে সাপগুলিকে চুম্বন করা সর্বদা সম্ভব হবে না, তবে আপনার এখনও এগুলি যতটা সম্ভব বন্ধ করা দরকার।

উদাহরণস্বরূপ, যদি ইনপুটটি ছিল

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

আউটপুট হতে পারে

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

অথবা

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

যদি সাপগুলি ইতিমধ্যে চুম্বন করে তবে আউটপুটটি ইনপুটটির সমান হবে। যেমন

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

সাধারণভাবে, যদি কোনও প্রসারিত অংশের প্রসারণ সাপকে ওভারল্যাপ করে তোলে তবে আউটপুটটি ইনপুটটির মতোই হবে। যেমন

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

নোট

  • স্টিডিন বা কমান্ড লাইন থেকে যথারীতি ইনপুট নেয় বা কোনও ফাংশন লিখুন যা স্ট্রিং নেয়। আউটপুট প্রিন্ট বা রিটার্ন করুন।
  • আপনি যদি পছন্দ করেন তবে .স্পেস ( ) এর জায়গায় ইনপুট এবং আউটপুটে পিরিয়ড ( ) ব্যবহার করতে পারেন ।
  • এটি প্রতিস্থাপন করা যে উল্লম্ব বারগুলির ক্রমের মধ্যে বিকল্প স্ল্যাশ করা কেবলমাত্র গুরুত্বপূর্ণ। তাদের সাপ বড় আকারে অর্ডার করা বা একটি পিছনে বা পিছনে স্ল্যাশ প্রথমে আসে কিনা তাতে কিছু যায় আসে না।
  • প্রসারিত অংশগুলি পার্টওয়ে পর্যন্ত প্রসারিত করতে পারে না - এটি হুবহু দ্বিগুণ বা মোটেও কোনও এক্সটেনশন নয়।

স্কোরিং

এটি কোড-গল্ফ । বাইটস মধ্যে সংক্ষিপ্ততম জমা জয়। টাইব্রেকার এর আগের উত্তর।

code-golf  ascii-art  string  arithmetic 
— ক্যালভিনের শখ
সূত্র
17
স্নেক্স এডুকেশন 101 - কীভাবে সঠিকভাবে চুম্বন করবেন
— অপটিমাইজার
45
"আমরা বলি যে সাপগুলি যখন তাদের জিভগুলি স্পর্শ করে তখন তারা চুম্বন করে।" আমি কী পড়ছি ...
— ফ্যাটালাইজ করুন
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**

সিজেএম ইন্টারপ্রেটারে এটি অনলাইনে চেষ্টা করুন ।

কিভাবে এটা কাজ করে

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 রেজেক্স এবং রেটিনার সেরা বৈশিষ্ট্যগুলি একত্রিত করা: ভারসাম্য গ্রুপ, স্বেচ্ছাসেবী দৈর্ঘ্যের বর্ণনহীন এবং পুনরাবৃত্তি রেজেক্সের বিকল্প।

মূলত, লম্বা রেইগেক্স একটি বৈধ সমাধান এনকোড করে এবং রেজেক্স ইঞ্জিনের ব্যাকট্র্যাকার আমার জন্য একটি অনুকূল সন্ধান করে।

ব্যাখ্যা

প্রথমে বিবেচনা করা যাক আমরা কীভাবে একটি রেইজেক্স সহ একটি বৈধ সমাধান (প্রয়োজনীয়ভাবে সঠিক আউটপুট উত্পাদন না করে) খুঁজে পেতে পারি। প্রসারিত অংশগুলি গণনা করতে আমাদের সাহায্য করার জন্য আমরা। নেট এর ব্যালেন্সিং গ্রুপগুলি ব্যবহার করতে পারি । নিম্নলিখিত সরল রেগেক্স বিবেচনা করুন:

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

আমরা এটি diste করতে পারেন।

\S+( )+.+

এটি পুরো স্ট্রিংয়ের সাথে মেলে, ইনপুটটির 1প্রতিটি জায়গার জন্য গ্রুপ স্ট্যাকের উপরে একটি ক্যাপচারটি চাপছে । প্রসারিত অংশগুলি সেই গোষ্ঠীগুলিতে আটকানো স্থানটি যথাযথভাবে পূরণ করবে তা নিশ্চিত করার জন্য আমরা সেই স্ট্যাকটি ব্যবহার করব।

এরপরে একটি লুকবাইন্ড। ক্যাচটি হ'ল লুকবিহ্যান্ডগুলি। নেট থেকে ডান থেকে বামে মিলছে (যাতে আপনার সেগুলি পড়তে হবে)। এটি আমাদের দ্বিতীয়বার স্ট্রিংটি অতিক্রম করার সুযোগ দেয়, এটি নির্ধারণ করে যে প্রসারিত অংশের একটি উপসেট রয়েছে যা ম্যাচের জায়গাগুলির সংখ্যার সাথে যোগ করে। ডান থেকে বাম দিকে নজরদারি দিয়ে যাচ্ছেন:

>

এটি কেবলমাত্র নিশ্চিত করা যায় যে আমরা আসলে স্ট্রিংয়ের শেষে (সাপের লেজ) থেকে শুরু করছি।

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

প্রতিটি প্রসারিত অংশের জন্য, এটি হয় কোনও কিছু না করেই পুরো অংশটির সাথে মেলে ( \|+বা ক্যাপচারিং স্ট্যাক 1( (?<-1>\|)*) ছাড়ানোর সময় এটি পুরো অংশের সাথে মেলে । এই বিকল্পটি থাকা নিশ্চিত করে যে আমরা কেবলমাত্র একটি প্রসারিত অংশ পুরোপুরি প্রসারিত করতে পারি বা অপরিবর্তিত রাখতে পারি, এবং স্টাফ পছন্দ করি না |/\|। তারপরে আমরা সাথে পরবর্তী প্রসারিত অংশে এগিয়ে যাই [^|]+।

(?(1)!)^

অবশেষে, আমরা নিশ্চিত করেছিলাম যে আমরা পুরো স্ট্রিংটি (উভয় সাপ) অতিক্রম করেছি এবং সেই স্ট্যাকটি 1সম্পূর্ণ ফাঁকা। অর্থাৎ আমরা প্রসারিত অংশের একটি উপসেট খুঁজে পেয়েছি যা আমরা আগে ক্যাপচার করেছি এমন জায়গাগুলির সংখ্যার সাথে সমান।

সাবটেট সমষ্টি সমস্যার সমাধান না হওয়া অবধি ব্যাকট্র্যাকার অপরিবর্তিত এবং বর্ধিত অংশগুলির সমস্ত সংমিশ্রণ চেষ্টা করে স্ট্রিংয়ের মাধ্যমে পিছনে পিছনে যাবে। যদি এই জাতীয় কোনও উপসেট উপস্থিত না থাকে তবে চেহারাটি ব্যর্থ হবে। এটি ব্যাকট্র্যাকারটিকে \S+( )+.+অংশে ফিরে যেতে এবং একটি জায়গা কম দিয়ে ক্যাপচার করার চেষ্টা ( )+করবে (যা কেবল .+পরিবর্তে আচ্ছাদিত হবে)। লোভের কারণে +আমরা তাই যথাসম্ভব শূন্যস্থান পূরণ করার চেষ্টা করি।

এই সামান্য পরিবর্তিত প্রতিস্থাপনের মাধ্যমে আপনি এই পদ্ধতির বৈধতা পরীক্ষা করতে পারেন:

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

যা আপনাকে =spaces=প্রদত্ত সাপগুলি পূরণ করতে পারে এমন ঠিক জায়গাগুলির সংখ্যার সাথে একটি স্ট্রিং দেবে ।

সত্যিকারের সঠিক সম্প্রসারণ করতে আমাকে আরও কিছু কৌশল যুক্ত করতে হয়েছিল |। মূলত, আমি ব্রাঞ্চ |ব্যবহার করে মিলে যাওয়া সমস্তগুলি প্রতিস্থাপন করতে চাই (?<-1>\|)+। ধারণাটি হ'ল কোনও স্বতন্ত্র চরিত্রের সাথে মেলে, সলভারটিকে একটি দর্শনীয় স্থানে রাখুন এবং ম্যাচটি যদি সেই শাখার অভ্যন্তরে থাকে তবে একটি পতাকা সেট করে। যদি সেই পতাকাটি সেট না করা হয় তবে আমরা অন্যান্য অক্ষরগুলির প্রতিস্থাপন এড়াতে ম্যাচটি শেষ পর্যন্ত অবৈধ করি।

এটি করতে, আমরা নেস্টেড লুকেরাউন্ডগুলির একটি গুচ্ছ ব্যবহার করি। আবার .NET- র ভেরিয়েবল-দৈর্ঘ্যের লুকবাইন্ডগুলি ডান থেকে বামে মিলছে, সুতরাং আমরা যদি লক হেডস এবং লুকবাইন্ডগুলি বাসা বেঁধে রাখি তবে আমরা রেজেক্স ইঞ্জিনটিকে বেশ কয়েকবার স্ট্রিংটি অতিক্রম করতে পারি। গল্ফিং কারণে, সলভারটি আমার আসল সমাধানে বিপরীত হয় (শেষে শুরু করে, ডান থেকে বামে ফাঁকা স্থানগুলি বেছে নিয়ে এবং তারপরে বাম থেকে ডানে উপসেট যোগফল সমাধান করে) তবে অন্যথায় দ্রষ্টকের কাঠামোটি হুবহু একই । আসুন পুরো রেজেক্স বিচ্ছিন্ন করুন:

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

আমরা একটি একক চরিত্রের সাথে মেলে, তারপরে স্ট্রিংয়ের বাকী অংশগুলি ক্যাপচার করি এবং কার্সারটিকে স্ট্রিংয়ের শেষের দিকে নিয়ে যাই। আমরা এই গ্রুপটি 1পরে ম্যাচের অবস্থানে আছি কিনা তা সল্ভারটি পরীক্ষা করার জন্য ব্যবহার করব ।

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

এটি উপরের সরল সলভারের প্রথম অংশের মতো, আমরা ডান থেকে বামে স্থানগুলি তুলি। জায়গাগুলির সংখ্যার ব্যাকট্র্যাকিং পূর্বের ঠিক ঠিক একইভাবে কাজ করে, আমরা 5এখন গ্রুপ ব্যবহার করছি except

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

এটি পূর্বের মতোই, আমরা বাম থেকে ডান দিকে যাচ্ছি ব্যতীত এবং যখনই আমরা |প্রসারিত শাখায় কোনওটির সাথে মেলে , আমরা পরীক্ষা করে দেখি যে এটি একটির সাথে সঠিকভাবে মিলছে কিনা check

(?=\1())?

এটি একটি alচ্ছিক চেহারা। এটি 1আবার গ্রুপের সাথে ম্যাচ করার চেষ্টা করে (যা এখানে অক্ষরের সাথে মিলে যাওয়ার পরে ঠিক তখনই সম্ভব) এবং যদি আমরা এটি করি তবে আমরা একটি খালি স্ট্রিংকে দলে ক্যাপচার করি 4যা ইঙ্গিত দেয় যে আমরা একটিতে বর্তমান চরিত্রটি খুঁজে পেয়েছি indicates বিস্তৃত বিট। যদি \1মেলে না, 4কোনও কিছুই ক্যাপচার করবে না এবং এটি ?নিশ্চিত করে যে ব্যর্থ চেহারাটি হ'ল সমাধানকারীকে মোটেই প্রভাবিত করবে না।

সবশেষে সমাধান শেষ হওয়ার পরে, আমরা কেবল \4এই চেহারাটি ব্যবহার করা হয়েছিল কিনা তা যাচাই করে দেখি । যদি তা হয় তবে আমরা বর্তমানের চরিত্রটি এর সাথে প্রতিস্থাপন করতে চাই /\।

একটি অসুবিধা রয়ে গেছে: জায়গার সঠিক পরিমাণ সরিয়ে নেওয়া। আমি এখনও অবধি খুঁজে পাওয়া এটি করার সবচেয়ে সংক্ষিপ্ততম উপায়টি হল একটি স্থান সহ একটি স্থান withোকানো /\এবং তারপরে একটি পৃথক পদক্ষেপে mar চিহ্নিতকারী জায়গাগুলির প্রত্যেকটির জন্য জিহ্বার মধ্যে একটি স্থান থেকে মুক্তি পাওয়া:

+` (.*~|~.*) 
$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এবং একটি ড্রপ ., প্রতিটি প্রতিস্থাপন জন্য মাঝখান থেকে সকল বৈধ স্ট্রিং উপর সর্বনিম্ন দৈর্ঘ্য স্ট্রিং নিতে তারপর প্রতিস্থাপন Xs এর সাথে /\।

আমি পুনরাবৃত্তকারীগুলি সহ আরও কয়েকটি পদ্ধতির চেষ্টা করেছি, তবে তারা বেশ অগোছালো হয়ে গেছে। আমি আরও শিখেছি যে 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~"~"&

খাঁটি ফাংশনটিকে যুক্তি হিসাবে স্ট্রিং গ্রহণ করে। আশা .বদলে সাপ মধ্যে।

আমি ভাবিনি যে এটি খারাপ হবে ... আমি একসাথে এটি ছড়িয়ে দেওয়ার এবং সমস্ত কিছু অনুমিত করার আগে যা ছিল তা এখানে Here

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
সূত্র
শুরু করে 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নতুন সাপগুলি পৃথক করে এমন স্থানকে ছোট করে রেখে প্রতিটি অংশ স্বাভাবিক বা প্রসারিত পরিবর্তিত বাম এবং ডান দেহগুলি তৈরি করি । গণিত স্ট্রিংয়ের মোট দৈর্ঘ্য এমনভাবে আবদ্ধ যাতে অনুসন্ধান শেষ হয়।
— coredump
সূত্র
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] =>  <|=||:)~~(:||||>

অবশ্যই এটি আরও ভাল করা যেতে পারে (আমি কীভাবে বুঝতে পারি না :))।
গল্ফ করার সময় আমি স্পষ্ট কিছু মিস করেছি কিনা তা আমাকে জানান (এটি আমার প্রথম কোডগল্ফ, আমি বোকামি কিছু করছি: পি)

— Kamehameha
সূত্র
@ এসপি 3000 এটি ভাল। প্রতিস্থাপন করা exitহয়েছে sys.exit()(ভুলে exitগিয়েছেন) এবং আপনি ঠিক বলেছেন, __import__সরানো যেতে পারে, যা 20 টি চর এর মতোই শেষ হয়েছে :)
— কামেমেহেহায়
থাম্বের বিটিডব্লিউ রুল: অ্যালাইজিংয়ের জন্য আপনার > 6দু'বার ব্যবহার করলে অ্যালিজিংয়ের জন্য চরগুলি দরকার , > 3আপনি যদি তিনবার ব্যবহার করেন তবে চরগুলি। আমি নিশ্চিত নই যে f=' 'উপনামটি মূল্যবান (আমি দুইবার গণনা করি)
— Sp3000
@ Sp3000 হ্যাঁ আপনি ঠিক বলেছেন। পূর্ববর্তী সংস্করণে আমি এই পরিবর্তনশীলটি তিনবার ব্যবহার করেছি। আমাকে আরও
— কয়েকটা
1

05 এ বি 1 ই , 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)
— কেভিন ক্রুইজসেন
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.