टूटते हुए शब्द

Question

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

उदाहरण के लिए:

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

इनपुट

• प्रारंभिक शब्द (जैसे chameleon)
• [c,a,l,n]किसी सरणी ( caln), या कुछ इसी तरह का प्रतिनिधित्व करने के लिए वर्णों की एक सरणी ( ) या एक स्ट्रिंग
• इनपुट फ़ंक्शन मापदंडों, एसटीडीआईएन या भाषा समकक्षों के माध्यम से हो सकता है
• सभी इनपुट कम-केस वाले अक्षर (az) होंगे

उत्पादन

• बदला हुआ शब्द

• यदि कई समाधान हैं, तो कोई भी मुद्रित किया जा सकता है

  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&]*(?:<(?:s>[^&]*<\/s>|[^&]+>)[^\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>

Comments

@AlexA। केवल एक उदाहरण क्योंकि अन्यथा डुप्लिकेट अक्षरों द्वारा बनाई गई सरणी होगी [c,o,c,o], बजाय [c,o]।

— स्ट्रेच मणिक

क्षमा करें, इसे फिर से पढ़ना स्पष्ट है। धन्यवाद।

— एलेक्स ए।

यह देखकर काफी जवाब मिला, और कई एक ही भाषा में, क्या आप लीडरबोर्ड स्निपेट को जोड़ने में रुचि रखते हैं ? यदि ऐसा है, तो मुझे इसे संपादित करने और आवश्यक हेडर प्रारूप का उपयोग न करने वाले उत्तरों में संशोधन करने में खुशी हो रही है।

— मार्टिन एंडर

@ मार्टिनबटनर मैं इसके बारे में भूल गया! जोड़ा गया। मुझे आपके स्निपेट में ओवरलैपिंग कॉलम से बचने के लिए बदलना #answer-listऔर #language-listचौड़ाई देना 50%था।

— स्ट्रेच मणिक

स्पष्टीकरण (मेरा bash+ sedउत्तर देखें ): क्या यह banana, na=> के लिए अवैध है baannana? मेरा मानना ​​था कि "आप मान सकते हैं कि सभी इनपुट में सरणी में अक्षर होंगे (क्रम में)" परमिट के लिए है , लेकिन आवश्यकता नहीं है , उत्तर दोनों सूचियों को क्रमिक रूप से संसाधित करने के लिए, लेकिन @manatwork ने इसे अलग तरीके से व्याख्या की।

— टोबी स्पाइट

Answer 1

अजगर, 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.

Answer 2

ब्रेनफक, 46 45 (63 इनपुट में मुद्रण योग्य पात्रों के साथ)

एलेक्स Pankratov के साथ संगत BFF (brainfuck Spoj और ideone पर इस्तेमाल किया दुभाषिया) और थॉमस Cort के बीएफआई (अराजकता गोल्फ पर इस्तेमाल किया)।

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

आइडोन पर प्रदर्शन ।

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

हम \x00टैब के बजाय विभाजक के रूप में उपयोग करके कुछ बाइट्स बचा सकते हैं :

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

Comments

यह महसूस करते हुए कि बीएफ मेरे पाइथन कोड से कम है .. :(

— केड

मैं आमतौर पर Brainfuck के लिए परवाह नहीं है, लेकिन यह बहुत बढ़िया है!

— डेनिस

ये सुन्दर है।

— जोशपब्रॉन

Answer 3

सीजेएम, 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).

Comments

यह CJams की लड़ाई है! आपके और Sp दोनों के पास 15 बाइट CJam उत्तर हैं, और 15 वर्तमान में सबसे छोटा है। :)

— एलेक्स ए।

@AlexA। बस पाइथ का इंतजार करें। आप बस इंतजार करें ...

— Sp3000

लगता है कि आप बेहतर सीखेंगे पायथ। ;)

— एलेक्स ए।

Answer 4

सी, 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++);

Comments

मुझे अल्पविराम ऑपरेटर बनाने के लिए धन्यवाद । यह उपयोगी है!

— ओलिपहंट - मोनिका

Answer 5

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

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

एक वैकल्पिक सीजेएम दृष्टिकोण। इसे ऑनलाइन आज़माएं

व्याख्या

दूसरे तार में प्रत्येक वर्ण के लिए, हम दो काम करते हैं।

1. चरित्र द्वारा स्ट्रिंग के वर्तमान प्रत्यय को विभाजित करें, जैसे "beeper" "e" -> ["b" "" "p" "r"]

2. सरणी में पहले स्ट्रिंग को अनसुना कर दो अक्षर डालें, फिर बाकी सरणी को वर्ण के साथ फिर से जोड़ दें, जैसे "b" "ee" "eper"। अंतिम स्ट्रिंग नया प्रत्यय है।

Answer 6

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

रेटिना के बारे में अधिक जानकारी।

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

यह एक नई लाइन द्वारा अलग किए गए STDIN पर दो तार की अपेक्षा करता है।

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

व्याख्या

(आउटडेटेड ... मैं मार्कर से छुटकारा पाने में कामयाब रहा ... मैं इसे बाद में अपडेट करूंगा।)

लाइनों की प्रत्येक जोड़ी एक रेगेक्स प्रतिस्थापन है (पहली पंक्ति पैटर्न, दूसरी पंक्ति प्रतिस्थापन)।

^
#

यह #इनपुट स्ट्रिंग की शुरुआत में एक मार्कर के रूप में डालता है ।

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

यह इनपुट के पहले अक्षर को (मार्कर के बाद) डुप्लिकेट किए जाने वाले अगले अक्षर के अनुरूप पाता है, उस अक्षर को डुप्लिकेट करता है, मार्कर को उसके पीछे ले जाता है, और दूसरे स्ट्रिंग के पहले चरित्र को ड्रॉप करता है। +`मोर्चे पर रेटिना बताता है (क्योंकि दूसरी स्ट्रिंग खाली है और सभी आवश्यक पत्र दोहराया गया है, इस मामले में) इस बार बार जब तक स्ट्रिंग को बदलने बंद हो जाता है क्या करना है।

#
<empty>

अंत में, हम मार्कर को गिराकर स्ट्रिंग को साफ करते हैं।

Comments

मुझे लगा कि रेटिना का एक अच्छा समाधान होगा, और मैं सही था, क्योंकि आपने एक पाया था। इसके अलावा, जब मैंने पहली बार आपके विवरण को स्किम किया था, तो मैंने अंत में पढ़ा था "हम माइक को गिराकर स्ट्रिंग को साफ करते हैं ।"

— mbomb007

@ mbomb007 मैं "माइक" से छुटकारा पाने की उम्मीद कर रहा था केवल व्यक्तिगत पत्रों की नकल करके जो उनके बाद कोई डुप्लिकेट नहीं है, लेकिन मैं इसे 33 बाइट्स से कम में नहीं कर सकता। (संशोधन इतिहास में एक टूटा हुआ 28 बाइट संस्करण है।)

— मार्टिन एंडर

@ mbomb007 FYI करें, मैंने अब मार्कर को हटाने का प्रबंधन किया, लेकिन बाइट की गिनती अभी भी समान है। हालांकि यह अभी भी देखने योग्य है।

— मार्टिन एंडर

एक अलग रूप में, मैं सिर्फ महसूस किया के रूप में है कि रेटिना पर एक पेज नहीं है esolangs.org

— mbomb007

@ mbomb007 हां, मुझे पता है। अधिक महत्वपूर्ण बकाया सुविधाओं में से कुछ को लागू करने के बाद मैं संभवतः एक जोड़ दूंगा।

— मार्टिन एंडर

Answer 7

अजगर, ६१

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]एक सूचकांक-आउट-ऑफ-बाउंड त्रुटि जब से बचने के लिए sया lखाली है।

Answer 8

प्रोलॉग, 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 बाइट्स का धन्यवाद सहेजा गया

Edit2: घटित put/1SWI-Prolog का उपयोग करके 20 बाइट्स की बचत की गई writef। सहेजे गए एक बाइट की पुनरावृत्ति समाप्ति की जगह के लिए समर्पित d([],_).है d(_,_).। अगर दोनों परिभाषाओं के क्रम की dअदला-बदली की जाती है, तो काम नहीं करेगा , लेकिन हम गोल्फ कोड में इस बारे में परवाह नहीं करते हैं। कोष्ठक को चारों ओर से हटाकर एक और 2 बाइट्स सहेजेH=[A|T],put(A),d(S,T)

Comments

मैं सच में यकीन नहीं कर रहा हूँ कि यह क्यों घट गया। शायद अपने कोड में कुछ स्पष्टीकरण जोड़ें?

— एलेक्स ए।

आप अंतर्निहित रूप से एकीकृत करके चार बाइट्स बचा सकते हैं H=[A|T]:। इसके अलावा, क्यों नहीं इसे थोड़ा और पठनीय बनाकर नए स्थानों के साथ रिक्त स्थान बदल दिया जाए?

— ओलिपहंट - मोनिका

@Oliphaunt इस सुझाव के लिए धन्यवाद, मैंने मूल रूप से H = [A | T] क्लॉज का उपयोग करने के लिए अपने कोड को संशोधित करने के बाद इस मामूली अनुकूलन को नहीं देखा।

— घातक

Answer 9

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

यहां कोई वास्तविक विशेष चाल नहीं है। xयह स्ट्रिंग है, yवर्णों की सरणी है जो डुप्लिकेट हैं। यह स्पष्ट करने के लिए कि क्या यह ठीक से नकल नहीं करता है, पहला इंडेंटेशन स्तर एक स्थान है, अगला एक टैब है।

संपादित करें 1: पॉप () के बजाय स्ट्रिंग हेरफेर का उपयोग करके सहेजे गए 9 बाइट्स।

संपादित 2: 1 -~से वेतन वृद्धि का उपयोग करके 2 बाइट्स सहेजे gगए।

संपादित 3: y[:1]चाल का उपयोग करके 7 बाइट्स सहेजे गए , इसके लिए xnor को धन्यवाद!

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.

Comments

"आप मान सकते हैं कि सभी इनपुटों में सरणी में अक्षर होंगे (क्रम में)।" जिससे आपको काफी बाइट्स बचानी चाहिए।

— mbomb007

आप संभवतः-रिक्त स्ट्रिंग से पहला तत्व प्राप्त कर सकते हैं y[:1]।

— xnor

मुझे अब एहसास हुआ कि आप इसे नहीं बचा सकते क्योंकि मैंने सोचा था कि आप इसे कैसे कर रहे हैं y=y[g:], इसलिए "काफी कुछ" काफी अतिशयोक्ति है।

— mbomb007

@ Vioz- मैं सोच रहा था y[:1]==c। क्या वह काम करता है?

— xnor

@xnor हां, यह होता है अगर मैं उन पत्रों को ले लेता हूं जिनके बदले प्रतिस्थापन की आवश्यकता होती है। धन्यवाद!

— केड

Answer 10

एक्सेल VBA, 110 बाइट्स

यह कोडगॉल्फ की मेरी पहली प्रविष्टि है इसलिए मुझे आशा है कि यह ठीक है।

आप A1 में इनपुट शब्द दर्ज करते हैं और फिर अक्षरों को B1 में प्रतिस्थापित किया जाता है और परिणामी शब्द एक संदेश बॉक्स में प्रदर्शित किया जाता है।

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

Comments

यदि VBA इंडेंटेशन-संवेदी नहीं है, तो आप सभी इंडेंट से छुटकारा पा सकते हैं और कुछ बाइट्स बचा सकते हैं। मुझे लगता है कि आप कॉमा और ऑपरेटर के आसपास के सभी रिक्त स्थान से छुटकारा पा सकते हैं। आपको कुछ बाइट्स बचाने की आवश्यकता है।

— निधि मोनिका का मुकदमा

@QPaysTaxes आपके संपादन के लिए धन्यवाद। मैंने रोलबैक को सिर्फ यह देखने के लिए दबाया कि यह क्या करेगा। यकीन नहीं है कि अगर आप अपने संपादन के लिए अंक या कुछ खो दिया है?

— वॉयटबॉय

नहीं, मेरे पास अभी भी +2 है, हालांकि मैं थोड़ा उलझन में था। आप फिर से वापस रोल करना चाह सकते हैं; कम से कम तीन उच्च-प्रतिनिधि लोगों के अनुसार, यह एक अच्छा संपादन था।

— निधि मोनिका का मुकदमा

@QPaysTaxes मैं सहमत हूं कि मुझे संपादन पसंद है। मुझे लगता है कि मैंने अभी कई बार एक रोलबैक किया है।

— वॉयटबॉय

मैं बता नहीं सकता। मोबाइल वास्तव में अच्छी तरह से चीजों को प्रदर्शित नहीं करता है। अंततः, हालांकि, क्या मायने रखता है कोड, स्वरूपण नहीं।

— निधि मोनिका का मुकदमा

Answer 11

हास्केल, 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"

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

यदि एक स्ट्रिंग खाली है, तो परिणाम पहली स्ट्रिंग है। एल्स: यदि स्ट्रिंग्स के पहले अक्षर मेल खाते हैं, तो इसे दो बार लें और स्ट्रिंग्स की पूंछ के साथ एक पुनरावर्ती कॉल को जोड़ दें। यदि वर्ण मेल नहीं खाते हैं, तो पहले स्ट्रिंग का पहला वर्ण लें और पहले स्ट्रिंग और उसी दूसरे स्ट्रिंग की पूंछ के साथ एक पुनरावर्ती कॉल को जोड़ दें।

Answer 12

पायथ, 18 17 बाइट्स

sm?+d.(QZqd&QhQdz

लाइव डेमो।

@Jakube के लिए 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

मूल के लिए लाइव डेमो।

Answer 13

जावास्क्रिप्ट, 47 बाइट्स

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

कुछ ES6 सुविधाओं का लाभ उठाते हुए।

Comments

इस काम के लिए सही ढंग से करता है onomatopoeia, oao?

— एलेक्स ए।

@AlexA। आउटपुट: "ओनोओमातोओपोइया"। आह! मुझे समझ आ गया। ठीक हो जाएगा

— अनाज

निश्चित, मुझे लगता है। कई पात्रों को जोड़ा :(

— अनाज

इसके बजाय b.indexOf(d)==0, कोशिश करें~b.search(d)

— इस्माईल मिगुएल

@IsmaelMiguel searchकेवल स्ट्रिंग्स पर लागू होता है। B को एक सरणी में बदलना था

— Cereal

Answer 14

पायथ, 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

Comments

@ आइसाकग मदद? कुछ कम होना चाहिए ...

— जक्यूब

और अधिक सुंदर ;-)

— जकुबे

इसे 14 में मिला - CJam से 1 कम सबसे अच्छी जगह है।

— ईसैक

Answer 15

जावास्क्रिप्ट ईएस 6, 47 बाइट्स

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

मान लिया गया sहै एक सरणी है["c","a","l","n"]

Answer 16

> <> (मछली) , 68 34 बाइट्स

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

आप इसे http://fishlanguage.com/playground पर चला सकते हैं स्ट्रिंग को प्रारंभिक स्टैक ("निशान," "गिरगिट") और इनपुट स्टैक के रूप में अतिरिक्त अक्षरों के सरणी (नहीं "निशान के रूप में) के रूप में चला सकते हैं।

इनपुट स्टैक को सीड करने के लिए Give बटन दबाना न भूलें।

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))

संपादित करें: इसे हटा दिया गया! :)

Answer 17

आर, ११ ९

@ एलेक्स के जवाब के आधार पर , यह बाइट्स के एक जोड़े को छोटा है:

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
        }
      )
    )
  )
}

Answer 18

पर्ल, 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}

Comments

नया संस्करण अब वर्ण क्रम का सम्मान नहीं करता है। (BTW, " foreachकीवर्ड वास्तव में कीवर्ड का एक पर्याय है for, इसलिए आप या तो उपयोग कर सकते हैं।" - Foreach Loops ।)

— manatwork

@manatwork इसे करना चाहिए। और forसंकेत के लिए धन्यवाद । यह वास्तव में अब छोटा है।

— जज

Answer 19

माणिक, 52 47 बाइट्स

समाधान:

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

उदाहरण:

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

स्पष्टीकरण:

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

---

अद्यतन करें

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

Comments

आप कोष्ठक को मापदंडों के आसपास छोड़ सकते हैं s,a। और *''के बराबर है .join। यह 5 बाइट्स बचा है, लेकिन मैं अभी भी हरा रहा हूं आपको एक (अब के लिए) से हूं: D

— daniero

Answer 20

पर्ल, 51 बाइट्स

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

इनपुट STDIN के माध्यम से प्रदान किया जाता है। पहला इनपुट प्रारंभिक शब्द (जैसे chameleon) है, दूसरा इनपुट एकल स्ट्रिंग (जैसे caln) के रूप में अक्षर हैं ।

उपरोक्त सिर्फ एक ओब्सेस्ड (पढ़ें "प्रेटियर") निम्नलिखित करने का तरीका है:

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

जैसा कि हम प्रत्येक पत्र के माध्यम से जाते हैं, हम शब्द की शुरुआत से स्रोत शब्द के अक्षर तक सिर्फ नए अक्षर से बदलते हैं, और $&हमारे परिणाम के लिए मैच (संग्रहीत ) में जोड़ते हैं । चूंकि मैच में अक्षर शामिल है और फिर पत्र के साथ प्रतिस्थापित हो जाता है, प्रत्येक अक्षर दो बार दिखाई देता है।

क्योंकि STDIN हमारे दोनों इनपुट्स के लिए एक नई लाइन कैरेक्टर जोड़ता है, हम अंतिम मैच के नए शब्द, यानी नए लाइन कैरेक्टर के अवशेषों को पकड़ने की गारंटी देते हैं।

Answer 21

REGXY, 24 बाइट्स

REGXY का उपयोग करता है , एक रेगेक्स प्रतिस्थापन आधारित भाषा का । इनपुट को प्रारंभिक शब्द और सरणी, अंतरिक्ष अलग (उदाहरण के लिए "गिरगिट caln") माना जाता है।

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

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

यदि यह मदद करता है, तो निष्पादन के पुनरावृत्त चरण निम्नानुसार हैं:

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

कार्यक्रम ऊपर दिए गए लिंक में नमूना दुभाषिया के साथ सही ढंग से संकलित और निष्पादित करता है, लेकिन समाधान शायद थोड़ा सा चुटीला है क्योंकि यह भाषा विनिर्देश की अस्पष्टता में एक धारणा पर निर्भर करता है। युक्ति बताती है कि प्रत्येक लाइन पर (/ से पहले) एक लेबल के रूप में कार्य करता है, लेकिन धारणा यह है कि एक अशक्त लेबल-पॉइंटर एक शून्य लेबल (या दूसरे शब्दों में) के साथ फ़ाइल में पहले कमांड पर वापस इंगित करेगा। वह 'शून्य' एक वैध लेबल है)। एक कम चुटीला समाधान होगा:

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

जिसकी मात्रा 27 बाइट्स तक होती है

Answer 22

जावास्क्रिप्ट ईएस 6, 72 बाइट्स

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

यह एक अनाम फ़ंक्शन है जो 2 पैरामीटर लेता है: एक स्ट्रिंग के रूप में प्रारंभिक शब्द और एक सरणी के रूप में खिंचाव करने के लिए वर्ण। Ungolfed कोड जो 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>

Answer 23

अजगर 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'])

मुझे बाइट की गिनती बहुत बुरी लगी होगी ... रिक्त स्थान और टैब के मिश्रण का उपयोग करता है।

Answer 24

आरएस, 39 बाइट्स

Rs के बारे में अधिक जानकारी।

पहले से ही रेटिना का उत्तर है, लेकिन मुझे लगता है कि यह थोड़ा अलग दृष्टिकोण का उपयोग करता है। वे अलग से भी बनाए गए थे: जब मैंने इस पर काम करना शुरू किया था, तो वह जवाब पोस्ट नहीं किया गया था।

इसके अलावा, यह एक 6 बाइट्स है वैसे भी। :)

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

लाइव डेमो और टेस्ट सूट।

Comments

मैं वास्तव में आपके दुभाषिया में उस डिबग स्विच को पसंद करता हूं।

— डेनिस

@ डेनिस धन्यवाद!

— kirbyfan64sos

Answer 25

जावास्क्रिप्ट, 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;
}

Answer 26

आर, 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 बाइट्स मिक्की और थैंक्स टू थ्री जजा!

Comments

आप cat(p,sep='')एक जोड़े के लिए सीधे उत्पादन के लिए उपयोग कर सकते हैं

— मिकी टन

@ मिक्की: ऐसा नहीं सोचा था! धन्यवाद, संपादित :)

— एलेक्स ए।

असल में, message(p)छोटा है।

— जज

@jja: मैं इसके बारे में नहीं जानता था message, यह बहुत बढ़िया है! धन्यवाद! अपने सुझाव का उपयोग करने के लिए संपादित।

— एलेक्स ए।

Answer 27

बाश + सेड, ५१

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

स्टड से इनपुट; एकल तर्क के रूप में दोहराए जाने वाले वर्ण:

$ echo chameleon | strtech caln
cchaamelleonn

यह सेड कार्यक्रम बनाकर काम करता है $2 बनाकर और फिर इसके विरुद्ध कार्य करता है $1। Sed प्रोग्राम प्रत्येक रिप्लेसमेंट लेटर की पहली घटना को उसके अपरकेस संस्करण की दो प्रतियों के साथ बदल देता है, और अंत में पूरे लॉट को डाउन करता है। ऊपर दिए गए उदाहरण के लिए, उत्पन्न सेड कार्यक्रम है

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&/"

Comments

गलत। strtech na <<< bananaआउटपुट "बैनाना" है, लेकिन पहले "एन" पर एक घटना को दोगुना किया जाना चाहिए, उसके बाद ही "ए" की घटना होगी।

— मैनटवर्क

उस मामले में, मैंने सवाल गलत समझा है; यह स्पष्ट नहीं था कि आदेश देने का मतलब यह था कि पूर्व के अक्षरों को दोगुना नहीं किया जाना चाहिए , बस यह कि आप बाद में एक को दोगुना कर पाएंगे । मेरे पास एक विकल्प के बारे में सोचना होगा जो इस नई आवश्यकता को पूरा करता है।

— टोबे स्पाइट

कोई बात नहीं, न तो मुझे यह पहली बार सही लगा। मैं सोचने के दौरान आपके उत्तर को नष्ट करने का सुझाव देता हूं (आप किसी भी समय बाद में अनिर्धारित कर सकते हैं), जिससे नीचे आने के अवसर से बचा जा सके।

— मैनटवर्क

@ मैनटवर्क: मैंने प्रश्नकर्ता को स्पष्टीकरण के लिए कहा है, और एक वैकल्पिक उत्तर प्रदान किया है जो नियमों को पढ़ने पर संतुष्ट करता है (लेकिन मुझे ऐसा करने के लिए 7 वर्णों की लागत है)

— टोबी स्पाइट

Answer 28

पायथन, 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))

Answer 29

मैथेमेटिका, 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"

Answer 30

लुआ, 76 78 76 75 58 53 बाइट्स

नई, पूरी तरह से wieselkatze और स्क्वीडदेव की मदद से समाधान reworked! दोस्तों, हम दिमाग को हरा सकते हैं: पी

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

समाधि में आने की व्याख्या। इसे यहाँ आज़माएँ।

---

मूल समाधान: @ kirbyfan64sos के लिए 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

इसे यहाँ आज़माएँ। (आउटडेटेड कोड लेकिन समान अवधारणा, बस कम गॉल्फर्ड, टोमोरो को अपडेट करेगा)

Comments

दो बाइट्स पर जोड़ा गया क्योंकि मुझे गड़बड़ को ठीक करना था जहां यह सरणी में परिभाषित सभी पत्र को अपने डुप्लिकेट के साथ बदल देगा।

मुझे लगता है कि आप दो बाइट्स सहेजने के बाद function f(x,y)और बाद में नए सिरे से हटा सकते हैं print(x)।

— kirbyfan64sos