এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা কোনও শব্দের মধ্যে অক্ষরের অনুলিপি করে, যাতে শব্দের বাম থেকে ডানে সাজানো সমস্ত সদৃশ অক্ষর ইনপুট অ্যারে গঠন করে।

উদাহরণ স্বরূপ:

input: chameleon, [c,a,l,n]
output: cchaamelleonn

ইনপুট

শুরুর শব্দ (উদাঃ chameleon)
অক্ষরের একটি অ্যারে ( [c,a,l,n]) বা একটি অ্যারে ( caln), বা অনুরূপ কিছু উপস্থাপনের জন্য স্ট্রিং
ইনপুট ফাংশন প্যারামিটার, STDIN বা ভাষার সমতুল্যর মাধ্যমে হতে পারে
সমস্ত ইনপুট ছোট হাতের অক্ষর (এজে) হবে

আউটপুট

পরিবর্তিত শব্দ
যদি একাধিক সমাধান থাকে তবে যে কোনও মুদ্রণ করা যায়
```
input: banana [n,a]  
possible outputs: bannaana, banannaa
                     |-|---------|-|--->[n,a]
```
আপনি ধরে নিতে পারেন যে ইনপুট শব্দটির (অ্যারেটি অগত্যা নয়) অ্যারেতে অক্ষর থাকবে (ক্রমে)
আপনি ধরেও নিতে পারেন ইনপুটগুলিতে কোনও টানা অক্ষর নেই যা একই (আপেল, গিক, সবুজ, কাচ, দরজা নয়)

উদাহরণ

input: abcdefghij, [a,b,c]
output: aabbccdefghij

input: lizard, [i,a,r,d]
output: liizaarrdd

input: coconut, [c,o]
ouput: ccooconut or coccoonut or ccocoonut

input: onomatopoeia, [o,o,a,o,o]
output: oonoomaatoopooeia

input: onomatopoeia, [o,a,o]
output: oonomaatoopoeia or onoomaatoopoeia or oonomaatopooeia etc.

সবচেয়ে কম প্রোগ্রামে জয়!

লিডারবোর্ড (স্নিপেটের জন্য মার্টিন বাটনারকে ধন্যবাদ)

কোড স্নিপেট দেখান

/* Configuration */

var QUESTION_ID = 51984; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";

/* App */

var answers = [], page = 1;

function answersUrl(index) {
  return "http://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      if (data.has_more) getAnswers();
      else process();
    }
  });
}

getAnswers();

var SIZE_REG = /\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/;
var NUMBER_REG = /\d+/;
var LANGUAGE_REG = /^#*\s*([^,]+)/;

function shouldHaveHeading(a) {
  var pass = false;
  var lines = a.body_markdown.split("\n");
  try {
    pass |= /^#/.test(a.body_markdown);
    pass |= ["-", "="]
              .indexOf(lines[1][0]) > -1;
    pass &= LANGUAGE_REG.test(a.body_markdown);
  } catch (ex) {}
  return pass;
}

function shouldHaveScore(a) {
  var pass = false;
  try {
    pass |= SIZE_REG.test(a.body_markdown.split("\n")[0]);
  } catch (ex) {}
  return pass;
}

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  answers = answers.filter(shouldHaveScore)
                   .filter(shouldHaveHeading);
  answers.sort(function (a, b) {
    var aB = +(a.body_markdown.split("\n")[0].match(SIZE_REG) || [Infinity])[0],
        bB = +(b.body_markdown.split("\n")[0].match(SIZE_REG) || [Infinity])[0];
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  answers.forEach(function (a) {
    var headline = a.body_markdown.split("\n")[0];
    //console.log(a);
    var answer = jQuery("#answer-template").html();
    var num = headline.match(NUMBER_REG)[0];
    var size = (headline.match(SIZE_REG)||[0])[0];
    var language = headline.match(LANGUAGE_REG)[1];
    var user = getAuthorName(a);
    if (size != lastSize)
      lastPlace = place;
    lastSize = size;
    ++place;
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", user)
                   .replace("{{LANGUAGE}}", language)
                   .replace("{{SIZE}}", size)
                   .replace("{{LINK}}", a.share_link);
    answer = jQuery(answer)
    jQuery("#answers").append(answer);

    languages[language] = languages[language] || {lang: language, user: user, size: size, link: a.share_link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 50%;
  float: left;
}

#language-list {
  padding: 10px;
  width: 50%px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Expand snippet

code-golf string subsequence

— স্ট্রেচ পাগল
সূত্র

@AlexA। শুধুমাত্র একটি উদাহরণ কারণ অন্যথায় সদৃশ অক্ষর দ্বারা গঠিত অ্যারের [c,o,c,o]পরিবর্তে হবে [c,o]।

— স্ট্রেচ পাগল

হ্যাঁ দুঃখিত, এটি আবার পড়লে তা স্পষ্ট। ধন্যবাদ।

— অ্যালেক্স এ

2

এটি দেখে বেশ কয়েকটি উত্তর এবং একই ভাষায় অনেকগুলি পেয়েছে, আপনি কি লিডারবোর্ড স্নিপেট যুক্ত করতে আগ্রহী ? যদি তা হয় তবে আমি এটিকে সম্পাদনা করতে এবং প্রয়োজনীয় শিরোনাম ফর্ম্যাটটি ব্যবহার না করে এমন উত্তরগুলি সংশোধন করে খুশি।

— মার্টিন ইন্ডার

@ মার্টিনব্যাটনার আমি সে সম্পর্কে ভুলে গেছি! যোগ করা হয়েছে। আপনার স্নিপেটে ওভারল্যাপিং কলামগুলি এড়ানোর জন্য আমাকে পরিবর্তন #answer-listএবং #language-listপ্রস্থের পরিবর্তন করতে 50%হয়েছিল।

— স্ট্রেচ পাগল

1

স্পেসিফিকেশন (আমার bash+ sedউত্তর দেখুন): এটি banana, na=> এর জন্য অবৈধ baannana? আমি বিশ্বাস করি যে "আপনি অনুমান করতে পারেন যে সমস্ত ইনপুটগুলির অ্যারেতে (অক্ষরে) অক্ষর থাকবে" বলতে অনুমতি দেওয়ার জন্য বোঝানো হয়েছে , তবে উভয় তালিকাকে যথাক্রমে প্রক্রিয়া করার উত্তরগুলির প্রয়োজন নেই , তবে @ মানচিত্র এটি আলাদাভাবে ব্যাখ্যা করেছে।

— টবি স্পাইট

5

পাইথ, 14 বাইট

s+L&@d<Q1.(QZz

প্রদর্শন.

ইনপুট শৈলী:

banana
["b","a","n","a"]

ব্যাখ্যা:

s+L&@d<Q1.(Q0z
                  Implicit: z = input(); Q = eval(input())
 +L          z    Map (lambda d) over z, adding the result to each character.
    @d<Q1         Intersection of d with Q[:1], up to the first element of Q.
   &              Logical and - if the first arg is truthy, evaluate and
                  return the second arg, otherwise return first arg.
         .(Q0     Q.pop(0)
                  The addition will either be the empty string, for the empty
                  intersection, or the character that was Q[0] otherwise.

s                 Concatenate and print.

— isaacg
সূত্র

43

ব্রেনফাক, 46 45 (ইনপুট প্রিন্টযোগ্য অক্ষর সহ 63)

অ্যালেক্স Pankratov এর সঙ্গে সামঞ্জস্যপূর্ণ বাফুফে (brainfuck SPOJ এবং ideone ব্যবহৃত অনুবাদক) এবং থমাস Cort এর BFI (অরাজকতা গলফ উপর ব্যবহৃত হয়)।

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

আদর্শের উপর বিক্ষোভ ।

-[+>,---------]
<[++++++++<]
<,+
[
  -.
  [>+>-<<-]
  >>
  [
    <[>+<-]
  ]
  <[.[-]]
  ,+
]

আমরা \x00ট্যাবের পরিবর্তে বিভাজক হিসাবে কিছু বাইট সংরক্ষণ করতে পারি :

,[>,]
<[<]
<,+
[
  -.
  [>+>-<<-]
  >>
  [
    <[>+<-]
  ]
  <[.[-]]
  ,+
]

— মিচ শোয়ার্জ
সূত্র

22

এই অনুভূতিটি যখন বিএফ আমার পাইথন কোডের চেয়ে কম হয় .. :(

— কেড

6

আমি সাধারণত ব্রেইনফাকের যত্ন নিই না, তবে এটি দুর্দান্ত!

— ডেনিস

এটা সুন্দর.

— জোশপাবারন

14

সিজেম, 15 বাইট

rr{_C#)/(C@s}fC

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

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

rr              e# Read two whitespace-separated tokens from STDIN.
  {         }fC e# For each character C in the second string.
   _            e#   Duplicate the first string.
    C#          e#   Compute the index of the character in the string.
      )/        e#   Add 1 and split the string in slice of that size.
        (       e#   Shift out the first slice.
         C      e#   Push the character.
          @     e#   Rotate the remainder of the string in top of the stack.
           s    e#   Stringify (concatenate the slices).

— ডেনিস
সূত্র

এটি সিজেমসের যুদ্ধ! আপনার এবং এসপি উভয়ের 15 বাইট সিজে্যাম উত্তর রয়েছে এবং 15 বর্তমানে সংক্ষিপ্ততম। :)

— অ্যালেক্স এ

3

@AlexA। শুধু পাইথের জন্য অপেক্ষা করুন। আপনি কেবল অপেক্ষা করুন ...

— Sp3000

2

মনে হচ্ছে আপনি পাইথকে আরও ভাল করে শিখবেন। ;)

— অ্যালেক্স এ

12

সি, 62 বাইট

f(char*s,char*c){while(*s-*c||putchar(*c++),*s)putchar(*s++);}

ভাল, এটি আশ্চর্যজনকভাবে প্রতিযোগিতামূলক।

আমরা একটি ফাংশন সংজ্ঞায়িত করি যা f(char*, char*)তার দ্বিতীয় ইনপুট হিসাবে নকল করতে স্ট্রিংটিকে তার প্রথম ইনপুট এবং অক্ষরের অ্যারে হিসাবে গ্রহণ করে।

কিছু পরীক্ষার কোড:

int main (int argc, char** argv) {
    f("onomatopeia", "oao");
    return 0;
}

কোন মুদ্রণ:

oonomaatoopeia

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

যদি কোনও ফাংশন না দিয়ে ম্যাক্রো জমা দেওয়া গ্রহণযোগ্য হয় তবে নিম্নলিখিতটি #define g(s,c)কেবলমাত্র 58 বাইট , তবে প্রয়োজন sএবং cআসল পয়েন্টার হতে হবে:

#define g(s,c)while(*s-*c||putchar(*c++),*s)putchar(*s++);

— BrainSteel
সূত্র

1

আমাকে কমা অপারেটর সন্ধান করার জন্য ধন্যবাদ । এটি দরকারী!

— অলিফোঁট - মনিকা

11

সিজেম, 15 বাইট

rr{:X/(XX+@X*}/

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

ব্যাখ্যা

দ্বিতীয় স্ট্রিংয়ের প্রতিটি চরিত্রের জন্য, আমরা দুটি জিনিস করি।

অক্ষরের দ্বারা স্ট্রিংয়ের বর্তমান প্রত্যয়টি বিভক্ত করুন "beeper" "e" -> ["b" "" "p" "r"]
Uncons অ্যারের মধ্যে প্রথম স্ট্রিং, চরিত্র দুটি সন্নিবেশ, তারপর চরিত্র, যেমন সঙ্গে অ্যারের বাকি পুনরায় যুক্ত "b" "ee" "eper"। সর্বশেষ স্ট্রিংটি নতুন প্রত্যয়।

— Sp3000
সূত্র

9

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

রেটিনা সম্পর্কে আরও তথ্য।

+`(?=(.))(((.)(?<!\4.))+\n)\1
$1$2

এটি STDIN- এ দুটি স্ট্রিংকে একটি নতুন লাইন দ্বারা পৃথক করে প্রত্যাশা করে।

গণনা উদ্দেশ্যে, প্রতিটি লাইন একটি পৃথক ফাইলে যায়, \nএকটি আসল নিউলাইন অক্ষর (0x0A) দিয়ে প্রতিস্থাপন করা উচিত। আপনি যদি এটি পরীক্ষা করতে চান তবে এটি একটি একক ফাইলে রাখা আরও সুবিধাজনক যেখানে যেখানে \nরয়েছে তেমনই রয়েছে এবং তারপরে রেটিনার সাথে অনুরোধ করুন-s ফাইলটি পাস করার আগে বিকল্পের করতে হবে।

ব্যাখ্যা

(পুরানো ... আমি চিহ্নিতকারী থেকে মুক্তি পেতে পরিচালিত ... আমি এটি পরে আপডেট করব))

প্রতিটি জোড়া লাইন একটি রেজেক্স বিকল্প (প্রথম লাইনের প্যাটার্ন, দ্বিতীয় লাইনের বিকল্প) is

^
#

এটি #ইনপুট স্ট্রিংয়ের শুরুতে চিহ্নিতকারী হিসাবে রাখে ।

+`#(.*?(.))(.*\n)\2
$1$2#$3

এটি নথির জন্য পরবর্তী অক্ষরের সাথে সম্পর্কিত ইনপুটটিতে প্রথম চিহ্নটি (মার্কারের পরে) সন্ধান করে, সেই চিঠিটিকে সদৃশ করে, চিহ্নিতকারীটিকে তার পিছনে নিয়ে যায় এবং দ্বিতীয় স্ট্রিংয়ের প্রথম অক্ষরটি ফেলে দেয়। +`সামনে রেটিনা বলে (কারণ দ্বিতীয় স্ট্রিং খালি এবং সমস্ত আবশ্যক অক্ষর সদৃশ করা হয়েছে এই ক্ষেত্রে,) এই বারবার পর্যন্ত স্ট্রিং পরিবর্তন স্টপ না।

#
<empty>

শেষ পর্যন্ত, আমরা মার্কারটি ফেলে দিয়ে স্ট্রিংটি পরিষ্কার করি।

— মার্টিন ইন্ডার
সূত্র

2

আমি অনুভব করেছি যে রেটিনার একটি দুর্দান্ত সমাধান হবে এবং আমি ঠিক বলেছিলাম কারণ আপনি এটি খুঁজে পেয়েছেন। এছাড়াও, যখন আমি প্রথমে আপনার বিবরণটি স্কিম করেছিলাম তখন আমি শেষটি " মাইকটি ফেলে দিয়ে স্ট্রিংটি পরিষ্কার করি as" হিসাবে পড়ি ।

— mbomb007

@ mbomb007 আমি কেবলমাত্র পৃথক বর্ণগুলির অনুলিপি দ্বারা "মাইক" থেকে মুক্তি পাওয়ার আশা করছিলাম যাগুলির পরে কোনও নকল নেই, তবে আমি এটি 33 বাইটের চেয়ে কম করতে পারি না। (পুনর্বিবেচনার ইতিহাসে একটি ভাঙা 28 বাইট সংস্করণ রয়েছে))

— মার্টিন ইন্ডার

@ এমবিম্ব ২০০7 এফওয়াইআই, আমি এখন চিহ্নিতকারীটিকে সরিয়ে ফেলতে পরিচালিত করেছি, তবে বাইট গণনা এখনও একইরকম। এটি এখনও গল্ফযোগ্য দেখাচ্ছে।

— মার্টিন ইন্ডার

একপাশে, আমি কেবল বুঝতে পেরেছিলাম যে রেটিনার esolangs.org

— mbomb007

@ mbomb007 হ্যাঁ, আমি সচেতন। আমি আরও কয়েকটি গুরুত্বপূর্ণ অসামান্য বৈশিষ্ট্য প্রয়োগ করার পরে সম্ভবত একটি যুক্ত করব।

— মার্টিন ইন্ডার

8

পাইথন, 61

def f(s,l):b=s[:1]==l[:1];return s and-~b*s[0]+f(s[1:],l[b:])

একটি লোভী পুনরাবৃত্তি সমাধান। bস্ট্রিংয়ের sপ্রথম অক্ষরটি lঅক্ষরের স্ট্রিংয়ের প্রথম অক্ষর দ্বিগুণ হয় কিনা তা সংরক্ষণ করে । যদি তা হয় তবে সেই চিঠির একটি নিন এবং এটির সাথে sপ্রথম উপাদানটি সরিয়ে রেখে বাকীগুলির সাথে পুনরাবৃত্ত কলটিতে প্রিপেন্ড করুন l। যদি না হয় bতবে একই কাজটি করুন তবে বর্ণটি দ্বিগুণ করবেন না এবং সরিয়ে ফেলবেন না l।

কোডটি খালি বা শূন্য থাকা অবস্থায় ত্রুটি-বিহীন ত্রুটি এড়ানোর s[:1]==l[:1]চেয়ে চেক করে ।s[0]==l[0]sl

— xnor
সূত্র

6

প্রোলোগ, 95 83 79 56 বাইট

d([A|S],H):-put(A),H=[A|T],put(A),d(S,T);d(S,H).
d(_,_).

উদাহরণ:

d(`chameleon`,`caln`).

আয়

cchaamelleonn

সম্পাদনা করুন: অলিফোঁটের জন্য 4 টি বাইট সংরক্ষণ করা হয়েছে

সম্পাদনা 2: অবচয়যুক্ত put/1এসডাব্লুআই-প্রোলোগের পরিবর্তে 20 টি বাইট সংরক্ষণ করা হয়েছে writef। পুনরাবৃত্তির প্রিনিকেট প্রতিস্থাপন করে একটি বাইট সংরক্ষণ করা d([],_).হয়েছে d(_,_).। দুটি সংজ্ঞার ক্রমটি dযদি অদলবদল হয় তবে কাজ করবে না , তবে গল্ফড কোডে আমরা সেটির দিকে যত্ন করি না। চারপাশে প্রথম দুটি বন্ধন অপসারণ করে আরও 2 টি বাইট সংরক্ষণ করা হয়েছেH=[A|T],put(A),d(S,T)

— Fatalize
সূত্র

1

আমি কেন নিশ্চিত তা নিশ্চিত হলাম না। আপনার কোডে কিছু ব্যাখ্যা যোগ করতে পারেন?

— অ্যালেক্স এ

1

আপনি পরোক্ষভাবে ঐক্যবদ্ধ দ্বারা চার বাইট সংরক্ষণ করতে পারেন: H=[A|T]। এছাড়াও, নতুন লাইনের সাথে স্পেসগুলি প্রতিস্থাপন করে এটিকে কেন একটু বেশি পঠনযোগ্য করে তুলছেন না?

— অলিফন্ট - মনিকা

@ অলিফ্যান্ট এই পরামর্শের জন্য ধন্যবাদ, এইচ = [এ | টি] ধারাটি ব্যবহার করার জন্য আমার কোডটি মূলত আমার কোডটি সংশোধন করার পরে আমি এই হালকা অপ্টিমাইজেশনটি দেখতে পাইনি।

— ফ্যাটালাইজ করুন

5

পাইথন 2, 83 74 72 65 বাইট

এখানে কোন আসল বিশেষ কৌশল নেই। xস্ট্রিংটি yহ'ল অক্ষরগুলির অ্যারে ray এটি সঠিকভাবে অনুলিপি না করে কিনা তা স্পষ্ট করতে, প্রথম ইনডেন্টেশন স্তরটি একটি স্থান, পরেরটি একটি ট্যাব।

সম্পাদনা 1: পপ () এর পরিবর্তে স্ট্রিং ম্যানিপুলেশন ব্যবহার করে 9 বাইট সংরক্ষণ করা হয়েছে।

সম্পাদনা 2: 2 দ্বারা -~বর্ধিত gকরে 2 বাইট সংরক্ষণ করা হয়েছে ।

সম্পাদনা 3: y[:1]ট্রিক ব্যবহার করে 7 বাইট সংরক্ষিত , এর জন্য এক্সএনরকে ধন্যবাদ!

def f(x,y,s=''):
 for c in x:g=y[:1]==c;s+=c*-~g;y=y[g:]
 print s

এটি এখানে দেখুন।

সঠিকভাবে ফর্ম্যাট এবং ব্যাখ্যা:

def f(x,y,s=''):           # Defining a function that takes our input,
                           # plus holds a variable we'll append to.
  for c in x:              # For every character in 'x', do the following:
    g = y[:1] == c         # Get the first element from the second string, will
                           # return an empty string if there's nothing left.
                           # Thanks to xnor for this trick!
    s += c * -~g           # Since int(g) would either evaluate to 0 or 1, we
                           # use the -~ method of incrementing g to multiply
                           # the character by 1 or 2 and append it to 's'
    y = y[g:]              # Again, since int(g) would either evaluate to 0
                           # or 1, use that to cut the first value off y, or
                           # keep it if the characters didn't match.
  print s                  # Print the string 's' we've been appending to.

— Kade
সূত্র

"আপনি ধরে নিতে পারেন যে সমস্ত ইনপুটগুলির অ্যারেতে (ক্রম) অক্ষর থাকবে" " এটি আপনাকে বেশ কয়েকটি বাইট সংরক্ষণ করতে হবে।

— mbomb007

2

আপনি সম্ভবত খালি স্ট্রিং থেকে প্রথম উপাদানটি পেতে পারেন y[:1]।

— xnor

আমি এখন উপলব্ধি করেছি যে আপনি যেভাবে এটির কাজটি করছেন তার কারণে আপনি যতটা ভেবেছিলাম সেগুলি সংরক্ষণ করতে পারবেন না y=y[g:] , সুতরাং "বেশ কয়েকটি" যথেষ্ট অতিরঞ্জিত।

— mbomb007

@ ভিওজ- আমি ভাবছিলাম y[:1]==c । ওইটা কি কাজ করে?

— xnor

@ এক্সনর হ্যাঁ, আমি যদি সেই চিঠিগুলি পরিবর্তে বদলের প্রয়োজন হয় তবে তা করে। ধন্যবাদ!

— কেড

5

এক্সেল ভিবিএ, 110 বাইট

কোডগল্ফে এটি আমার প্রথম প্রবেশ তাই আমি আশা করি এটি ঠিক আছে।

আপনি এ 1 তে ইনপুট শব্দটি প্রবেশ করুন এবং তারপরে বি 1-এ প্রতিস্থাপন করা হবে এবং ফলস্বরূপ শব্দটি একটি বার্তা বাক্সে প্রদর্শিত হবে।

w = Cells(1, 1)
l = Cells(2, 1)
For i = 1 To Len(w)
x = Left(w, 1)
R = R + x
If InStr(l, x) > 0 Then
R = R + x
End If
w = Right(w, Len(w) - 1)
Next
MsgBox R

— Wightboy
সূত্র

2

ভিবিএ যদি ইনডেন্টেশন সংবেদনশীল না হয় তবে আপনি সমস্ত ইনডেন্টগুলি থেকে মুক্তি পেতে পারেন এবং কয়েকটি বাইট সংরক্ষণ করতে পারেন। আমি মনে করি আপনি কমা ও আশেপাশের অপারেটরগুলির পরে সমস্ত স্থান থেকেও মুক্তি পেতে পারেন। আপনাকে কয়েকটি বাইট সংরক্ষণ করতে হবে।

— ফান্ড মনিকার লসুইট

@ কিপ্যায়েট্যাক্সস আপনার সম্পাদনার জন্য ধন্যবাদ। আমি কী করব তা দেখতে রোলব্যাক টিপলাম। নিশ্চিত না যে এটি আপনাকে সম্পাদনার জন্য পয়েন্ট বা কিছু হারায়?

— ওয়েটবয়

না, আমার কাছে এখনও +2 রয়েছে, যদিও আমি কিছুটা হলেও বিভ্রান্ত হয়ে পড়েছিলাম। আপনি আবার ফিরে যেতে চাইবেন; কমপক্ষে তিন জন হাইপিশ-জনগণের মতে এটি একটি ভাল সম্পাদনা ছিল।

— ফান্ড করুন মনিকার লসুইট

@ কিপেসট্যাক্সেস আমি সম্মতি জানাই আমি সম্পাদনাটি পছন্দ করেছি। মনে করুন আমি কেবল একটি বহুবার ঘূর্ণিত হয়েছি।

— ওয়েটবয়

আমি বলতে পারি না। মোবাইল ঠিক জিনিসগুলি দুর্দান্তভাবে প্রদর্শন করে না। পরিশেষে, যদিও, কী কোডগুলি গুরুত্বপূর্ণ তা বিন্যাস নয়।

— মনিকা এর মামলা মোকদ্দমা করুন

4

হাস্কেল, 42 বাইট

(a:b)#e@(c:d)|a==c=a:a:b#d|1<2=a:b#e
a#_=a

ব্যবহারের উদাহরণ:

*Main> "coconut" # "co"
"ccooconut"
*Main> "lizard" # "iard"
"liizaarrdd"
*Main> "onomatopoeia" # "ooaoo"
"oonoomaatoopooeia"

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

যদি একটি স্ট্রিং ফাঁকা থাকে, ফলাফলটি প্রথম স্ট্রিং। অন্য: যদি স্ট্রিংয়ের প্রথম অক্ষর মিলে যায় তবে এটি দুটি বার নিন এবং স্ট্রিংগুলির লেজের সাথে একটি পুনরাবৃত্ত কল যুক্ত করুন। যদি অক্ষরগুলি মেলে না, তবে প্রথম স্ট্রিংয়ের প্রথম অক্ষরটি ধরুন এবং প্রথম স্ট্রিংয়ের পুচ্ছ এবং একই দ্বিতীয় স্ট্রিংয়ের সাথে একটি পুনরাবৃত্ত কল যুক্ত করুন।

— nimi
সূত্র

4

Pyth, 18 17 বাইট

sm?+d.(QZqd&QhQdz

সরাসরি নমুনা.

1 জ্যাকেটকে ধন্যবাদ 1 বাইট সংরক্ষিত

ব্যাখ্যা:

                z  Read the first line of input.
 m                 For each character in that line
  ?      qd&QhQ    If (?) the first char of the stretch list (`&QhQ`) 
                   and the current character are equal,
   +d.(QZ          Then double the current character and pop an element off
                   the stretch list.
               d   Otherwise, just return the same character.
s                  Join all the characters together.

মূল সংস্করণ:

jkm?+d.(QZqd&QhQdz

আসল জন্য লাইভ ডেমো।

— kirbyfan64sos
সূত্র

4

জাভাস্ক্রিপ্ট, 47 বাইট

(a,b)=>a.replace(/./g,d=>b[0]!=d?d:d+b.shift())

কিছু ES6 বৈশিষ্ট্য সুবিধা গ্রহণ করা।

— খাদ্যশস্য
সূত্র

1

এই কাজের জন্য সঠিকভাবে কি onomatopoeia, oao?

— অ্যালেক্স এ

1

@AlexA। আউটপুটস: "ওনোম্যাটোওপোইয়িয়া"। আহ আমি বুঝতে পেরেছি. ঠিক করবে

— সিরিয়াল

স্থির, আমি মনে করি। প্রচুর অক্ষর যুক্ত হয়েছে :(

— সিরিয়াল

পরিবর্তে b.indexOf(d)==0, চেষ্টা করুন~b.search(d)

— ইসমাইল মিগুয়েল

@ ইসমাইল মিগুয়েল searchকেবল স্ট্রিংগুলিতে প্রযোজ্য। খকে একটি অ্যারেতে পরিবর্তন করতে হয়েছিল

— সিরিয়াল

3

পাইথ, 16 বাইট

u|pH<GJxGH>GJwz

অনলাইনে চেষ্টা করুন: বিক্ষোভ

এটি বেশ হ্যাকি। স্ট্যাক-ভিত্তিক ভাষাগুলির এখানে একটি সুবিধা থাকতে পারে।

ব্যাখ্যা

                   implicit: z = 1st input line, w = 2nd
u             wz   reduce, start with G = z
                   for each H in w, update G to:
        xGH          index of H in G
       h             +1
      J              store in J
    <GJ              substring: G[:J] (everything before index J)
  pH                 print substring then H (without newlines)
 |                   afterwards (actually or, but p always returns 0)
           >GJ       substring: G[J:] (everything from index J to end)
                     update G with ^
                   afterwards implicitly print the remainder G

— Jakube
সূত্র

@ আইস্যাকগ সহায়তা? কিছুটা ছোট হতে হবে ...

— জাকুব

এবং আরও মার্জিত ;-)

— জাকুবে

1

এটি 14 - 1 এ সিজোমের চেয়ে কম স্থানের সেরা জায়গা place

— isaacg

3

জাভাস্ক্রিপ্ট ES6, 47 বাইট

(w,s)=>w.replace(/./g,c=>c==s[0]?c+s.shift():c)

ধরে sনেওয়া একটি অ্যারে["c","a","l","n"]

— Shmiddty
সূত্র

2

> <> (ফিশ) , 68 34 বাইট

ri&:o&:&=\
l&io& /!?/
?!;20.\l!\

আপনি এটি http://fishlanguage.com/playground এ চালাতে পারেন প্রাথমিক স্ট্যাক হিসাবে স্ট্রিংটিকে ইনপুট করে ("চিহ্নগুলি, অর্থাত্" গিরগিটি "সহ) এবং ইনপুট স্ট্যাক হিসাবে অতিরিক্ত অক্ষরের অ্যারে (কোনও" চিহ্নগুলি না মানে বাছুর)।

ইনপুট স্ট্যাকের বীজ দিতে গিভ বোতাম টিপতে ভুলবেন না।

r       reverses the stack
i&      reads in the first input, and stores it in the register
:o      copies the top of the stack, and outputs the top of the stack
&:&     puts register value on stack, copies it, then puts top stack into register
=       checks if the top two values are equal, if yes push 1, else push 0
?       if top value is non-zero, execute next instruction
!       skips the following instruction (unless it was skipped by the previous ?)

If yes, then we proceed on the same line
&o      puts register value on stack, and outputs it
i&      reads in the first input, and stores it in the register
l       puts length of stack on stack, then proceed to lowest line

If no, we go directly to the last line
l       As above.
?!;     If zero value (from length), then end execution
20.     Push 2 and 0 onto stack, then pop top two values, and go to that position (2,0) (i.e. next instruction is at (3,0))

সম্পাদনা: এটি বন্ধ! :)

— Fongoid
সূত্র

2

আর, 119

@ অ্যালেক্সের উত্তরের ভিত্তিতে , এটি হ'ল কয়েক বাইট সংক্ষিপ্ত:

function(s,a){message(unlist(lapply(strsplit(s,"")[[1]],function(x){if(length(a)&x==a[1]){a<<-a[-1];c(x,x)}else x})))}

Ungolfed:

function(s, a) {
  message(                             # Prints to output
    unlist(                            # Flattens list to vector
      lapply(                          # R's version of map
        strsplit(s,"")[[1]],           # Split vector to characters
        function (x) {
          if (length(a) & x == a[1]) { # If there are still elements in a
                                       # and there's a match
            a <<- a[-1]                # Modify a
            c(x, x)                    # And return the repeated character
          } else x                     # Otherwise just return it
        }
      )
    )
  )
}

— jja
সূত্র

2

পার্ল, 73 62 59 56

সম্পূর্ণ নতুন পদ্ধতির ফলে আরও ভাল ফলাফল পাওয়া যায়। তবুও, আমি বাজি ধরছি এটি আরও কম হতে পারে।

যেমন কল f('coconut', ['c','o'])।

sub f{($s,$a)=@_;$s=~s/(.*?)($_)/\U$1$2$2/ for@$a;lc$s}

অ্যারের প্রতিটি চরিত্রের জন্য, প্রথম উপস্থিতিটি সন্ধান করুন এবং এটির সদৃশ করুন এবং সবকিছুকে বড় হাতের দিকে পরিণত করুন। তারপরে পুরো স্ট্রিংটি ফিরে আসুন, লোয়ারকেসে রূপান্তরিত করুন।

সম্পাদনা: shiftএবং এর থেকে মুক্তি পেয়ে আরও কয়েকটি চরিত্রের চাঁচা করেছেন pop।

পূর্ববর্তী সংস্করণ:

sub f{join '',map{shift @{$_[0]}if s/($_[0][0])/$1$1/;$_}split //,shift}

— jja
সূত্র

নতুন সংস্করণটি আর চরিত্রের আদেশকে সম্মান করে না। (BTW, " foreachশব্দ আসলে জন্য একটি প্রতিশব্দ হয় forশব্দ, তাই আপনি হয় ব্যবহার করতে পারেন।" - foreach loops ।)

— manatwork

@ মান্যাটওয়ার্ক যা এটি করা উচিত। এবং forইঙ্গিত জন্য ধন্যবাদ । এটি আসলে এখন খাটো।

— জাজা

2

রুবি, 52 47 বাইট

সমাধান:

f=->(s,a){s.chars.map{|c|c==a[0]?a.shift*2:c}.join}

উদাহরণ:

p f.call('banana', ['n','a']) # => "bannaana"

ব্যাখ্যা:

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

হালনাগাদ

f=->s,a{s.chars.map{|c|c==a[0]?a.shift*2:c}*''}

— ব্রায়ান ডেভিস
সূত্র

আপনি প্যারামিটারগুলির আশেপাশে প্রথম বন্ধনগুলি এড়িয়ে যেতে পারেন s,a। এবং *''এর সমতুল্য .join। এটি 5 বাইট সংরক্ষিত হয়েছে, তবে আমি আপনাকে এখনও একটি দ্বারা পরাজিত করেছি (আপাতত): ডি

— ডানিরো

2

পার্ল, 51 বাইট

$s=<>;$s=~s=^.*$_=$_=,$,.=$&for split"",<>;print$,;

এসটিডিআইএন এর মাধ্যমে ইনপুট সরবরাহ করা হয়। প্রথম ইনপুটটি শুরুর শব্দ (উদাঃ chameleon), দ্বিতীয় ইনপুট হ'ল একক স্ট্রিং (যেমন caln) হিসাবে বর্ণগুলি ।

উপরেরটি নীচেরগুলি করার একটি অস্পষ্ট ("prettier" পড়ুন) উপায়:

$word = <>;
for $letter(split "", <>) {
   $word =~ s/^.*$letter/$letter/;
   $result .= $&;
}
print $result;

আমরা প্রতিটি চিঠির মধ্য দিয়ে যাওয়ার পরে আমরা শব্দটি শুরু থেকে শুরু করে উত্স শব্দটিতে বর্ণটি কেবল নতুন অক্ষর দিয়ে প্রতিস্থাপন করি $&এবং আমাদের ফলাফলটি ম্যাচটি (সঞ্চিত ) সংযোজন করি । যেহেতু ম্যাচে চিঠিটি অন্তর্ভুক্ত থাকে এবং তারপরে চিঠিটি প্রতিস্থাপন করা হয়, তাই প্রতিটি চিঠি দু'বার উপস্থিত হয়।

যেহেতু STDIN আমাদের উভয় ইনপুটগুলিতে একটি নতুন লাইন চরিত্র যুক্ত করে, আমরা শেষ ম্যাচে পুরো শব্দের অবশিষ্টাংশ, অর্থাৎ নতুন লাইন চরিত্রটি ক্যাপচার করার গ্যারান্টিযুক্ত।

— অ্যালেন জি
সূত্র

2

REGXY, 24 বাইট

REGXY ব্যবহার করে , একটি রেজেক্স প্রতিস্থাপন ভিত্তিক ভাষা। ইনপুটটিকে শুরুর শব্দ এবং অ্যারের হিসাবে ধরে নেওয়া হয়, স্থান পৃথক করা (উদাহরণস্বরূপ "গিরগিটি কলন")।

/(.)(.* )\1| /\1\1\2/
//

প্রোগ্রামটি প্রথম স্ট্রিংয়ের একটি অক্ষরের সাথে কোনও স্থানের পরে প্রথম অক্ষরের সাথে মিল রেখে কাজ করে। যদি এটি মেলে, চরিত্রটি প্রতিস্থাপনে পুনরাবৃত্তি করা হয় এবং অ্যারেতে থাকা অক্ষরটি সরিয়ে ফেলা হয় (ভাল, স্ট্রিংটিতে ফিরে যুক্ত হয়নি)। প্রসেসিং দ্বিতীয় লাইনে চলে যায়, এটি প্রথম লাইনের ঠিক পয়েন্টার যা পূর্ববর্তী প্রতিস্থাপনের ফলাফলের প্রক্রিয়াকরণ পুনরাবৃত্তি করে। পরিণামে, স্থানটির পরে কোনও অক্ষর থাকবে না, যার ফলে বিকল্পটির দ্বিতীয় স্থানটি পরিবর্তনের স্থানটি সরিয়ে ফেলবে match এরপরে রেজেক্সটি ম্যাচ করতে ব্যর্থ হবে, প্রক্রিয়াজাতকরণটি সম্পন্ন হবে এবং ফলাফলটি ফিরে আসবে।

এটি যদি সহায়তা করে তবে মৃত্যুদন্ড কার্যকর করার পুনরাবৃত্তিগুলি নিম্নরূপ:

chameleon caln
cchameleon aln
cchaameleon ln
cchaameleonn n
cchaameleonn  (with trailing space)
cchaameleonn

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

a/(.)(.* )\1| /\1\1\2/
b//a

যার পরিমাণ 27 বাইট

— Jarmex
সূত্র

1

জাভাস্ক্রিপ্ট ES6, 72 বাইট

(s,a,i=0,b=[...s])=>a.map(l=>b.splice(i=b.indexOf(l,i+2),0,l))&&b.join``

এটি একটি অনামী ফাংশন যা 2 টি প্যারামিটার নেয়: স্ট্রিং হিসাবে শুরু শব্দ এবং অ্যারে হিসাবে প্রসারিত করতে অক্ষর। ইঙ্গিতযুক্ত কোড যা ES5 ব্যবহার করে এবং নীচে UI পরীক্ষা করে।

f=function(s,a){
  i=0
  b=s.split('')
  a.map(function(l){
    i=b.indexOf(l,i+2)
    b.splice(i,0,l)
  })
  return b.join('')
}

run=function(){document.getElementById('output').innerHTML=f(document.getElementById('s').value,document.getElementById('a').value.split(''))};document.getElementById('run').onclick=run;run()

<label>Starting word: <input type="text" id="s" value="onomatopoeia" /></label><br />
<label>Leters to duplicate: <input type="text" id="a" value="oao"/></label><br />
<button id="run">Run</button><br />Output: <output id="output"></output>

স্নিপেট প্রসারিত করুন

— NinjaBearMonkey
সূত্র

1

পাইথন 2, 77

def f(x,y,b=''):
 for i in x:
    try:
     if i==y[0]:i=y.pop(0)*2
    except:0
    b+=i
 print b

যেমন কল করুন:

f('onomatopoeia',['o','a','o'])

আমি বাইট সংখ্যাটি মারাত্মকভাবে ভুল পেয়েছি ... স্পেস এবং ট্যাবগুলির মিশ্রণ ব্যবহার করে Uses

— বেটা ক্ষয়
সূত্র

1

আরএস, 39 বাইট

আরএস সম্পর্কে আরও তথ্য

ইতিমধ্যে একটি রেটিনা উত্তর রয়েছে, তবে আমি মনে করি এটির কিছুটা ভিন্ন পদ্ধতির ব্যবহার রয়েছে। সেগুলিও পৃথকভাবে তৈরি করা হয়েছিল: যখন আমি এইটিতে কাজ শুরু করি, তখন উত্তরটি পোস্ট করা হয়নি।

এছাড়াও, এটি যাইহোক যাইহোক 6 বাইট দীর্ঘ। :)

#
+#(\S)(\S*) ((\1)|(\S))/\1\4#\2 \5
#/

লাইভ ডেমো এবং পরীক্ষার স্যুট।

— kirbyfan64sos
সূত্র

আমি আপনার দোভাষীর সেই ডিবাগ সুইচটি সত্যিই পছন্দ করি।

— ডেনিস

@ ডেনিস ধন্যবাদ!

— kirbyfan64sos

1

জাভাস্ক্রিপ্ট, 92 টি অক্ষর

function f(s,c){r="";for(i=0;i<s.length;i++){r+=s[i];if(c.indexOf(s[i])>-1)r+=s[i]}return r}

অপ্রকাশিত সংস্করণ:

function stretch(str, chars) {
    var ret = "";
    for(var i = 0; i < str.length; i++) {
        ret += str[i];
        if(chars.indexOf(str[i]) > -1) {
            ret += str[i];
        }
    }
    return ret;
}

— SirPython
সূত্র

1

আর, 136 128 122 বাইট

function(s,a){p=strsplit(s,"")[[1]];for(i in 1:nchar(s))if(length(a)&&(x=p[i])==a[1]){p[i]=paste0(x,x);a=a[-1]};message(p)}

এটি একটি নামহীন ফাংশন তৈরি করে যা স্ট্রিং এবং একটি অক্ষর ভেক্টরকে ইনপুট হিসাবে গ্রহণ করে এবং স্ট্রিংটি STDOUT এ মুদ্রণ করে। এটি কল করার জন্য, এটি একটি নাম দিন।

অবহেলিত + ব্যাখ্যা:

f <- function(s, a) {
    # Split s into letters
    p <- strsplit(s, "")[[1]]

    # Loop over the letters of s
    for (i in 1:nchar(s)) {

        # If a isn't empty and the current letter is the first in a
        if (length(a) > 0 && p[i] == a[1]) {

            # Replace the letter with itself duplicated
            p[i] <- paste0(p[i], p[i])

            # Remove the first element from a
            a <- a[-1]
        }
    }

    # Combine p back into a string and print it
    message(p)
}

উদাহরণ:

> f("coconut", c("c","o"))
ccooconut

> f("onomatopoeia", c("o","a","o"))
oonomaatoopoeia

মিকিটি এবং 8 টি জেজে 3 টি বাইট সংরক্ষণ করা!

— অ্যালেক্স এ।
সূত্র

আপনি cat(p,sep='')এক দম্পতির জন্য সরাসরি

— STDOUT এ

@ মিকিটি: এটা ভেবে দেখেনি! ধন্যবাদ, সম্পাদিত। :)

— অ্যালেক্স এ।

1

আসলে, message(p)খাটো হয়।

— jja

@ জজা: আমি জানতাম না message, এটা দুর্দান্ত! ধন্যবাদ! আপনার পরামর্শ ব্যবহার করতে সম্পাদিত।

— অ্যালেক্স এ 14

1

বাশ + সেড, 51

sed "`sed 's/./s!^[^&]*&!\U\&&!;/g'<<<$1`s/.*/\L&/"

স্টিডিন থেকে ইনপুট; অক্ষরগুলি একক যুক্তি হিসাবে দ্বিগুণ করতে হবে:

$ echo chameleon | strtech caln
cchaamelleonn

এটি এর থেকে একটি সেড প্রোগ্রাম তৈরি করে $2এবং তারপরে এটি কার্যকর করে কাজ করে $1। সেড প্রোগ্রামটি প্রতিটি প্রতিস্থাপন পত্রের প্রথম উপস্থিতির পরিবর্তে তার বড় হাতের সংস্করণটির দুটি কপি দিয়ে প্রতিস্থাপিত করে এবং শেষে পুরো অংশটিকে নিচে নামিয়ে দেয়। উপরের উদাহরণের জন্য, উত্পাদিত সেড প্রোগ্রামটি হ'ল

s!^[^c]*c!\U&C!;s!^[^a]*a!\U&A!;s!^[^l]*l!\U&L!;s!^[^n]*n!\U&N!;s/.*/\L&/

প্রিটি-মুদ্রিত:

# if only sed had non-greedy matching...
s!^[^c]*c!\U&C!
s!^[^a]*a!\U&A!
s!^[^l]*l!\U&L!
s!^[^n]*n!\U&N!
s/.*/\L&/

আমি এখন পর্যন্ত প্রক্রিয়া করা অক্ষরগুলি চিহ্নিত করতে বড় হাতের ব্যবহার করি; এটি ইতিমধ্যে দ্বিগুণ হয়ে যাওয়া অক্ষরগুলিকে পুনরায় দ্বিগুণ করা বা আগের বর্ণের তুলনায় দ্বিগুণ করার আগে এড়িয়ে চলে।

পূর্ববর্তী সংস্করণ, স্পষ্ট করার আগে প্রতিস্থাপনের তালিকার ক্রমটি উল্লেখযোগ্য (44 টি)

sed "`sed 's/./s!&!\U&&!;/g'<<<$1`s/.*/\L&/"

— টবির গতি
সূত্র

ত্রুটিপূর্ণ. strtech na <<< banana"বনান্না" আউটপুট দেয় তবে প্রথমে "এন" এর সাথে দ্বিগুণ হওয়া উচিত, তারপরেই "এ" এর উপস্থিতি ঘটে।

— manatwork

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

— টবি স্পিড

কোনও সমস্যা নেই, আমিও প্রথমবারের মতো এটি পাইনি। আমি ভাবার সময় আপনার উত্তরটি মুছে ফেলার পরামর্শ দিচ্ছি (আপনি যে কোনও সময় পরে মুছে ফেলতে পারেন), যাতে ডাউনটিভয়েড হওয়ার সুযোগটি এড়ানো যায়।

— manatwork

@ মান্যাটওয়ার্ক: আমি প্রশ্নকর্তাকে স্পষ্টতার জন্য জিজ্ঞাসা করেছি, এবং একটি বিকল্প উত্তর সরবরাহ করেছি যা সন্তুষ্ট করে যে নিয়মগুলি পড়তে হবে (তবে এটি করতে আমার 7 টি অক্ষর লাগবে)

— টবি স্পাইট

0

পাইথন, 53 92 বাইট

পাইথন 2 এবং 3 উভয় ক্ষেত্রেই আমার সমাধানটি একই দৈর্ঘ্যের হতে পারে।

সম্পাদনা: ম্যান, একই চিঠির একাধিক প্রতিস্থাপন করার সময় (সেই একই পদ্ধতি ব্যবহার করার সময়) কিছুটা কাজ নিয়েছে তখন সেই কেসটি ঠিক করা।

পাইথন 2:

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

def f(s,t):
 for c in t:s=s.replace(c,'%',1)
 print s.replace('%','%s')%tuple(x*2for x in t)

পাইথন 3:

s,*t=input()
for c in t:s=s.replace(c,'%',1)
print(s.replace('%','%s')%tuple(x*2for x in t))

— mbomb007
সূত্র

0

গণিত, 66 বাইট

""<>Fold[Most@#~Join~StringSplit[Last@#,#2->#2<>#2,2]&,{"",#},#2]&

উদাহরণ:

In[1]:= f = ""<>Fold[Most@#~Join~StringSplit[Last@#,#2->#2<>#2,2]&,{"",#},#2]&

In[2]:= f["banana", {"n", "a"}]

Out[2]= "bannaana"

— alephalpha
সূত্র

0

লুয়া, 76 78 76 75 58 53 বাইট

নতুন, উইজেলকাটিজ এবং স্কুইডদেভের সহায়তায় সম্পূর্ণ পুনরায় কাজ সমাধান! আসুন ছেলেরা, আমরা ব্রেইনফাককে পরাস্ত করতে পারি: পি

function f(a,b)print((a:gsub("["..b.."]","%1%1")))end

টমমরোর ব্যাখ্যা আসছে। এখানে চেষ্টা করুন।

আসল সমাধান: @ কিরবিফ্যান64সোসকে 2 বাইট সংরক্ষিত!

গল্ফ দেওয়ার জন্য লুয়া একটি খুব ভয়ঙ্কর ভাষা, তাই আমি মনে করি আমি এইটির জন্য বেশ ভাল ব্যবহার করেছি।

function f(x,y)for i=1,#x do g=y:sub(i,i)x=x:gsub(g,g..g,1)end print(x)end

কোড ব্যাখ্যা, অসম্পূর্ণ সংস্করণ সহ:

function f(x,y) --Define a function that takes the arguements x and y (x is the string to stretch, y is how to stretch it)
  for i=1,#x do --A basic for loop going up to the length of x
    g=y:sub(i,i) -- Define g as y's "i"th letter
    x=x:gsub(g,g..g,1) --Redefine x as x with all letter "g"s having an appended g after them, with a replace limit of 1.
  end
  print(x)
end

এখানে চেষ্টা করুন। (পুরানো কোড তবে একই ধারণা, কেবল কম গল্ফযুক্ত, টমমরো আপডেট করবে)

দুটি বাইটে যুক্ত করা হয়েছে কারণ আমাকে এই সমস্যাটি ঠিক করতে হয়েছিল যেখানে এটি অ্যারেতে বর্ণিত সমস্ত অক্ষরকে তাদের নকলের সাথে প্রতিস্থাপন করবে।

আমি মনে করি আপনি দুটি বাইট সংরক্ষণের পরে function f(x,y)এবং পরে নতুন লাইনগুলি সরিয়ে ফেলতে পারেন print(x)।

— kirbyfan64sos

শব্দ টানা

ইনপুট

আউটপুট

উদাহরণ

পাইথ, 14 বাইট

ব্রেনফাক, 46 45 (ইনপুট প্রিন্টযোগ্য অক্ষর সহ 63)

সিজেম, 15 বাইট

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

সি, 62 বাইট

সিজেম, 15 বাইট

ব্যাখ্যা

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

ব্যাখ্যা

পাইথন, 61

প্রোলোগ, 95 83 79 56 বাইট

পাইথন 2, 83 74 72 65 বাইট

এক্সেল ভিবিএ, 110 বাইট

হাস্কেল, 42 বাইট

Pyth, 18 17 বাইট

ব্যাখ্যা:

মূল সংস্করণ:

জাভাস্ক্রিপ্ট, 47 বাইট

পাইথ, 16 বাইট

ব্যাখ্যা

জাভাস্ক্রিপ্ট ES6, 47 বাইট

> <> (ফিশ) , 68 34 বাইট

আর, 119

পার্ল, 73 62 59 56

রুবি, 52 47 বাইট

পার্ল, 51 বাইট

REGXY, 24 বাইট

জাভাস্ক্রিপ্ট ES6, 72 বাইট

পাইথন 2, 77

আরএস, 39 বাইট

জাভাস্ক্রিপ্ট, 92 টি অক্ষর

আর, 136 128 122 বাইট

বাশ + সেড, 51

পাইথন, 53 92 বাইট

পাইথন 2:

পাইথন 3:

গণিত, 66 বাইট

লুয়া, 76 78 76 75 58 53 বাইট