मार्की हस्ताक्षर पत्र

41

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

उदाहरण

Input:  ['ONE', 'TWO', 'THREE', 'SEVENTEEN']
Output: ['ENO', 'TW', 'EHR', 'EENSV']

दिन 1: आपके पास कोई पत्र के साथ शुरू करते हैं, तो लिखने के लिए ONE, आप अपने सभी पत्र खरीदने E, N, O।
दिन 2: अगले दिन, आप ऊपर TWO (नीचे ले जाना ONE) चाहते हैं। आपके पास पहले से एक Oहै ONE, इसलिए आप एक अतिरिक्त खरीदते हैं TW।
दिन 3: इस बिंदु पर, आपके पास है ENOWT। लिखने के लिए THREE, आपको चाहिए EHR। ध्यान दें कि आपको अपने पास एक सेकंड खरीदने की आवश्यकता Eहै।
दिन 4: लिखने के लिए SEVENTEEN, आपको 4 Eके कुल की आवश्यकता है, जिसमें से आपके पास पहले से ही दो (तीन नहीं!) हैं, इसलिए आप दो और खरीदते हैं। आपके पास एक Tऔर एक है N, इसलिए आप शेष पत्र खरीदते हैं EENSV:।

हमने इस उदाहरण में वर्णानुक्रम से सॉर्ट किए गए आउटपुट अक्षर बनाए हैं, लेकिन आप उन्हें किसी भी क्रम में आउटपुट कर सकते हैं।

इनपुट: पत्रों के गैर-खाली तारों की एक गैर-खाली सूची A-Z। आप चाहें तो लोअरकेस का उपयोग कर सकते हैं। तार के लिए पात्रों की सूची ठीक है।

आउटपुट: प्रत्येक दिन खरीदने के लिए आवश्यक अतिरिक्त अक्षरों को आउटपुट या प्रिंट करें। एक दिन के लिए पत्र किसी भी क्रम में आउटपुट हो सकते हैं, लेकिन दिन सही क्रम में आने चाहिए।

प्रत्येक दिन के पत्रों को अन्य दिनों से अलग किया जाना चाहिए ताकि आप यह बता सकें कि एक दिन कहाँ समाप्त होता है। एक अनुगामी और / या अग्रणी विभाजक ठीक है, दोनों एक दिन के भीतर या दिनों के बीच। ध्यान दें कि एक दिन में कोई पत्र नहीं खरीदा जा सकता है, जो आउटपुट में परिलक्षित होना चाहिए (एक स्थान या खाली रेखा ठीक है, यहां तक ​​कि अंतिम दिन भी)।

परीक्षण के मामलों

['ONE', 'TWO', 'THREE', 'SEVENTEEN']
['ENO', 'TW', 'EHR', 'EENSV']

['ONE', 'TWO', 'ONE', 'THREE']
['ENO', 'TW', '', 'EHR']

['ABC', 'AABC', 'ABBC', 'ABCC', 'AABBCC']
['ABC', 'A', 'B', 'C', '']

['SHORT', 'LOONG', 'LOOOONG', 'LOOOOOOONG', 'SHORT', 'LOOONG']
['HORST', 'GLNO', 'OO', 'OOO', '', '']

यहां अलग-अलग सूचियों के रूप में सभी इनपुट और आउटपुट हैं:

[['ONE', 'TWO', 'THREE', 'SEVENTEEN'], ['ONE', 'TWO', 'ONE', 'THREE'], ['ABC', 'AABC', 'ABBC', 'ABCC', 'AABBCC'], ['SHORT', 'LOONG', 'LOOOONG', 'LOOOOOOONG', 'SHORT', 'LOOONG']]
[['ENO', 'TW', 'EHR', 'EENSV'], ['ENO', 'TW', '', 'EHR'], ['ABC', 'A', 'B', 'C', ''], ['HORST', 'GLNO', 'OO', 'OOO', '', '']]

और अंतरिक्ष-अलग स्ट्रिंग्स (आउटपुट मामले में अनुगामी रिक्त स्थान) के रूप में:

ONE TWO THREE SEVENTEEN
ONE TWO ONE THREE
ABC AABC ABBC ABCC AABBCC
SHORT LOONG LOOOONG LOOOOOOONG SHORT LOOONG

ENO TW EHR EENSV
ENO TW  EHR
ABC A B C 
HORST GLNO OO OOO

लीडरबोर्ड

कोड स्निपेट दिखाएं

code-golf  string 
— XNOR
स्रोत
5
एक जंगली लीडरबोर्ड स्क्रिप्ट उपयोगकर्ता की आयु में दिखाई दी है: ओ
— क्विंटेक
क्या हम ऐसे पात्रों की एक सरणी के रूप में आउटपुट कर सकते हैं जिन्हें सभी वर्णों की एक स्ट्रिंग के बजाय खरीदने की आवश्यकता है? जैसे:[['E', 'N', 'O'], ...]
— डाउनगोट
क्या आउटपुट SHORTLONGOOOOOअंतिम आउटपुट के लिए मान्य है? कोई सीमांकक का उपयोग कर AKA?
— मैजिक ऑक्टोपस Urn
@Downgoat हाँ, सूचियाँ चार आउटपुट के लिए ठीक हैं।
— xnor
@MagicOctopusUrn नहीं, आपको सीमांकक की आवश्यकता है, अन्यथा आप यह नहीं बता सकते हैं कि पत्र किस दिन के लिए हैं।
— xnor

जवाबों:

10

हास्केल, 54 49 बाइट्स

import Data.List
g x=zipWith(\\)x$scanl(++)""$g x

इसे ऑनलाइन आज़माएं!

हम \\इनपुट लिस्ट के युग्म अंतर सूची ( ) और आउटपुट सूची के संचयी परिशिष्ट (आरंभ करने "") की गणना करके आउटपुट सूची बनाते हैं ।

input list:                ONE       TWO       THREE        SEVENTEEN
cumulative append:         ""   +->  ONE  +->  ONETW   +->  ONETWHRE
list difference (output):  ONE -+    TW  -+    HRE    -+    SVEEN

दोनों Data.Listऔर Data.Functionदायरे में (जैसे कि लैम्बडबॉट वातावरण का उपयोग करके), इसे 30 बाइट्स तक छोटा किया जा सकता है:

fix.(.scanl(++)"").zipWith(\\)

संपादित करें: -5 बाइट्स @Sriotchilism O'Zaic के लिए धन्यवाद।

— nimi
स्रोत
— गेहूं जादूगर
10

पायथन 2 , 72 68 बाइट्स

-4 बाइट जोनाथन एलन को धन्यवाद।

p=''
for r in input():
 for x in p:r=r.replace(x,'',1)
 print r;p+=r

इसे ऑनलाइन आज़माएं!

टिप्पणी की गई

l=input()       # the list of words to write
p=''            # p contains all letters we own
for r in l:     # for each word ...
  for x in p:   # for each letter we own ...
    r=r.replace(x,'',1)   # remove one occurence from the current word
  print r       # print the remaining word
  p+=r          # add the remaining chars to p
— OVS
स्रोत
3
for r in input():4 बाइट्स बचाता है।
— जोनाथन एलन
7

पर्ल 6 , 44 बाइट्स

{$!=@;.map:{kxxv $!=.comb.Bag∖($⊎=$!):}}

इसे ऑनलाइन आज़माएं!

पात्रों की सूची की सूची के रूप में आउटपुट।

व्याख्या

{                                      } # Anonymous codeblock
 $!=@;                                   # Initialise $! to an empty list
      .map:{                          }  # Map each item in the input to
                    .comb                # The string split to characters
                         .Bag            # In a Bag
                             ∖           # Set minus
                              ($⊎=$!)    # The accumulated Bag of results
                 $!=                     # And save the result for the next item
            kxxv                     : # Then decompose the Bag into a list
— मजाक कर रहा है
स्रोत
2
गिरावट का एक कारण सराहना की जाएगी
— जो राजा
नहीं downvoter, लेकिन मैं कह रहा हूँ कि यह आउटपुट स्वरूप बहुत दूर है। Bag(E(2), N, S, V)वास्तव में दो ई को ठीक दिखाने के लिए कुछ करने की आवश्यकता होगी।
— xnor
3
क्या वास्तव में? यह सिर्फ डिफ़ॉल्ट प्रिंट स्वरूपण है। वापसी परिणाम एक अनियंत्रित सूची है जिसमें वे वर्ण होते हैं (और एक ही वर्ण के कई हो सकते हैं)। मैं इसे बेहतर ढंग से प्रतिबिंबित करने के लिए आउटपुट स्वरूपण को अपडेट करूंगा, लेकिन डाउनवोट हास्यास्पद लगता है।
— जो राजा
Downvoter, क्या आप बता सकते हैं, क्या यह I / O या कुछ और है? बैग प्रारूप के बारे में, मैं पर्ल को नहीं जानता, क्या यह पर्ल गोल्फ में आई / ओ के लिए सामान्य है? डॉक्स को देखते हुए (साइट डाउन होने के कारण कैश्ड), वे मुझे काउंट के साथ डाइट की तरह अधिक प्रतीत होते हैं, पायथन के समान है collections.Counterजिसे मैंने आउटपुट के रूप में अनुमति देने का इरादा नहीं किया था। क्या कोई आसानी से मल्टीपलिटी के साथ बैग इल्ट्स पर पुनरावृति कर सकता है, किसी सूची / सरणी के लिए डाली जा सकती है, बहुलता के साथ प्रदर्शित हो सकता है, आदि?
— xnor
3
डाउनवोट एक गलती थी, ऊपर उठने के लिए थी।
— जोनाथन एलन
7

हास्केल , 44 बाइट्स

import Data.List
foldl1(\a x->a++',':(x\\a))

इसे ऑनलाइन आज़माएं!

आउटपुट ONE,TW,HRE,SVEENदिनों के बीच अल्पविराम की तरह एक स्ट्रिंग है ।

— लिन
स्रोत
1
फोल्ड \`. And an unexpected 1` बेस केस को भी फोल्ड करने के लिए आउटपुट फॉर्मेट का अच्छा उपयोग क्या है।
— xnor
7

जावास्क्रिप्ट (Node.js) , 59 बाइट्स

a=>a.map(h=>([...t].map(c=>h=h.replace(c,'')),t+=h,h),t='')

इसे ऑनलाइन आज़माएं!

बिल्कुल सीधा समाधान। प्रत्येक शब्द के लिए h, हमारे पास पहले से मौजूद अक्षर हटा दें।

यहाँ उस कोड का एक समझाया गया संस्करण है:

f = list => {
  // the string that accumulates all the letters already bought
  let accu = '';
  // for every word in the list
  return list.map( word => {
    // for every letter already bought 
    [...accu]
      // remove the letter from the word
      .map(char => {
        return word = word.replace(char,'')
      });
    // add not bought letters to accumulator
    accu += word;
    // the reduced word (without already bought letters) should be added to result map
    // this represents the letters to buy today
    return word
  }, accu)
}

console.log(f(['ONE', 'TWO', 'THREE', 'SEVENTEEN']))
console.log(f(['ONE', 'TWO', 'ONE', 'THREE']))
console.log(f(['ABC', 'AABC', 'ABBC', 'ABCC', 'AABBCC']))
console.log(f(['SHORT', 'LOONG', 'LOOOONG', 'LOOOOOOONG', 'SHORT', 'LOOONG']))
स्निपेट का विस्तार करें

— TSH
स्रोत
आप मेरे अन्यथा अधूरे समाधान से एकमात्र सार्थक चाल उधार लेकर 1 बाइट बचा सकते हैं।
— अरनुलद
5

जे , 29 बाइट्स

-29 बाइट्स FrownyFrog के लिए धन्यवाद!

(],a.<@#~0>.-&(1#.a.=/;))/@|.

इसे ऑनलाइन आज़माएं!

मूल पोस्ट

जे , 58 बाइट्स

[:}.@>[:(],<@(/:~@({.@>@-.&(((e.<@#[){:)\));))&.>/<@a:,~|.

इसे ऑनलाइन आज़माएं!

"पुनरावृत्ति भाग का सम्मान करते हुए" अक्षरों को घटाना सुधारने में मदद करने के लिए ngn के लिए धन्यवाद।

जे के लिए एक महान फिट नहीं है, लेकिन एक शानदार व्यायाम।

चलो एक सहायक क्रिया wo("बिना") का निर्माण शुरू करते हैं जो दोहराव का सम्मान करते हुए, एक दूसरे से एक स्ट्रिंग में सभी चक्टर्स को हटा देता है। 

wo=.{.@>@-.&(((e. <@# [) {:)\)

यहां एक मजेदार विचार है: हम किसी वर्ण की प्रत्येक दोहराई गई आवृत्ति को अद्वितीय बनाते हैं, इसे आवश्यक संख्या में दोहराते हुए। इस प्रकार अगर हमारी मूल स्ट्रिंग ABBAयह हो जाए:

┌─┬─┬──┬──┐
│A│B│BB│AA│
└─┴─┴──┴──┘

एक तीसरा और Aबन जाएगा AAA। यह वाक्यांश द्वारा पूरा किया ((e. <@# [) {:)\जाता है, जो प्रत्येक उपसर्ग लेता \है, इसके अंतिम तत्व {:को देखता है, और उस उपसर्ग में सभी तत्वों का एक मुखौटा बनाता है जो e.उस अंतिम तत्व से मेल खाता है, और फिर उन तत्वों को फ़िल्टर और बॉक्स करता है <@#।

हमारे इनपुट्स के साथ "यूनिक-इफाइड" दोनों अब हम -. पुनरावृत्ति का सम्मान करते हुए सुरक्षित रूप से सामान्य सेट माइनस का उपयोग कर सकते हैं ।

फिर हम प्रत्येक परिणाम को खोलते हैं और हमारे दोहराव को "पूर्ववत" करने के लिए केवल पहला तत्व लेते हैं: {.@>

इस सहायक क्रिया को हमारे समग्र समाधान में प्लग करना (जो कि केवल इसे सुन्न कर देता है) बन जाता है:

[: }.@> [: (] , <@(/:~@wo ;))&.>/ <@a: ,~ |.

अनिवार्य रूप से, हम यहां जो कुछ भी करते हैं वह हमारी समस्या को एकल कमी के रूप में निर्धारित करता है। हम इनपुट |.को उलटना शुरू करते हैं और इसे ,~एक ऐस a:, या खाली बॉक्स में जोड़ते हैं , जो हमारे अंतिम परिणाम का प्रारंभिक मूल्य होगा, जैसे:

┌─────────┬─────┬───┬───┬──┐
│SEVENTEEN│THREE│TWO│ONE│┌┐│
│         │     │   │   ││││
│         │     │   │   │└┘│
└─────────┴─────┴───┴───┴──┘

हम कमी को प्रभावित करने के लिए प्रत्येक तत्व के बीच निम्न क्रिया करते हैं:

(] , <@(/:~@wo ;))/

यह कहता है: सही इनपुट लें ](यानी, हमारा परिणाम) और इसे , बाएं इनपुट में जोड़ें (यह ONEपहली पुनरावृत्ति TWOपर है, 2 पर, आदि) सही इनपुट woकी लकीर के ;बिना (यानी, अब तक किसी भी पिछले पत्र के बिना) उपयोग किया जाता है), लेकिन इसे क्रमबद्ध करने से पहले /:~और इसे फिर से बॉक्स करें <@।

इस सब के अंत में हमारे पास वह परिणाम होगा जो हम चाहते हैं, बक्से की एक सूची, लेकिन सभी एक बड़े अतिरिक्त बॉक्स के अंदर, और अभी भी सामने वाले खाली बॉक्स के साथ। इस प्रकार हम बाहरी बॉक्स को हटाने और पहले तत्व को मारने के लिए खोलते हैं }.@>:।

— जोनाह
स्रोत
[:}.@>|.(],a.<@#~0>.-&(1#.a.=/;))&.>/@,<@a:
— FrownyFrog
एक साधारण (],a.<@#~0>.-&(1#.a.=/;))/@|.भी काम करता है जब तक कि मैं एक किनारे के मामले को याद नहीं कर रहा हूं।
— FrownyFrog
जहाँ तक मैं बता सकता हूँ, छँटाई आवश्यकताओं में कहीं नहीं है।
— फ्रॉन्फ्रोग्रोग
2
अपडेट किया गया और अब जबकि मेरे पास इसे अवशोषित करने का समय है, बस फिर से कहना चाहता था: यह बहुत अच्छा है!
— योना
4

जावास्क्रिप्ट (ईएस 6),  66  65 बाइट्स

a=>a.map(b=s=>[...s].filter(c=>x==(x=x.replace(c))?b+=c:0,x=b+0))

इसे ऑनलाइन आज़माएं!

टिप्पणी की गई

bbxcxb

a =>                      // a[] = input
  a.map(b =               // initialize b to the callback function of this map()
                          // it will be coerced to a string that does not contain
                          // any letter in uppercase
    s =>                  // for each entry s in a[]:
    [...s].filter(c =>    //   for each character c in s:
      x == (              //     check whether x is changed when
        x = x.replace(c)  //     c is replaced with 'undefined'
      ) ?                 //     if so:
        b += c            //       append c to b and keep c
      :                   //     else:
        0,                //       discard c
      x = b + 0           //     coerce b to a string and save it in x
    )                     //   end of filter()
  )                       // end of map()
— Arnauld
स्रोत
4

सी ++ (जीसीसी) , 177 170 बाइट्स

-5 बाइट्स @ अनातोलीग की टिप के लिए धन्यवाद, मैंने देखा कि छोटी चीजों के लिए -2 बाइट्स।

#import<random>
#define v std::vector<std::string>
v a(v p){std::vector<int>o(91),b;int j=-1;for(auto i:p){b=o;p[++j]="";for(int c:i)--b[c]<0?p[j]+=c,++o[c]:0;}return p;}

व्याख्या

#import<random>दोनों को जोड़ता है <string>और <vector>आधे बाइट्स के लिए।

पहले 0s का 91-तत्व वेक्टर बनाता है (केवल सूचक 65-90 का उपयोग पत्र घटनाओं को संग्रहीत करने के लिए किया जाता है), और उसी प्रकार का एक और वेक्टर लेकिन मूल्य पर सेट नहीं किया जाता है। इनपुट के प्रत्येक तत्व (दिनों) के माध्यम से Iterates: वर्तमान में स्वामित्व वाले पत्र प्राप्त करता है, दिन के लिए आवश्यक पत्र प्राप्त करता है, आवश्यक मात्रा के साथ सूचकांक पर इनपुट को ओवरराइड करता है और स्वामित्व पत्रों को अपडेट करता है। ओवरराइड किए गए इनपुट को लौटाता है।

इसे ऑनलाइन आज़माएं!

— नील ए।
स्रोत
आप बाइट की संख्या 6 बाइट को कम करने के लिए कर सकते हैं #define v std::vector<std::stringऔर हटा सकते हैं using namespace std।
— एंथोलीग
2

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 123 बाइट्स

a=>{var b="";for(dynamic i=0,e,f;i<a.Count;b+=a[i++]=f)foreach(var c in((e,f)=(b.ToList(),"")).f+a[i])f+=e.Remove(c)?"":c;}

इसे ऑनलाइन आज़माएं!

अनाम फ़ंक्शन जो इनपुट सरणी को संशोधित करके आउटपुट करता है।

// a: input array of strings
a=>{
  // b: cumulative letters
  var b="";
  for(
    // i: loop index of string
    // e: copy of cumulative letters for manipulation
    // f: characters missing from current string
    dynamic i=0,e,f;
    // iterate over each string in a
    i<a.Count;
    // add missing letters of the day to
    // cumulative missing letters and
    // update array for output
    b+=a[i++]=f
  )
    // iterate current string with character c
    foreach(var c in
      // tuplized variable assignment
      // e=b.ToList()
      //   set e to a copy of the cumulative letters
      // f=""
      //   initially there are no letters needed for the day
      ((e,f)=
      (b.ToList(),"")).f+a[i]
    )
      // conditionally add c to missing letters for the day
      f+=e.Remove(c)?"":c;
}
— दाना
स्रोत
2

आर, 119 112 106 103 बाइट्स

-7 बाइट्स को दो लंबे समय तक काम करने वाले नामों को अलियास करने और अब scan()
-6 बाइट्स से उपयोगकर्ता इनपुट लेने के लिए strsplit(), शुरुआत में एक बार कॉल
करने के लिए -3 बाइट्स फिर से अलियासिंग से छुटकारा पाने के लिए और एक कॉल में दो वेरिएबल्स असाइन करें

(बाइट गिनती भी संपादित की गई थी जो पहले कम थी)

a=scan(,'');b=a=strsplit(a,'');for(i in 2:length(a))b[[i]]=vecsets::vsetdiff(a[[i]],unlist(b[1:i-1]));b

यह किसी भी तरह का मेरा पहला PPCG सबमिशन है! इसलिए मुझे नहीं पता कि गोल्फिंग के संदर्भ में और शिष्टाचार पोस्ट करने के संदर्भ में मैं क्या कर रहा हूं। आउटपुट वैक्टर की एक सूची है जो चुनौती की शर्तों को पूरा कर सकता है या नहीं कर सकता है। :-P

कोड के लिए के रूप में, यह उपयोगकर्ता इनपुट के माध्यम से लेता है scan()और प्रत्येक नए दिन के पत्रों की तुलना संचयी रूप से स्वामित्व वाले पत्रों से करता है, अन्य समाधानों की तरह। यदि व्यक्तिगत पात्रों के वैक्टरों में तार बदलने के लिए unlistऔर उसके छोटे विकल्प उपलब्ध हैं, जिन्हें strsplitजानना अच्छा होगा। मैंने अगले दिन के लिए आवश्यक पत्रों के सेट अंतर और वर्तमान में स्वामित्व वाले पत्रों को प्राप्त करने के लिए vsetdiffकार्ल विथॉफ्ट के vecsetsपैकेज में फ़ंक्शन का उपयोग किया ।

— qdread
स्रोत
1
नहीं, यह पूरी तरह से ठीक है। मैं बाहरी पैकेजों का उपयोग करने में खुद को थोड़ा अनिच्छुक हूं, लेकिन यह सिर्फ मेरे लिए है ... मैं बेस आर कोड में चुनौतियों का सामना करना चाहता हूं;)
— डाइजेक्सिल
1
— digEmAll
1
— digEmAll
1
— digEmAll
1
— बदौलत
2

जाप , 15 14 बाइट्स

£Q®X=rZPPÃQ±XX

कोशिश करो

£Q®X=rZPPÃQ±XX     :Implicit input of array
£                  :Map each X
 Q®                :  Map each Z in Q (initially a quotation mark)
   X=              :    Reassign to X
     rZ            :    Replace Z with
       P           :    The empty string
        P          :    With the default global flag disabled
         Ã         :  End map
          Q±X      :  Append X to Q
             X     :  Return X
— झबरा
स्रोत
1
@Downvoter, कृपया टिप्पणी छोड़ने की शालीनता रखें।
— झबरा
1

पॉवरशेल , 71 बाइट्स

$args|%{$w=$_;$p|% t*y|%{$w=$w-replace"^(.*?)$_(.*)",'$1$2'};$w;$p+=$w}

इसे ऑनलाइन आज़माएं!

इनपुट शब्द लेता है $argsऔर उन पर पुनरावृत्त करता है। प्रत्येक पुनरावृत्ति हम वर्तमान शब्द को सेट करते हैं $w, फिर $pपहले से खरीदे गए पत्रों के हमारे ool पर लूप करते हैं । प्रत्येक आंतरिक लूप, हम -replaceअपने वर्तमान $wऑर्ड पर एक रेगेक्स करते हैं , ताकि हम अपने $pओउल से पत्र के पहले उदाहरण को बदल दें । एक बार जब हम पूल में सभी पत्रों के माध्यम से चले गए हैं, तो हम शेष है $w(यानी, जिसे हमें खरीदने की आवश्यकता है) का उत्पादन करते हैं , और फिर $p+=$wअगले शब्द के लिए हमारे पूल पर उन पत्रों से निपटते हैं ।

— AdmBorkBork
स्रोत
1

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

Function z(w)
z=""
For Each x In w.Cells
v=x.value
For y=1To Len(z)
v=Replace(v,Mid(z,y,1),"",1,1)
Next
z=z&v
Next
End Function

एक्सेल रेंज के रूप में इनपुट लेता है।

— विलियम कुली
स्रोत
1

सी (जीसीसी) , 118 बाइट्स

m(a,r,q,u)char**a,*r,*q,*u;{for(;*a;a++,memcpy(r,q,255))for(memcpy(q,r,255),u=*a;*u;u++)*u=r[*u]-->0?32:(q[*u]++,*u);}

इसे ऑनलाइन आज़माएं!

एक छोटे से बोनस के रूप में यह rएक सरणी के रूप में शुरू में स्टॉक लेता है । aरिक्त स्थान के साथ सभी पूर्व स्वामित्व वाले पत्रों के साथ इनपुट को शून्य-समाप्त-शून्य-समाप्त-स्ट्रिंग सूची आउटपुट करता है ।

— LambdaBeta
स्रोत
— सीलिंगकैट
1

05AB1E , 11 बाइट्स

-6 केविन क्रूज़सेन का धन्यवाद

ćsvDysSõ.;»

इसे ऑनलाइन आज़माएं!

— जादू ऑक्टोपस Urn
स्रोत
1
आपकी 15-byter काम करता है, लेकिन मैं पीछे की जगह लेंगे Jसाथ »। इसके अलावा, आप की जगह 4 बाइट बचा सकता है vyð.;}ðKके साथ Sõ.; 11 बाइट्स ।
— केविन क्रूज़सेन
अह्ह्ह ... मुझे इसे वेक्टर बनाने के लिए एस की जरूरत थी।
— मैजिक ऑक्टोपस Urn
1

स्विफ्ट 4.2 / एक्सकोड 10.2 , 244 242 239 238 बाइट्स

a.reduce(([Character:Int](),[String]())){c,l in let b=l.reduce(into:[Character:Int]()){$0[$1,default:0]+=1}.map{($0,max(0,$1-(c.0[$0] ?? 0)))};return(c.0.merging(b){$0+$1},c.1+[b.map{String(Array(repeating:$0.0,count:$0.1))}.joined()])}.1

इसे ऑनलाइन आज़माएं!

अक्षरों को वर्णानुक्रम में व्यवस्थित नहीं किया जाता है, यह नियमों द्वारा निषिद्ध नहीं है।

— रोमन पोडिमोव
स्रोत
1

स्काला, 68 बाइट्स

(c:Seq[String])=>c./:(Seq(""))((a,n)=>a:+n.diff(a./:("")(_+_))).tail

इसे ऑनलाइन आज़माएं!

/: foldLeft ऑपरेटर के लिए लघु-हाथ है, एक एकत्रीकरण है, अंततः हम जो परिणाम चाहते हैं, n अगले तत्व है

संयुक्त राष्ट्र के golfed

def NewLettersPerDay(c: Seq[String]): Seq[String] = {
    c.foldLeft(Seq(""))((agg, next) => {
      val existingLetters = agg.reduce(_+_)
      val newDayLetters = next.diff(existingLetters)
      agg :+ newDayLetters
    }).tail
}
— sprague44
स्रोत
0

चारकोल , 18 बाइट्स

ＥθΦι¬⊙…θκ‹№…ιμλ№νλ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

 θ                  Input array
Ｅ                   Map over strings
   ι                Current string
  Φ                 Map over characters
       θ            Input array
      …             Truncated to length
        κ           Outer index
    ¬               Logical Not
     ⊙              Any element exists where
          №         Count of
              λ     Current letter in
            ι       Outermost word
           …        Truncated to
             μ      Current letter index
         ‹          Is less than
               №    Count of
                 λ  Current letter in
                ν   Innermost word
                    Implicitly print each day's bought letters on their own line
— नील
स्रोत
0

PHP, UTF-8 अवगत (253 बाइट्स)

<?php $p=[];for($i=1;$i<$argc;$i++){$a=$p;$b=[];for($j=0;$j<mb_strlen($s=$argv[$i]);$j++){$k=1;if(isset($a[$c=mb_substr($s,$j,1)]))if($a[$c]){$k=0;$a[$c]--;}if($k){echo $c;if(isset($b[$c]))$b[$c]+=$k;else $b[$c]=$k;}}$p=array_merge($p,$b);echo PHP_EOL;}
— rexkogitans
स्रोत
0

C # (विजुअल C # इंटरएक्टिव कंपाइलर) , 112 बाइट्स

a=>{var b="";for(int i=0;;b+=a[i++])foreach(var z in b)if(a[i].Contains(z))a[i]=a[i].Remove(a[i].IndexOf(z),1);}

इसे ऑनलाइन आज़माएं!

— अज्ञान का अवतार
स्रोत
हम्म ... यह एक अपवाद फेंकता है?
— दाना
@ डाना मुझे पूरा यकीन है कि कुछ भी वापस नहीं आता है, अपवाद के साथ बाहर निकलने की अनुमति नहीं है
— अज्ञानता का अवतार
दिलचस्प है ... मुझे लगता है कि यह सबसे अजीब नियम नहीं है।
— दाना
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.