আমার ডাউনস্ল্যাশগুলি আঁকো

60

প্রোগ্রামার হিসাবে আপনি সম্ভবত ফরোয়ার্ড স্ল্যাশ এবং পিছনের স্ল্যাশ শুনেছেন। তবে আপনি কি নেমে যাওয়ার কথা শুনেছেন? আপনি যখন স্ল্যাশগুলির একটি গুচ্ছ গ্রহণ করেন, তখন তাদের প্রান্তটি সংযুক্ত করুন এবং তাদের নীচে যেতে আঁকুন।

আজকের চ্যালেঞ্জের জন্য, আপনাকে অবশ্যই এমন একটি প্রোগ্রাম বা ফাংশন লিখতে হবে যা পুরোপুরি স্ল্যাশ সমন্বিত একটি স্ট্রিং নেবে এবং সেগুলি সংযোগকারী একটি লাইনে নীচের দিকে টানা সমস্ত স্ল্যাশকে আউটপুট করবে। উদাহরণটি দেখলে এটি আরও অনেক স্পষ্ট হবে। স্ট্রিং দেওয়া \\\//\/\\, আপনি আউটপুট করা উচিত:

\
 \
  \
  /
 /
 \
 /
 \
  \

এখানে কিছু স্পষ্টতা রয়েছে:

  • প্রতি লাইনে অবশ্যই একটি স্ল্যাশ থাকতে হবে।

  • প্রথম লাইনে 0 টি নেতৃস্থানীয় স্পেস থাকবে।

  • প্রতিটি জোড়া স্ল্যাশের জন্য:

    • যদি তারা একে অপরের থেকে পৃথক হয় তবে সেগুলি একই কলামে আঁকা হবে। উদাহরণস্বরূপ, \/দেবে:

      \
/

    • যদি তারা একই চরিত্র হয় তবে নীচের দিকটি একটি দিকে নির্দেশিত দিকের দিকে , এটি একটি ব্যাকস্ল্যাশের জন্য ডানদিকে যাচ্ছে এবং একটি সামনের দিকে স্ল্যাশের জন্য বাম দিকে অগ্রসর হচ্ছে। তাই \\//দেবে

      \
 \
 /
/

  • যতক্ষণ না এটি আউটপুটটির চাক্ষুষ চেহারা পরিবর্তন করে না ততক্ষণ প্রতিটি লাইনে অতিরিক্ত ট্রেলিং হোয়াইটস্পেস থাকতে পারে। এক পর্যন্ত শীর্ষস্থানীয় এবং শীর্ষস্থানীয় নতুন লাইন গ্রহণযোগ্য। অতিরিক্ত নেতৃস্থানীয় স্থানের অনুমতি নেই !

এটিকে আরও সহজ রাখার জন্য, আপনি ধরে নিতে পারেন যে স্ট্রিংটিতে কখনও খুব বেশি ফরোয়ার্ড স্ল্যাশ থাকবে না। অন্য কথায়, ইনপুটটির কোনও উপসর্গটিতে ব্যাকস্ল্যাশগুলির চেয়ে বেশি ফরোয়ার্ড স্ল্যাশ থাকবে না , সুতরাং কোনও ইনপুট পছন্দ হবে না \\////বা //কখনই দেওয়া হবে না। এর অর্থ হ'ল প্রতিটি ইনপুট ব্যাকস্ল্যাশ দিয়ে শুরু হবে।

যদি আপনার ইনপুটটি স্ট্রিং আক্ষরিক হিসাবে নেওয়া হয় তবে এটি প্রয়োজনীয় হলে আপনি ব্যাকস্ল্যাশ থেকে রক্ষা পেতে পারেন। আপনাকে কখনই কোনও ইনপুট হ্যান্ডেল করতে হবে না যা খালি, বা কোনও স্ল্যাশ ছাড়া অন্য অক্ষর রয়েছে।

আপনি কোনও যুক্তিসঙ্গত ফর্ম্যাট দ্বারা আউটপুট করতে পারেন ।

যথারীতি, এটি একটি কোড-গল্ফ চ্যালেঞ্জ, সুতরাং আপনি যদি এমন ভাষা বেছে নেন যেখানে এটি বরং কঠিন the আপনি যে কোনও আকর্ষণীয় কৌশল বাইটগুলি বন্ধ করে রাখবেন তা ব্যাখ্যা করার জন্য বোনাস পয়েন্টস!

উদাহরণ

#Input
\\\\\\\\\\\

#Output
\
 \
  \
   \
    \
     \
      \
       \
        \
         \
          \

#Input
\\\//\\/\//\\///

#Output
\
 \
  \
  /
 /
 \
  \
  /
  \
  /
 /
 \
  \
  /
 /
/


#Input
\/\/\/

#Output
\
/
\
/
\
/
code-golf  string  ascii-art 
— ডিজেএমসিএমহেম
সূত্র
9
ব্যাকস্ল্যাশগুলি
— ক্ষোভজনক
— ডিজিটাল ট্রমা

উত্তর:

20

জিএনইউ সেড, ২০

s|\\|&^L|g
s|/|^H/^L^H|g

নোট করুন ^Lএবং ^Hআক্ষরিক ফর্মফিড এবং ব্যাকস্পেস অক্ষর (0x12 এবং 0x8)।

এই উত্তরটি ব্যাকস্পেস এবং ফর্মফিড অক্ষর ব্যবহার করে কার্সারটিকে প্রায় ঘুরিয়ে নিয়ে কাজ করে। স্ল্যাশ / ব্যাকস্ল্যাশগুলি ফাঁকা স্থান সহ বাম-প্যাডযুক্ত নয় - এটি নিশ্চিত নয় যে এই উত্তরটি অযোগ্য ঘোষণা করবে al এটি টিআইওতে কাজ করে না, তবে সাধারণ টার্মিনালগুলিতে এটি দুর্দান্ত দেখায়xterm এবং gnome-terminal।

নীচে এই এসডি স্ক্রিপ্ট পুনরায় তৈরি করুন:

base64 -d <<< c3xcXHwmDHxnCnN8L3wILwwIfGc= > downslash.sed

এটি নিম্নলিখিত হিসাবে চালান:

$ echo '\\\//\/\\' | sed -f downslash.sed
\ 
 \ 
  \ 
  /
 /
 \ 
 /
 \ 
  \ 

$

ব্যাখ্যা:

s|\\|&^L|g     # move cursor down after every "\"
s|/|^H/^L^H|g  # move cursor left before every "/", then after, down and left again
— ডিজিটাল ট্রমা
সূত্র
14

কাঠকয়লা , 13 12 11 বাইট

ＦＳ¿⁼ι/↓¶/↘ι

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। অতিরিক্ত //গুলি সমর্থন করে । ব্যাখ্যা:

 Ｓ              Input string
Ｆ               Loop over each character
  ¿             If
    ι           Current character
   ⁼            Equals
     /          Literal /
      ↓¶        Move left
      ↓ /       Print a / downwards
         ↘ι     Else it's a \ so print that down and right
— নিল
সূত্র
আমি মনে করি ↓¶বর্ণনায় = "বাম দিকে সরান" সঠিক নয়।
— জোনাথন অ্যালান
@ জোনাথান অ্যালান এটি সঠিক (নতুন প্রিন্ট মুদ্রিত = বাম দিকে সরানো), যদিও এটি সম্ভবত "প্রিন্ট \n/ডাউন" বলতে আরও পরিষ্কার হবে
— এএসসিআইআই-কেবল
আমি বলিনি print \n/ downকারণ আমি অনুভব করেছি যে কোডটির আক্ষরিক অনুবাদের চেয়ে কোডটির প্রভাব বর্ণনা করা আরও সহায়ক।
— নিল
1
(গালে জিহ্বা: এর প্রভাবটি বর্ণনা = MyCode - Do the spec)। আমি এখনই এটি পেয়েছি যদিও প্রভাবটি বাম দিকে সরানো হয়; "বাম দিকে সরান (নীচের দিকে মুদ্রণের দিকনির্দেশ দিয়ে একটি নতুন লাইন মুদ্রণ করে) বলার উপযুক্ত হতে পারে"।
— জোনাথন অ্যালান
সবার মধ্যে সবচেয়ে সংক্ষিপ্ত এবং স্ব-ব্যাখ্যামূলক!
— j4hangir
10

/// , 119 বাইট

/// এর কোনও ইনপুট কমান্ড নেই, সুতরাং ইনপুট অবশ্যই প্রোগ্রামটিতে এম্বেড করা উচিত। এই একের জন্য, ইনপুট স্ট্রিংটি কেবল সংযোজন করা হয়, কোনও পালানোর দরকার নেই।

/=/\/\///M/
|%%=N/%|||=C/BA=\/\\/\/C\\=C\\/CbC=B\A\=CfC=AB=/A/%Mxy=B/|z%N|x|y% %N%x|y%%% |fzN%M%b|zN|M|%
=|/AB\\=%/|=AC

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

  • নীচে, একটি ইনপুট \\/\// প্রোগ্রামের জন্য প্রদর্শনের জন্য যুক্ত করা হবে।
  • ␤ ইনলাইন কোডে নতুন লাইনের প্রতিনিধিত্ব করতে ব্যবহৃত হয়।

শব্দ সংক্ষেপ

/=/\/\///M/␤|%%=N/%|||=C/BA=প্রোগ্রামটির শুরুতে গল্ফিং সংক্ষিপ্তসারগুলির বিকল্প রয়েছে।

  • =বিস্তৃতি //, Mকরতে ␤|%%, Nকরতে %|||এবং Cকরতে BA।

  • এটির পরে বর্তমান প্রোগ্রামটি হয়ে যায়

    /\/\\/\/BA\\//BA\\/BAbBA//B\A\//BAfBA//AB///A/%
|%%xy//B/|z%%||||x|y% %%|||%x|y%%% |fz%|||%
|%%%b|z%||||
|%%|%
//|/AB\\//%/|//ABA\\/\//

ইনপুট পুনর্নির্মাণ

পরবর্তী পর্যায়ে সংযুক্ত ইনপুট স্ট্রিংটি আরও ব্যবহারযোগ্য আকারে রূপান্তরিত করে। যেহেতু এটি সম্পূর্ণরূপে /// এর দুটি কমান্ড অক্ষর ধারণ করে, তাই বেস প্রোগ্রামটি ম্যাংলিং এড়াতে কিছুটা যত্ন নেওয়া উচিত।

  • প্রথম উল্লেখযোগ্য বিকল্প, /\/\\/\/BA\\/স্ট্রিংটির /\সাথে প্রতিস্থাপন করে /BA\।
    • বেস প্রোগ্রামটি /\এই সময়ে ধারণ করে না , সুতরাং এই প্রতিস্থাপন এটি প্রভাবিত করে না।
    • যাইহোক, এটি যুক্ত ইনপুট স্ট্রিংগুলি এর সিকোয়েন্সগুলির \পরে অনুসরণ করে of/ , যা ABAবেস প্রোগ্রামের শেষে এক সাথে নিম্নলিখিত বিকল্পগুলির সাথে এর মাধ্যমে পুনরাবৃত্তি সম্ভব করে।
    • এর পূর্ব ABAউপসর্গ সহ , উদাহরণস্বরূপ ইনপুট স্ট্রিং এখন হয়ে যায় ABA\\/BA\//।
  • পরবর্তী প্রতিস্থাপন, দ্বারা /BA\\/BAbBA/প্রতিস্থাপিত BA\হয়BAbBA ।
    • যেহেতু /// বিকল্পগুলি আর মেলে না তার পুনরাবৃত্তি হয় \, এটি ইনপুট স্ট্রিংয়ের সমস্ত মাধ্যমে পুনরাবৃত্তি করে যা উপসর্গের সাথে এখন হয়ে যায়ABAbBAbBA/BAbBA//
  • একইভাবে, /B\A\//BAfBA/পরিবর্তন BA/করার BAfBAমাধ্যমে iterating /গুলি।
    • পালানো \এই প্রতিস্থাপনে দরকার কারণ অন্যথায় এটি পূর্বের দ্বারা ম্যাঙ্গেল করা হবে।
    • ইনপুটটি এখন পরিণত হয়েছে ABAbBAbBAfBABAbBAfBAfBA।
  • এরপরে /AB//এনকোডিংয়ের কিছু অতিরিক্ত অতিরিক্ত অংশগুলি সরিয়ে ফেলা হয় turningAbBAbBAfBAbBAfBAfBA ।
    • এটি পরে প্রোগ্রামের বিকল্প ABথেকে একটি অপসারণ /|/AB\\/করে, এটি উপরের থেকে রক্ষা করার জন্য প্রয়োজনীয় ছিল/\ কৌশলগুলি ।
    • এই মুহুর্তে প্রতিটি \আসল ইনপুট স্ট্রিং হয়ে গেছে AbBএবং প্রতিটি /হয়ে গেছে AfB। ( bএবং fপিছিয়ে এবং সামনে দাঁড়াও।) Aশেষে একটি বিভ্রান্তি আছে ।
  • পরবর্তী দুটি বিকল্প চূড়ান্ত পর্যায়ে চলার জন্য প্রোগ্রামের টুকরাগুলির সাথে সমস্ত Aগুলি এবং Bগুলিকে প্রতিস্থাপন করে । প্রতিস্থাপনের স্ট্রিংগুলিতে, %গুলি এবং |এনগুলি এনকোড করুন যা যথাক্রমে কী /গুলি এবং \গুলি হয়ে উঠবে । এর দুটি সুবিধা রয়েছে:
    • এর বিপরীতে /এবং \, %গুলি এবং |অনুলিপিগুলি অনুলিপি করার জন্য পলায়নের দরকার নেই।
    • প্রতিস্থাপনের স্ট্রিংগুলি সাবস্ট্রিং যুক্ত এড়ায় /\যা অন্যথায় পূর্বের ম্যানিপুলেশনগুলি দ্বারা ম্যাঙ্গেল করা হত।
  • এর পর প্রতিকল্পন /|/\\/(পূর্বে /|/AB\\/) এখন decodes |গুলি, যার পরে নিম্নলিখিত /%/|//পরিণত হয়েছে /%/\//এবং decodes %গুলি।

চূড়ান্ত পর্যায়ে প্রোগ্রাম কাঠামো

এই মুহুর্তে, বেস প্রোগ্রামটি তার সমস্ত বিকল্পগুলি চালাচ্ছে এবং যা অবশিষ্ট রয়েছে তা ইনপুট স্ট্রিংয়ের প্রোগ্রাম-এনকোডিং।

  • প্রতিটি ইনপুট অক্ষর একটি উপ-প্রকল্পে পরিণত হয়েছে

    /
\//xy*\z//\\\\x\y/ //\\\/x\y/// \fz/\\\/
\///b\z/\\\\
\//\/

    (trailing সম্পর্কে newline), যেখানে *প্রতিনিধিত্ব করে পারেন fএকটি মূল জন্য /, অথবা bএকটি মূল জন্য \।

  • /␤\//xyপ্রোগ্রামের শেষে একটি অসম্পূর্ণ প্রতিস্থাপন কমান্ডও রয়েছে, যা /পূর্ববর্তী উপ-প্রকল্পের বিকল্পগুলির জন্য প্রয়োজনীয় সরবরাহ ব্যতীত কোনও প্রভাব ফেলবে না ।

ভাগ করা সাবস্ট্রিং

সাবপ্রোগ্রামগুলির মাধ্যমে চূড়ান্ত পুনরাবৃত্তি শুরুর আগে, ফর্মের প্রতিটি চরিত্রের উপপ্রগ্রামের পরে সীমানা পেরিয়ে একটি স্ট্রিং থাকে \/␤/।

  • এই সাবস্ট্রিংগুলি একটি ভাগ করা বৈশ্বিক রাষ্ট্র হিসাবে ব্যবহৃত হয়। প্রোগ্রামের বাকী সমস্ত বিকল্পগুলি সেগুলি অভিন্ন এবং সমান্তরালভাবে হেরফের করবে, যেমন প্রতিটি ইনপুট অক্ষরের সাবপ্রগ্রামের শেষে এই ভাগ করা সাবস্ট্রিংয়ের অনুলিপি (চূড়ান্ত ব্যতীত)/ , বিকল্পগুলি অ্যাঙ্কর করে) তার জন্য লাইন প্রিন্ট করার জন্য চালানো হবে অক্ষর।
  • সাবস্ট্রিংয়ের প্রাথমিক সংস্করণটি কেবলমাত্র একটি লাইন প্রিন্টিংকে উপস্থাপন করে /যা সঠিক লগ্নিকল্পিত "পূর্ববর্তী রেখা" যার ফলে প্রথম লাইনের প্রথম অক্ষরটি তার লাইনের শুরুতে মুদ্রিত হয়।
  • সাধারণভাবে, মুদ্রণের পদক্ষেপের সময়, ভাগ করা সাবস্ট্রিংটিতে অনেকগুলি স্থান, \\বা \/, একটি নতুন লাইন এবং নিম্নলিখিত থাকে /।

একটি চরিত্রের সাবপ্রগ্রাম চালাচ্ছি

\একে অপরের দ্বারা মিলে যাওয়া এবং ম্যাংগল হওয়া থেকে বিরত রাখতে (অন্যান্য উপ-প্রোগ্রামের অন্যান্য অনুলিপি সহ) নিম্নলিখিত কয়েকটি বিকল্পের ভিতরে অতিরিক্ত অতিরিক্ত রয়েছে। এটি অর্জন উভয় কারণে xএবং yপ্রয়োজনীয় কারণও ।

  • একটি অক্ষর subprogram প্রথম প্রতিকল্পন, /␤\//xyf\z/বা /␤\//xyb\z/, কারণ ␤/ভাগ সাবস্ট্রিং শেষে পরিণত এ xyfzবা xybz, অবিলম্বে নিম্নলিখিত \/বা \\।
  • প্রতিকল্পন /\\\\x\y/ /প্রতিস্থাপন \\xyএকটি স্থান দ্বারা, এবং প্রতিস্থাপন /\\\/x\y//প্রতিস্থাপন \/xyকিছুই দ্বারা।
    • পূর্ববর্তী ইনপুট অক্ষরটি যথাক্রমে এক \বা হ'ল এগুলি প্রয়োগ /হয়।
    • ভাগ করা স্ট্রস্ট্রিংয়ে এখন \পরবর্তী মুদ্রণের জন্য যথাযথ সংখ্যক স্থান রয়েছে , তার পরে fzবা এর পরে bz।
  • প্রতিস্থাপনটি / \fz/\\\/␤\//প্রতিস্থাপন ​ fzকরে \/␤/এবং /b\z/\\\\␤\//প্রতিস্থাপন bzকরে \\␤/।
    • বর্তমান ইনপুট অক্ষর যথাক্রমে /বা এগুলি প্রয়োগ \হয়।
    • প্রথমটি /সঠিকভাবে রাখার জন্য একটি অতিরিক্ত স্থান খায় ।
      • যদি এই স্থানটি অনুপস্থিত (যেমন ইনপুট উপসর্গের শর্ত লঙ্ঘন করে), নিম্নলিখিত বিকল্পগুলি ভুল ব্যাখ্যা করা যায়, প্রচুর জাঙ্ক মুদ্রণ করে এবং সাধারণত একটি আঘাত করে ///, যা একটি অসীম লুপ।
    • প্রত্যেকে তার নিজস্ব চরিত্রটি মুদ্রণের জন্য সঠিক কমান্ড যুক্ত করে ␤/এবং ভাগ করা সাবস্ট্রিংয়ের শেষে মূলটি পুনরায় স্থাপন করে।
  • চরিত্রের সাবপ্রগ্রামটি এখন ভাগ করা সাবস্ট্রিংয়ের অনুলিপিতে পৌঁছেছে, যা তার লাইনটি মুদ্রণের জন্য প্রস্তুত।

শেষ চরিত্রের সাবপ্রোগ্রামটি চলার পরে, প্রোগ্রামটির অবশিষ্টাংশটি /␤\//xy। যেহেতু এটি অনুপস্থিত ফাইনাল সহ একটি অসম্পূর্ণ বিকল্প /, প্রোগ্রামটি এড়িয়ে যায় এবং সাধারণত থেমে থাকে।

— আরজান জোহানসেন
সূত্র
1
কাজের জন্য সঠিক ভাষা! লোল
— ডিজেএমসিএমহেম
6

জেলি , 14 বাইট

=”\ðḤ’+\_⁸⁶ẋżY

ফলাফল মুদ্রণ একটি সম্পূর্ণ প্রোগ্রাম।

এটি অনলাইন চেষ্টা করুন!

কিভাবে?

=”\ðḤ’+\_⁸⁶ẋżY - Link: list of characters, s    e.g. "\\\//\\/"
 ”\            - literal '\'                         '\'
=              - equal? (call this e)                [1, 1, 1, 0, 0, 1, 1, 0]
   ð           - new dyadic chain f(e, s)
    Ḥ          - double                              [2, 2, 2, 0, 0, 2, 2, 0]
     ’         - decrement                           [1, 1, 1,-1,-1, 1, 1,-1]
      +\       - cumulative reduce with addition     [1, 2, 3, 2, 1, 2, 3, 2]
         ⁸     - chain's left argument, e            [1, 1, 1, 0, 0, 1, 1, 0]
        _      - subtract (# of leading spaces)      [0, 1, 2, 2, 1, 1, 2, 2]
          ⁶    - literal ' '                         ''
           ẋ   - repeat                              [""," ","  "," "," "," ","  ","  "]
            ż  - zip with s                          [["",'\'],[" ",'\'],["  ",'\'],["  ",'/'],[" ",'/'],[" ",'\'],["  ",'\'],["  ",'/']]
             Y - join with newlines                  ["",'\','\n'," ",'\','\n',"  ",'\','\n',"  ",'/','\n'," ",'/','\n'," ",'\','\n',"  ",'\','\n',"  ",'/']
               - implicit print - this smashes the lists (shown as "..." above) and the characters (shown as '...' above) together.
— জোনাথন অ্যালান
সূত্র
5

এমএটিএল , 23 19 18 বাইট

@ স্যাঞ্চাইজসকে ধন্যবাদ 1 বাইট

fGqoEq1yd~h*YsGZ?c

ইনপুট একটি স্ট্রিং যা একক উদ্ধৃতিতে আবদ্ধ।

এটি অনলাইন চেষ্টা করুন! বা পরীক্ষার কেস যাচাই করুন: 1 , 2 , 3 ।

ব্যাখ্যা

'\\\//\/\\'উদাহরণ হিসাবে ইনপুট বিবেচনা করুন ।

f      % Implicit input. Array of indices of nonzeros. Since all chars in the input
       % have nonzero code point, this gives [1 2 ... n] where n is input length
       % STACK: [1 2 3 4 5 6 7 8 9]
G      % Push input again
       % STACK: [1 2 3 4 5 6 7 8 9], '\\\//\/\\'
qo     % Subtract 1 from (the code-point) of each char and then compute modulo 2.
       % This transforms '\' into 1 and '/' into 0
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 0 0 1 0 1 1]
Eq     % Double, subtract 1. This transforms 0 into -1
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1]
1y     % Push 1 and duplicate from below
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1], 1, [1 1 1 -1 -1 1 -1 1 1]
d~     % Consecutive differences, logical negation: gives 1 if consecutive entries
       % are equal, 0 otherwise
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1], 1, [1 1 0 1 0 0 0 1]
h      % Horizontally concatenate
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1], [1 1 1 0 1 0 0 0 1]
*      % Element-wise multiplication
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 0 -1 0 0 0 1]
Ys     % Cumulative sum
       % STACK: [1 2 3 4 5 6 7 8 9], [1 2 3 3 2 2 2 2 3]
G      % Push input again
       % STACK: [1 2 3 4 5 6 7 8 9], [1 2 3 3 2 2 2 2 3], '\\\//\/\\'
Z?     % Build sparse matrix with those row indices, column indices, and values
       % STACK: [92  0  0;
                  0 92  0;
                  0  0 92;
                  0  0 47;
                  0 47  0;
                  0 92  0;
                  0 47  0;
                  0 92  0;
                  0  0 92]
c      % Convert to char. Char 0 is shown as space. Implicitly display
       % STACK: ['\  ';
                 ' \ ';
                 '  \';
                 '  /';
                 ' / ';
                 ' \ ';
                 ' / ';
                 ' \ ';
                 '  \']
— লুইস মেন্ডো
সূত্র
আপনার সূচকগুলি পেতে কিছুটা আলাদা অ্যালগরিদম দ্বারা একটি বাইট বন্ধ: অনলাইনে চেষ্টা করে দেখুন!
— সানচিইস
@ সাঞ্চাইজস আপনার অত্যন্ত উপযুক্ত সম্পাদনার জন্য ধন্যবাদ!
— লুইস মেন্ডো 21
5

সি # (.নেট কোর) , 74 88 82 78 77 76 + 18 বাইট

-1 বাইট কেভিন ক্রুইজসেনকে ধন্যবাদ

s=>s.Select((x,i)=>$"{x}".PadLeft((x-s[0])/45-~s.Take(i).Sum(y=>y<92?-1:1)))

প্রতিটি লাইনের জন্য একটি স্ট্রিংয়ের সংগ্রহ আউটপুট দেয়। বাইট গণনা এছাড়াও অন্তর্ভুক্ত:

using System.Linq;

এটি অনলাইন চেষ্টা করুন!

By 77 বাইট উত্তরের ব্যাখ্যা:

s =>                              // Take input, a string
    s.Select((x, i) =>            // Replace every character with:
        $"{x}"                    //     The character as string
        .PadLeft(                 //     Pad with this many spaces:
            s.Take(i)             //         Take characters, in the input string, preceding current one
            .Sum(y =>             //         Sum them by:
                y < 92 ? -1 : 1   //             If it's a \ add 1, if / subtract 1
            )
            + (x - s[0]) / 45 + 1 //         If first slash is a / add one more space, if current slash is a \ add one more space (I got this through power of MATHS!)
                                  //         How I arrived at this function:
                                  //         + x / 48        If current slash is a \ add one more space
                                  //         - s[0] / 48 + 1 If the first slash is a / add one more space
        )
    )
— গ্রজেগোর্জ পুয়াওস্কি
সূত্র
3
জন্য কাজ করে না /\\/\\/।
— নীল
@ নিল তা নির্দেশ করার জন্য আপনাকে ধন্যবাদ! সংশোধন করা হয়েছে।
— গ্রেজগোর্জ পুয়াওস্কি
1
আমি জানি এটা অনেক দিন হয়ে গেছে, কিন্তু আপনি পরিবর্তন করে একটি বাইট সংরক্ষণ করতে পারবেন s.Take(i).Sum(y=>y<92?-1:1)+(x-s[0])/45+1করার(x-s[0])/45-~s.Take(i).Sum(y=>y<92?-1:1)
— কেভিন Cruijssen
কেভিন ক্রুজসেন ভাল লাগছে!
— গ্রেজগোর্জ পুয়াওস্কি
4

05 এ বি 1 ই , 14 বাইট

ÇÈx<ηOs-W-ISú»

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

Ç                # convert input string to a list of ascii codes
 È               # check each for evenness
  x              # push a doubled copy
   <             # decrement
    η            # compute prefixes
     O           # sum each prefix
      s          # swap the unaltered copy of evenness to the top
       -         # subtract from the prefix-sum list
        W-       # subtract the minimum value
          IS     # push input split to a list of chars
            ú    # pad each with the number of spaces computed
             »   # join on newline
— Emigna
সূত্র
1
জন্য কাজ করে না /\\/\\/।
— নীল
Ç¥.¥0<.SηOv¹Nèy<ú, বাইনারি মধ্যে sobbing
— যাদু অক্টোপাস Urn
3

আর , 122 121 বাইট

-1 বাইট জিউসেপিকে ধন্যবাদ

x=el(strsplit(scan(,""),""));n=seq(x);y=x>"/";for(i in n)cat(rep(" ",diffinv(y[n[-1]-1]+y[n[-1]]-1)[i]),x[i],"\n",sep="")

এটি অনলাইন চেষ্টা করুন!

অতিরিক্ত সাদা স্থান সহ:

x = el(strsplit(scan(,""),""))
n = seq(x)
y = x>"/"
for(i in n) {
  cat(rep(" ", diffinv(y[n[-1]-1]+y[n[-1]]-1)[i]), x[i], "\n", sep="")
}

ব্যাখ্যা: এই উত্তরটি পর্যবেক্ষণের ভিত্তিতে তৈরি করা হয়েছে যে শীর্ষস্থানীয় স্পেসগুলির সংখ্যা প্রতিটি লাইনকে -1 দ্বারা পরিবর্তিত করে এবং আরও / পূর্ববর্তী এবং বর্তমান লাইনের ।

আমাদের যদি এন স্ল্যাশ থাকে তবে চলকটি yদৈর্ঘ্যের এন এর ভেক্টর \, অন্য পদের সাথে প্রতিটি পদের জন্য 1 থাকে । অতএব, প্রতি লাইনে শীর্ষস্থানীয় স্থানের সংখ্যাটি পেতে, আমরা গণনা করি y[1:(N-1)] + y[2:N] - 1। ফাংশনটি diffinv0 দিয়ে শুরু করে এই পার্থক্যগুলিকে একটি অনুক্রমের সাথে রূপান্তর করে rest

— user2390246
সূত্র
1
হাহ। আমি 119 বাইটের জন্য একেবারে ভিন্ন পন্থা নিয়েছিলাম যা আমাকে ভাবতে বাধ্য করে যে আমরা যদি আমাদের পদ্ধতির সমন্বয় করতে পারি। (এর দুর্দান্ত ব্যবহার diffinv;) এছাড়াও আপনি y=x>")"-1 বাইটের জন্য সেট করতে পারেন
— জিউসেপ
@ জিউজ্পে আপনার এই পোস্টটি পোস্ট করা উচিত যে পৃথক উত্তর হিসাবে এটি আলাদা আলাদা পদ্ধতির। আপনার করা এড়ানো একটি দুর্দান্ত উপায় strsplit, যা সর্বদা খুনি a আপনি বিখ্যাত ব্যবহার করতে পারেন diffinv!
— ব্যবহারকারী 2390246
1
এছাড়াও আমি মনে করি আপনি যদি library(methods)শিরোনামটি রেখে দেন (যা প্যাকেজটি অংশ বেস হিসাবে যেহেতু ঠিক আছে ডাব্লু / ও জরিমানা হওয়া উচিত), আপনি ব্যবহার করতে পারেন el। এছাড়াও, diffinvপরিণত হিসাবে হিসাবে দীর্ঘ হিসাবে পরিণত cumsum! :)
— জিউসেপ
হ্যাঁ, আমি এটিও বুঝতে পেরেছিলাম, এটি সেই প্রসঙ্গে যথেষ্ট কাজ করে না
— ব্যবহারকারী 2390246
ভাল, আমি একটি workaround সঙ্গে এসেছিলেন , কিন্তু হ্যাঁ, যে *Sজিনিস স্ক্রু আপ।
— জিউসেপ
3

মস্তিষ্ক-ফ্লাক , 175 বাইট (174 অক্ষর + 1 পতাকা)

-cপতাকা নিয়ে দৌড়াও।

{(({})<(())>){({}[()]<([{}])>)}{}(({}<>{}<><({}<>)((()()()()()){})>)<{({}[()]<((((()()()()){}){}){})>)}>{})<>}<>{}{({}<>)(({})(())){({}[()]<([{}]())>)}{}{<>{}<>(<{}>)}{}<>}<>

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

{ for each char in the input...
  (({})<(())>){({}[()]<([{}])>)}{} push 1/-1 for backslash/slash
  ((
   {}<>{}<> add the 1/-1 to a running total
   <
    ({}<>) move slash/backslash to other stack
    ((()()()()()){}) newline
   >
  )<{({}[()]<((((()()()()){}){}){})>)}>{}) spaces
  <>
}<>{} end for
reverse data order, removing one space before backslash
{({}<>)(({})(())){({}[()]<([{}]())>)}{}{<>{}<>(<{}>)}{}<>}<>
— MegaTom
সূত্র
আমি সবসময় ব্রেইন ফ্ল্যাঙ্ক upvote। : ডি
— ডিজেএমসিহেম
3

রুবি , 80 76 বাইট

-4 বাইট ধন্যবাদ manatwork ধন্যবাদ

puts"\\";$*[i=0].chars.each_cons 2{|b,c|puts" "*(b==c ?b==?/?i-=1:i+=1:i)+c}

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা:

puts "\\"           # Output the first backslash
$*[i=0].            # Get the first argument and set i to 0
chars.              # Go through every individual character,
each_cons 2 { |b,c| # In pairs to compare easily
                    #
    puts " " *      # Decide how many padding spaces to use based on the value
                    # of i. The expression inside the parenthesis will return
                    # i but before that, it will increment/decrement i based
                    # on what the previous character was.
                        #
    ( b==c ?            # if b == c
        b==?/ ?         #   if b == "/" (Going to the left)
            i-=1        #       return decremented i
            :           #   else        (Going to the right)
            i+=1        #       return incremented i
        :               # else
        i) +            #   return i
                    #
                c   # Finally, write the second of the characters that we're
}                   # iterating through.
— Pazzaz
সূত্র
1
কোন রুবি সংস্করণ? কোড ব্লক অনুসরণ করলে আমার কাছে প্যারামিটারের চারপাশে প্রথম বন্ধনীর দাবি রয়েছে .each_cons(2){…}। পরিবর্তন আপনি প্রতিস্থাপন সংরক্ষণ করতে পারবেন .each_char→ .chars।
— manatwork
@ মান্যাটওয়ার্ক আমার রুবি সংস্করণটি ২.৪.১। চরগুলি সম্পর্কে পরামর্শের জন্য ধন্যবাদ, আমি এটি সম্পর্কে জানতাম না।
— পাজ্জাজ
i+=নেস্টেড টের্নারি এক্সপ্রেশনটির শুরুতে গিয়ে এবং এর সাথে শেষ করে আপনি আরও দুটি বাইট সংরক্ষণ করতে পারেন -1:1:0।
— বেনজ 2240
3

জাভা 8, 121 118 110 109 102 বাইট

a->{String r="";int s=0,p=0,i;for(char c:a){for(i=s+=p+(p=c-63)>>5;i-->0;r+=" ");r+=c+"\n";}return r;}

-7 বাইটস @ নেভির বিট- ওয়াইজ ম্যাজিককে ধন্যবাদ জানায় । :)

ব্যাখ্যা:

এখানে চেষ্টা করুন।

a->{                    // Method with char-array parameter and String return-type
  String r="";          //  Return-String
  int s=0,              //  Amount of spaces
      p=0,              //  Previous characters (starting at 0)
      i;                //  Index-integer
  for(char c:a){        //  Loop over the input
    for(i=s+=p+(p=c-63)>>5;
                        //   If the current does not equals the previous character
                        //    Leave `s` the same
                        //   Else-if it's a '\':
                        //    Increase `s` by 1
                        //   Else (it's a '/'):
                        //    Decrease `s` by 1
                        //   And set the previous character to the current in the process
        i-->0;r+=" ");  //   Append `r` with `s` amount of spaces               
    r+=c+"\n";          //   Append the character + a new-line to the result
  }                     //  End of loop
  return r;             //  Return result-String
}                       // End of method
— কেভিন ক্রুইজসেন
সূত্র
1
102 বাইট:a->{String r="";int s=0,p=0,i;for(char c:a){for(i=s+=p+(p=c-63)>>5;i-->0;r+=" ");r+=c+"\n";}return r;}
— নেভায়ে
@ নেভা ধন্যবাদ আমি জানতাম এটি কিছুটা বিটওয়াইজ অপারেশন দিয়ে সংক্ষিপ্ত করা যেতে পারে, তবে এটি বের করতে পারিনি। প্রধানত কারণ আমি প্রভাব চেষ্টা সম্পর্কে ভুলে গেছি >>/ >>>/ <<... আমি শুধুমাত্র সঙ্গে কিছু বিষয় পরীক্ষা করা ছিল &/ |/ ~/ ^। ..>>
— কেভিন Cruijssen
3

সি (জিসিসি), 137 134 97 বাইট

এটি অনলাইন চেষ্টা করুন!

• 3 বাইট ধন্যবাদ এটাকোকে

Digital 37 বাইট ডিজিটাল ট্রমা এবং দ্য পাইরেটবেকে ধন্যবাদ

i,d;f(char*s){char c=s[i],n=s[++i];if(c){printf("%*c%c\n",d+1,c);(c-n)?d:(c==47)?--d:++d;f(s);}}

খুব বেশি অভিনব কিছু নয় যে কেবল একটি সরল রিকার্সিভ ফাংশন যা একটি স্ট্রিং নেয় এবং স্ল্যাশগুলি প্রিন্ট করে, নোট করুন যে ইনপুটটিকে প্রথমে ব্যাকস্ল্যাশগুলি থেকে বাঁচতে হবে।

ব্যবহার

f("\\\\\\//\\/\\\\",0,0);

Ungolfed

এটি পুরানো উত্তরের জন্য, এটি আপডেট করে দেখুন একটি অনলাইন লিঙ্কটি দেখুন!

f(char *s, i, d) {
    char c=s[i], n=s[++i];
    if(!c) return;
    for(int j=0; j<d; j++) printf(" ");
    printf("%c\n",c);
    f(s, i, (c!=n)?d:(c=='/')?d-1:d+1);
}

আউটপুট

এখানে চিত্র বর্ণনা লিখুন

— Asleepace
সূত্র
আপনি প্রতিস্থাপন করতে পারেন c=='\0'সঙ্গে !cএকই প্রভাবের জন্য।
— এটাকো
অসাধারণ ধন্যবাদ সবেমাত্র সমাধানটি আপডেট করেছে!
— স্লিপেসেস
আপনি printf("%*s%c", n, "", c)এন সি নেতৃস্থানীয় স্থানের সাথে চর সি মুদ্রণ করতে ব্যবহার করতে পারেন ?
— ডিজিটাল ট্রমা
আমি প্রায় নিশ্চিত করুন যে আপনি প্রতিস্থাপন কয়েক বাইট সংরক্ষণ করতে পারবেন আছি (c!=n)সঙ্গে c-nএবং তিন এক্সপ্রেশন সাজানোর। একই সাথে (c=='/')। এছাড়াও, আপনি '/'আক্ষরিক সংখ্যার সাথে প্রতিস্থাপন করতে পারেন 47। আমি মনে করি এটি মোট 7 বাইট।
1
— ASCII- কেবল
3

রেটিনা , 47 বাইট

^|\\
 $&
+m`^( *)( /|\\)(/| \\)
$1$2¶$1$3
m`^

এটি অনলাইন চেষ্টা করুন! লিঙ্কে পরীক্ষার কেস অন্তর্ভুক্ত রয়েছে। ব্যাখ্যা:

^|\\
 $&

প্রতিটি লাইনের শুরুতে এবং প্রতিটি আগে একটি স্থান যুক্ত করুন \।

+m`^( *)( /|\\)(/| \\)
$1$2¶$1$3

স্ট্রিংয়ের প্রথম দুটি অক্ষর বিবেচনা করুন। প্রথমটি যদি হয় /তবে ইনডেন্টটি হ্রাস করতে হবে; এটি ক্যাপচারের পূর্ববর্তী স্থান অন্তর্ভুক্ত করে অর্জন করা হয়েছে (যা সর্বদা বিদ্যমান কারণ এটি প্রথম পর্যায়ে যুক্ত করা হয়েছিল); দ্বিতীয়টি যদি হয় \\তবে এটি বাড়ানো দরকার; প্রথম পর্যায়ে ক্যাপচারে যোগ করা স্থানটি অন্তর্ভুক্ত করে এটি অর্জন করা সম্ভব। দ্বিতীয় অক্ষরটিকে সঠিক ইনডেন্ট দেওয়ার পরে, দ্বিতীয় এবং তৃতীয় চরিত্রের জন্য মঞ্চটি পুনরাবৃত্তি করা হয় ইত্যাদি etc.

m`^

অতিরিক্ত ইনডেন্ট সরান।

আমি একটি 94-বাইট সংস্করণ লিখেছি যা (আমার কাঠকয়ালের উত্তরের মতো) যে কোনও স্ল্যাশের সংমিশ্রণের অনুমতি দেয়: অনলাইনে চেষ্টা করে দেখুন! ব্যাখ্যা:

.$
¶$.`$* $&

শেষ স্ল্যাশ গ্রহণ করে এবং নিজের লাইনে একই অবস্থানে এন্ডেন্ট করে বলটি ঘূর্ণায়মান হয়ে নিন।

/
 /

সমস্ত ফরোয়ার্ড স্ল্যাশগুলিতে উপসর্গের স্পেস যাতে তারা ক্যাপচার করতে পারে।

+`^(.*)( /|\\)¶( *)( \\|/)
$1¶$3$2¶$3$4

বারবার ইনপুটটির শেষ স্ল্যাশ নিন এবং নীচের লাইনে স্ল্যাশ সহ এটি নিজের লাইনে সারিবদ্ধ করুন।

+ms`^(?<!^[\\/].*) (?!.*^[\\/])

কোনও বাম-ওভার ইন্ডেন্টেশন মুছুন।

G`.

এখন খালি ইনপুট মুছুন।

— নিল
সূত্র
2

লুয়া , 96 বাইট

c=0 for s in(...):gmatch(".")do c=c+(p==s and(s=="/"and-1or 1)or 0)p=s print((" "):rep(c)..s)end

এটি অনলাইন চেষ্টা করুন!

লুয়াতে আমি সবচেয়ে ছোট একজনের সাথে আসতে পারি। কমান্ড লাইন থেকে ইনপুট নেওয়া হয়।

এটি কয়েকটি কৌশল ব্যবহার করে:

  1. (...):gmatch(
    কমান্ড লাইন থেকে লুয়া প্রোগ্রামে একটি স্ট্রিং পাওয়ার এটি সংক্ষিপ্ততম ফর্ম হওয়া উচিত। ...অ্যাপ্লিকেশন Lua মধ্যে অভিব্যক্তি ফাংশন ঘোষণা উল্লেখিত হয়নি এবং ভারার্গস জন্য ব্যবহার করা হয় একটি ফাংশন কোনো বাড়তি পরামিতি ধারন করে না। যেহেতু লুয়া প্রোগ্রামের মূল সংস্থাটি কমান্ড লাইন আর্গুমেন্টটিকে তার পরামিতি হিসাবে একটি ফাংশন হিসাবে ডাকা হয়, তাই কমান্ড লাইন আর্গুমেন্টগুলি শেষ হয়ে যায় ...।
    এর চারপাশের প্রথম বন্ধনীগুলি সম্ভাব্য বহু-মূল্যবান করে তোলে... এক্সপ্রেশনটিকে একক অভিব্যক্তিতে রূপান্তরিত করে। এটি (কিছুটা অবাক করা) উদাহরণ বিবেচনা করুন: 
    function multipleReturnValues()
    return "abc", "def"
end
print(  multipleReturnValues()  ) --This prints: abc    def
print( (multipleReturnValues()) ) --This prints: abc
  2. লুয়া পার্সারের কোনও লাইন টার্মিনেটর বা বিবৃতিগুলির মধ্যে শ্বেত স্পেসের প্রয়োজন নেই, যতক্ষণ না দুটি স্টেটমেন্টের টোকেন স্পষ্টভাবে পৃথক করা যায় এবং বৈধ লুয়া কোডটির পাঠ্যটির কেবলমাত্র একটি ব্যাখ্যা রয়েছে।
  3. আপত্তিজনকভাবে and/ orযদি "তবে x 1 অন্য মান 2" যুক্তি যুক্ত হয়।
    লুয়ার andঅপারেটর যদি এটি মিথ্যা হয় তবে তার প্রথম যুক্তি ফিরিয়ে দেয়; অন্যথায়, এটি তার দ্বিতীয় যুক্তি ফিরে দেয়। orঅপারেটর তার প্রথম যুক্তি ফেরৎ যদি এটা truthy হয়; অন্যথায়, দ্বিতীয় তর্ক।
  4. pকোন আরম্ভের প্রয়োজন নেই।
    p==sইনপুট নির্বিশেষে লুপের প্রথম রানটিতে সর্বদা মিথ্যা হতে হবে। pলুপটি প্রবেশের আগে কোনও মান নির্ধারণ না করা (এটি রেখে nil) এটি ঘটবে এবং বাইটগুলিও সংরক্ষণ করবে।

কেউ কি এই (লুয়াতে) গল্ফ করতে পারেন?

— জোনাথন এস।
সূত্র
আমি জিমেচ ব্যবহার না করে জিএসব ব্যবহার করে দুটি বাইট সংরক্ষণ করতে সক্ষম হয়েছি। c=0(...):gsub(".",function(s)c=c+(p==s and(s=="/"and-1or 1)or 0)p=s print((" "):rep(c)..s)end)
— কোয়ার্টিকিবোর্ড
ভাল, এটি গুরুত্বপূর্ণ যে না। পরিবর্তন করে আপনি সহজেই দুটি বাইট সংরক্ষণ করতে পারতেনgmatch(".") থেকে gmatch"."আপনি আপনার পরবর্তী উত্তর করেছিল পছন্দ করি।
— কোয়ের্টিকিবোর্ড
@ কের্তিকিবোর্ড এটি অদ্ভুত ... আমি এই কোডের প্রথম সংস্করণে ঠিক ঠিক ঠিক এর মতো জিএসব ব্যবহার করেছি, তবে তারপরে গ্যামেচে স্যুইচ করেছি কারণ এটি কোনওভাবে সংক্ষিপ্ত হয়ে গেছে। আমি জানি না আমি কী আলাদা করেছি, দুর্ভাগ্যক্রমে ফাইলটি ওভাররাইট করা হয়েছে।
— জোনাথন এস
2

আর , 119 বাইট

function(s)for(i in 1:nchar(s))cat(rep(" ",cumsum(c(0,!diff(S<-(utf8ToInt(s)>48)*2-1))*S)[i]),substr(s,i,i),"
",sep="")

এটি অনলাইন চেষ্টা করুন!

এটি ব্যবহারকারী 2390246 এর উত্তর থেকে কিছুটা পৃথক । তারা প্রতিটি স্ট্রিং দিয়ে পুনরাবৃত্তি করে, একটি নির্দিষ্ট সংখ্যক স্থানের অক্ষর এবং তারপরে উপযুক্ত /\অক্ষরটি মুদ্রণ করে ।

যাইহোক, আমি স্ট্রিংটি বিভক্ত করা এড়িয়ে চলার পরিবর্তে অক্ষরগুলি তাদের ইউটিএফ -8 এনকোডিং মানের পরিবর্তে বেছে নিয়েছিলাম, যার পরে সরাসরি সংখ্যায় অঙ্ক করা যায়, যা আমাকে কয়েকটা বাইট সংরক্ষণ করেছিল।

— : Giuseppe
সূত্র
এই বিষয়ে আরও কিছু চিন্তা করা, আমার মনে হয় আপনার অ্যালগোরিদমে কোনও ত্রুটি রয়েছে: টিআইও
— ব্যবহারকারী 2390246
@ user2390246 আমি এটি ঠিক করেছি! আমার কিছু ভুল জায়গায় বন্ধনী ছিল, তবে এখন diffinvঅবশ্যই এখানে কাজ করবে না।
— জিউসেপে
— জাইসি
2

সি # (.নেট কোর) , 60/65 বাইট

আমি খাটো সি # সংস্করণ চেষ্টা করেছি tried

s=>{int i=0;return s.Select(x=>"".PadLeft(x<92?--i:i++)+x);}

যেমন বলা হয়েছিল: "এর অর্থ হ'ল প্রতিটি ইনপুট ব্যাকস্ল্যাশ দিয়ে শুরু হবে।" অথবা "/" শুরু করে যা কিছুটা দীর্ঘায়িত করে

s=>{int i=s[0]&1;return s.Select(x=>"".PadLeft(x<92?--i:i++)+x);}

এটি অনলাইন চেষ্টা করুন!

— দেনিযেল
সূত্র
সাইটে স্বাগতম! :)
— ডিজেএমসিএমহেম
2

লুয়া , 88 84 বাইট

উন্নত সংস্করণ (কোয়ার্টিকিবোর্ডকে -4 বাইট ধন্যবাদ)

s=""g=s.gsub g(...,".",function(c)s=g(g(g(s,"\\"," "),"/?$",c)," /","/")print(s)end)

এটি অনলাইন চেষ্টা করুন!

আসল সংস্করণ (৮৮ বাইট)

লুয়ার আরেকটি প্রচেষ্টা, এবার কাউন্টার ভেরিয়েবলের পরিবর্তে স্ট্রিং ম্যানিপুলেশন ব্যবহার করে সম্পূর্ণ ভিন্ন পদ্ধতির সাথে।

s=""for c in(...):gmatch"."do s=s:gsub("\\"," "):gsub("/?$",c):gsub(" /","/")print(s)end

Ungolfed:

s = ""
for c in string.gmatch((...), ".") do --for each character in the input
  --s contains the output from the previous iteration
  s = s:gsub("\\", " ") --Replace backslash with space -> indent by 1
  s = s:gsub("/?$", c) --Remove any / at the end of the string and append c to the string
  s = s:gsub(" /", "/") --Remove a single space in front of any / -> un-indent by 1
  print(s)
end

(...):gmatch"."
কোডটিতে একটি আকর্ষণীয় জিনিস রয়েছে: এটি লুয়া পার্সারে কিছু quirks ব্যবহার করে। যখন লুয়া কোনও ফর্মের কোডের সাথে মুখোমুখি হয় func "string", তখন এটি এতে রূপান্তরিত হবে func("string")। এটি এমন একটি যাতে print "string"ধ্রুব স্ট্রিং প্রিন্ট করতে লিখতে পারে এবং এটি কেবল ফাংশনের পরে একক স্ট্রিং আক্ষরিক সাথে কাজ করে। অন্য যে কোনও কিছু একটি সিনট্যাক্স ত্রুটি দেবে। তবে এই সিনট্যাকটিক চিনিটি একটি অভিব্যক্তির মাঝখানে ফাংশন কলগুলির সাথেও কাজ করে এবং আরও আশ্চর্যজনকভাবে এটি :পদ্ধতি কল সিনট্যাকটিক চিনির সাথে একসাথে ঠিক কাজ করে works সুতরাং শেষ পর্যন্ত, লুয়া কোডটির এভাবে ব্যাখ্যা করবে:

(...):gmatch"."
-> (...):gmatch(".")
-> string.gmatch((...), ".")

কেউ যদি তিনটি জিএসব কলগুলির মধ্যে একটি অপসারণের উপায়ের কথা ভাবতে পারেন তবে দয়া করে আমাকে বলুন।

— জোনাথন এস।
সূত্র
1
আমি হতাশ হয়েছি যে আমার জিএসব ট্রিকটি আমি আপনার অন্য উত্তরে মন্তব্য করেছি এটির জন্য বেশ কার্যকর হয়নি। এটি আসলে একটি বাইট যুক্ত করে শেষ হয়েছিল। যাইহোক, আমি সহজেই এটি ছেড়ে দেব না। কোডটি সংক্ষিপ্ত করার জন্য প্রথমে আমি ভেরিয়েবল হিসাবে জিএসব সংরক্ষণ করার চেষ্টা করেছি। আমার আশ্চর্যের বিষয় হল, আমার কোডটি ঠিক একই পরিমাণে বাইট ছিল - ৮৮। তবে, আমি বুঝতে পেরেছিলাম যে gsub সংরক্ষিত হওয়ার সাথে সাথে আমার জিএসব ট্রিকটি এখন কাজ করতে পারে! এখানে আমার কোড যা 4 টি বাইট বন্ধ করে দিয়েছে:s=""g=s.gsub g(...,".",function(c)s=g(g(g(s,"\\"," "),"/?$",c)," /","/")print(s)end)
— কোয়ার্টিকিবোর্ড
@ কুর্তিকিবোর্ড ইয়াপ, আমি লুপের আগে একটি ভেরিয়েবলের মধ্যে জিএসএসবি সংরক্ষণ করার চেষ্টা করেছি এবং তারপরে তিনবার জিএসব লেখার পরিবর্তে এটি ব্যবহার করেছিলাম এবং একে একে একে কোনও পার্থক্য না দেখে আমি ঠিক অবাক হয়ে গিয়েছিলাম। "লুপের পরিবর্তে gsub" এবং "স্টোর gsub" কৌশলগুলি সম্মিলিত করা সত্যিই ঝরঝরে, সেটির কথা ভাবেন না! ধন্যবাদ! :)
— জোনাথন এস
1

পাইথ - 33 বাইট

প্রথম চেষ্টা, গল্ফ হবে।

jsMC,*L;+ZsM._*VqVtzztMxL"/ \\"zz

এটি এখানে অনলাইনে চেষ্টা করুন ।

— Maltysen
সূত্র
— স্টান স্ট্রাম
— স্টান স্ট্রাম
— স্ট্যান স্ট্রাম
pinged @maltysen
— স্ট্যান Strum
এই মুহূর্তে @ স্টান্সস্ট্রাম, আপনি কেবল এটি নিজের উত্তর হিসাবে পোস্ট করতে পারেন
— মাল্টেসেন
1

পার্ল, 40 + 2 বাইট

/\//&&$.--,say($"x$.,$_),/\\/&&$.++for@F

আপনার -Fপতাকা দরকার

1

পার্ল, 34 38 + 1 বাইট

দুটি মামলা পরিচালনা করতে 

s,(/)|.,$"x($1?$c&&--$c:$c++).$&.$/,ge

-pঅপশন দিয়ে চালানো

s,(/)|.,$"x($1?--$c:$c++).$&.$/,ge

সম্পাদনা করুন: প্রথম চরিত্রটি হলে নিম্নলিখিত মন্তব্যটি কাজ করে না /

s,(/)|.,$"x($1?$c--:++$c).$&.$/,ge

তবে প্রথম চর হলে আউটপুট ডানদিকে একটি অক্ষর স্থানান্তরিত হবে \

— নাহুয়েল ফৌইলুল
সূত্র
1
জন্য কাজ করে না /\\/\\/।
— নিল
আপডেট হওয়া প্রশ্নের সাথে আপনার আসল 34সমাধানটি এখন পুরোপুরি বৈধ
— টন হসপেল
1

ভিবিএ (এক্সেল), 181 বাইট

Sub q()
a = Cells(1, 1)
For x = 1 To Len(a)
c = Mid(a, x, 1)
If c = "\" Then: Debug.Print b & c: b = b + " "
If c = "/" Then: b = Left(b, Len(b) - 1): Debug.Print b & c
Next
End Sub
— remoel
সূত্র
1
এক্সেল ভিবিএর অটোফর্ম্যাটিং প্রকৃতির সদ্ব্যবহার করে এবং [...]স্বরলিপি ব্যবহার করে আপনি আপনার অ্যালগরিদম পরিবর্তন না করে উল্লেখযোগ্যভাবে এটি গলফ করতে পারেন : আমি এটিকে 128 বাইটে নামিয়েছি Sub q For x=1To[Len(A1)] c=Mid([A1],x,1) If c="\"Then Debug.?b;c:b=b+" " If c="/"Then b=Left(b,Len(b)-1):Debug.?b;c Next End Sub
— টেলর স্কট
আমার স্ক্রিপ্ট গল্ফ করার জন্য আপনাকে ধন্যবাদ। আমি এ থেকে কিছু শিখেছি এবং ভবিষ্যতে প্রয়োগ করব। :) আমি জানতাম না যে আমি এটি সরাসরি কোষগুলিতে ডেটা আনতে ব্যবহার করতে পারি। আবারও ধন্যবাদ :)
— রিমুয়েল
1

পাইথ , 24 21 বাইট

রডের উত্তর থেকে পোর্ট ।

VQ=-Z<N\<+*ZdN=+Z>N\<

এটি অনলাইন চেষ্টা করুন!

— ফিলিপ নারদী বাটিস্তা
সূত্র
অবৈধ, মুদ্রণগুলি [প্রথম লাইনে অতিরিক্ত নেতৃস্থানীয় স্থান যদি স্ট্রিংটি শুরু হয় \। আপনার কোডটি কোথায়?
— মিঃ এক্সকোডার
@ মিঃ এক্সকোডার ঠিক করেছেন
— ফিলিপ
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.