एक स्ट्रिंग का विवरण दें


39

बहुत सारी भाषाओं में डुप्लिकेट से छुटकारा पाने के तरीके हैं, या "डुप्लीकेट" या किसी सूची या स्ट्रिंग को "विशिष्ट" करना है। एक कम आम कार्य एक स्ट्रिंग को "खराब करना" है। अर्थात्, दिखाई देने वाले प्रत्येक वर्ण के लिए, पहले दो घटनाएँ रखी जाती हैं।

यहां एक उदाहरण दिया गया है जहां हटाए जाने वाले वर्णों के साथ लेबल किया गया है ^:

aaabcbccdbabdcd
  ^    ^ ^^^ ^^
aabcbcdd

आपका कार्य वास्तव में इस ऑपरेशन को लागू करना है।

नियम

इनपुट एक एकल, संभवतः खाली, स्ट्रिंग है। आप मान सकते हैं कि इसमें केवल ASCII रेंज के निचले अक्षर हैं।

आउटपुट सभी वर्णों के साथ एक एकल स्ट्रिंग होना चाहिए जो पहले से ही स्ट्रिंग में कम से कम दो बार दिखाई दिया है (इसलिए बाईं ओर-सबसे दो घटनाएं रखी गई हैं)।

तार के बजाय आप वर्णों की सूची (या सिंगलटन स्ट्रिंग्स) के साथ काम कर सकते हैं, लेकिन प्रारूप को इनपुट और आउटपुट के बीच संगत होना चाहिए।

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के हमारे किसी भी मानक तरीके का उपयोग कर सकते हैं।

आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं , लेकिन ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

यह , इसलिए सबसे छोटा वैध उत्तर - बाइट्स में मापा जाता है - जीतता है।

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

लाइनों की हर जोड़ी एक परीक्षण का मामला है, आउटपुट के बाद इनपुट।



xxxxx
xx
abcabc
abcabc
abcdabcaba
abcdabc
abacbadcba
abacbdc
aaabcbccdbabdcd
aabcbcdd

लीडरबोर्ड

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से एक लीडरबोर्ड उत्पन्न करता है) एक भाषा के रूप में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 3 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes


5
सिंगलटन स्ट्रिंग्स ... स्ट्रिंगलेट्स?
dkudriavtsev

जवाबों:



15

जावास्क्रिप्ट (ईएस 6), 42 48

संपादित करें एक मजबूत 6 बाइट्स ने @ xeil को बचाया

s=>s.replace(k=/./g,c=>(k[c]+=c)[11]?'':c)

स्पष्टीकरण: मैं kप्रत्येक चरित्र के लिए जानकारी संग्रहीत करने के लिए ऑब्जेक्ट के 'a' ... 'z' गुणों का उपयोग करता हूं (ऑब्जेक्ट k इस मामले में केवल बाइट्स को बचाने के लिए एक rexxp है)। ये गुण शुरू में हैं undefined। एक नंबर को जोड़ने जावास्क्रिप्ट में undefinedदेता है NaN(काफी समझदार), लेकिन जोड़ने एक स्ट्रिंग 'एक्स' देता है "undefinedX"- लंबाई 10 (मूर्ख) के एक स्ट्रिंग। अधिक वर्ण जोड़ने पर आपको लंबे तार मिलते हैं। यदि किसी दिए गए वर्ण के लिए प्राप्त स्ट्रिंग 11 से अधिक है, तो वह वर्ण आउटपुट पर कॉपी नहीं किया गया है।

परीक्षा

F=
s=>s.replace(k=/./g,c=>(k[c]+=c)[11]?'':c)

test=`

xxxxx
xx
abcabc
abcabc
abcdabcaba
abcdabc
abacbadcba
abacbdc
aaabcbccdbabdcd
aabcbcdd`.split`\n`
for(i=0;i<test.length;)
  a=test[i++],b=test[i++],r=F(a),
  console.log(r==b?'OK':'KO',a,'->',r,b)


कड़ाई से एक खाली लाइन बोलना परीक्षण के मामलों में से एक है।
नील

@ नील ओके ने खाली स्ट्रिंग टेस्ट
edc65

यदि आप सरणी इनपुट और आउटपुट पर स्विच करते हैं, तो आप 12 और वर्णों को सहेजने के लिए .filter का उपयोग कर सकते हैं। v=>v.filter(x=>!(v[x]+=x)[11])। कुडोस "अपरिभाषित" हैक पर।
ग्रैक्स

@ ग्रेक्स थैंक्स लेकिन बहुत अलग। इसे स्वयं पोस्ट करना चाहिए
edc65

14

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

lambda s:reduce(lambda r,c:r+c*(r.count(c)<2),s)

c[r.count(c)/2:]करने के लिए एक ही लंबाई विकल्प है c*(r.count(c)<2)


49 बाइट्स:

r=''
for c in input():r+=c*(r.count(c)<2)
print r

12

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

(.)(?<=\1.*\1.+)

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

साधारण रेगेक्स प्रतिस्थापित - एक चरित्र से मेल खाता है अगर यह पहले से ही दो बार दिखाई दिया, और इसे हटा दें।


मैंने एक लूप और 18 बार बाइट्स के साथ एक दोहराया समूह{2} भी आजमाया ।
कोबी

1
मैंने हाल ही में जोड़े गए फीचर का उपयोग करके 14 प्राप्त किया है। ;)
मार्टिन एंडर

मुझे पता था कि कुछ है। मैंने सीमा की ओर देखा, शायद वह नहीं। मैं फिर से जाँच करूँगा।
कोबी

3
आह, मुझे लगता है कि मुझे मार्टिन का जवाब मिला। जब मैं पहले कोशिश कर रहा था, तो मुझे कुछ परेशानी हुई, मुझे लगता है कि क्योंकि मैं इस बात पर विचार नहीं करता था कि मल्टीप्ल इनपुट पर डिडुप्लिकेट कैसे काम करेगा। स्पोइलर (प्रति पंक्ति मोड को सक्षम करने के लिए 5 बाइट्स के साथ जोड़ा गया): retina.tryitonline.net/…
FryAmTheEggman

@FryAmTheEggman - अच्छा, मुझे यह नहीं मिला। एक उत्तर जोड़ने के लिए स्वतंत्र महसूस करें - मुझे लगता है कि यह मेरे उत्तर से बहुत अलग है और मैंने इसे संपादित करने में सहज महसूस नहीं किया :P। धन्यवाद!
कोबी

6

ब्रेकीलॉग , 25 बाइट्स

.v|s.g:.z:1a
:2fl<3
he~t?

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें

व्याख्या

यह काम करता है क्योंकि s - Subsetपहले सबसे बड़े सबसेट के साथ एकीकृत होगा, इस प्रकार "aaa"इसके लिए "aa"पहले प्रयास करेगा "a"

  • मुख्य विधेय:

      .v         input = Output = ""
    |          Or
      s.         Output is an ordered subset of the input
      g:.z       Zip each character of the output with the output itself
      :1a        Apply predicate 1 on each element of the zip
    
  • 1 की भविष्यवाणी करें: जांचें कि सभी वर्ण केवल दो बार ही दिखाई देते हैं। इनपुट =[String:Char]

    :2f        Find all valid outputs of predicate 2 (i.e. one output per occurence
                   of the char)
    l<3        There are less than 3 occurences
    
  • भविष्यवाणी 2: एक चरित्र की घटना प्राप्त करें। इनपुट =[String:Char]

    he         Take a character of the string in the input
      ~t?      That character is the char of the input
    

6

> <> , 22 बाइट्स

i:0(?;::9g:}2(?o{1+$9p

इसे ऑनलाइन आज़माएं! अब तक की गिनती का ट्रैक रखने के लिए कोडबॉक्स का उपयोग करता है।

i                       Read a char c of input
 :0(?;                  Halt if EOF
      :                 Make a copy - stack has [c c] at the top
       :9g              Get count stored at (c, 9)
          :}            Copy the count and move to bottom of stack
            2(?o        If the count is less than 2, output c
                {1+     Move the count back to the top of the stack and increment
                   $9p  Update cell at (c, 9)
                        [Instruction pointer moves to start as ><> is toroidal]

6

जे, 20 15 बाइट्स

#~(3>[+/@:={:)\

यह एक राक्षसी कार्य को परिभाषित करता है जो एक स्ट्रिंग लेता है और वापस करता है। इसे यहाँ आज़माएँ । उपयोग:

   f =: #~(3>[+/@:={:)\
   f 'abaacbb'
abacb

व्याख्या

मैंने उसी एल्गोरिथ्म में स्विच किया जिसका कुछ अन्य समाधान उपयोग करते हैं, क्योंकि यह छोटा हो गया है ...

#~(3>[+/@:={:)\  Input is y.
  (          )\  For each prefix of y:
          =        compute the equality vector
     [     {:      of the prefix and its last element, and
      +/@:         take its sum. Now we have a vector r such that y[i] has its
                   r[i]'th occurrence at position i.
   3>              Mark those coordinates where r[i] < 3.
#~               Remove the non-marked characters from y.

6

हास्केल, 40 39 बाइट्स

foldl(\s c->s++[c|filter(==c)s<=[c]])""

प्रयोग उदाहरण: foldl(\s c->s++[c|filter(==c)s<=[c]])"" "aaabcbccdbabdcd"-> "aabcbcdd"

अगला चार्ट रखें cयदि सभी cs के तार अभी तक लघुकथात्मक हैं या सिंगलटन स्ट्रिंग के बराबर हैं [c]

संपादित करें: @xnor ने सूची बोध से स्विच करके एक बाइट को बचाया filter। धन्यवाद!


आपका विकल्प filter(==c)s<=[c]एक बाइट को बचाने के लिए कर सकता है ।
xnor


5

सी, 57 बाइट्स

f()स्ट्रिंग के साथ कॉल करने के लिए अलग करना। फ़ंक्शन इसके पैरामीटर को संशोधित करता है। for-लूप घोषणा के कारण C99 की आवश्यकता है ।

f(char*p){for(char*s=p,m[256]={0};*s=*p;s+=++m[*p++]<3);}

क्या आप sपहले बयान की घोषणा नहीं कर सकते for?
मार्टिन एंडर

C99 में आप कर सकते हैं। मैं सिर्फ इसलिए नहीं कि मुझे गोल्फ C89 को संगत रखना पसंद है।
उल्लू के जूलर

5

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

s=>s.filter(c=>(s[c]=(s[c]|0)+1)<3)

इनपुट के रूप में वर्णों की एक सरणी लेता है और अलग सरणी देता है।


अच्छा लगा। आप c=>(s[c]=-~s[c])<3कुछ बाइट्स को बचाने के लिए कर सकते हैं ।
ETHproductions

मुझे याद आया कि आप इनपुट के रूप में सरणियों का उपयोग कर सकते हैं और एक फ़ंक्शन का उपयोग करके लिखा था map। यह आवश्यक रूप से आपकी तरह देखा। मुख्य अंतर असाइनमेंट था, यदि आप इसे चारों ओर स्विच करेंगे तो कुछ बाइट्स बचेंगे। s.filter(c=>(s[c]=s[c]+1|0)<3)33 बाइट्स के लिए प्रयास करें । संपादित करें: वूप्स, मेरे ऊपर टिप्पणी से चूक गए, यह और भी बेहतर है :)
Jan

4

PowerShell v2 +, 31 बाइट्स

$args-replace'(.)(?<=\1.*\1.+)'

कोबी के रेटिना जवाब में उसी रेगेक्स का उपयोग करता है , जो कि पावरशेल -replaceऑपरेटर में सिर्फ समझाया जाता है । काम करता है क्योंकि दोनों पृष्ठभूमि में .NET-फ्लेवर रेगेक्स का उपयोग कर रहे हैं।

वैकल्पिक रूप से, रेगेक्स के बिना, 56 बाइट्स

$b=,0*200;-join([char[]]$args[0]|%{"$_"*($b[$_]++-lt2)})

एक सहायक सरणी बनाता है जो $bपहले से आबाद है 0। इनपुट स्ट्रिंग $args[0]को एक char-रे के रूप में रखता है, इसे एक लूप के माध्यम से पाइप करता है |%{...}। प्रत्येक पुनरावृत्ति वर्तमान चरित्र $_को एक "$_"बूलियन द्वारा गुणा किए जाने वाले स्ट्रिंग के रूप में प्रस्तुत करती है जो केवल $TRUE( 1यहाँ संक्षेप में डाली गई है) यदि सहायक बिंदु में उपयुक्त बिंदु इससे कम है 2(यानी, हमने पहले ही दो बार इस चार्ट को नहीं देखा है)। स्ट्रिंग्स के परिणामी संग्रह को -joinएक ही आउटपुट स्ट्रिंग बनाने के लिए एक साथ Parens और ed में समझाया गया है । यह पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।


regex अपराजेय है। :) मैं एक हैशटेबल बेहतर है फिर rexx के बिना संस्करण के लिए एक सरणी $b=@{};-join($args|% t*y|?{++$b.$_-lt3}):।
माज़ी

1
@ mazzy रेगेक्स और आपके कोड के बिना संस्करण के लिए, इसे PowerShell 2 की तुलना में एक नया संस्करण बनाने की आवश्यकता होगी। नतीजतन, मुझे लगता है कि मैं इस जवाब को बिना बदलाव के रखूंगा। आप अपने कोड को एक अलग उत्तर के रूप में पोस्ट कर सकते हैं, हालांकि!
AdmBorkBork

संस्करण 3.0 में हैशटेबल दिखाई दिया? ठीक है। धन्यवाद।
माज़ी

4

गणितज्ञ, 39 बाइट्स

Fold[If[Count@##<2,Append@##,#]&,{},#]&

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



4

MATL , 8 बाइट्स

t&=Rs3<)

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

व्याख्या

t      % Input string implicitly. Push another copy
&=     % Matrix of all pairwise equality comparisons of string elements
R      % Keep only upper triangular part, making the rest of the entries zero
s      % Sum of each column. This gives a vector with number of occurrences
       % of the current character up to the current position
3<     % True for entries that are less than 3
)      % Use as logical index into initial copy of the input. Display implicitly

उदाहरण

इनपुट की मानें 'aaababbc', तो स्टैक में संकेतित कथनों के बाद निम्नलिखित शामिल हैं:

  • t

    'aaababbc'
    'aaababbc'
    
  • t&=

    'aaababbc'
    [ 1 1 1 0 1 0 0 0;
      1 1 1 0 1 0 0 0;
      1 1 1 0 1 0 0 0;
      0 0 0 1 0 1 1 0;
      1 1 1 0 1 0 0 0;
      0 0 0 1 0 1 1 0;
      0 0 0 1 0 1 1 0;
      0 0 0 0 0 0 0 1 ]
    
  • t&=R

    'aaababbc'
    [ 1 1 1 0 1 0 0 0;
      0 1 1 0 1 0 0 0;
      0 0 1 0 1 0 0 0;
      0 0 0 1 0 1 1 0;
      0 0 0 0 1 0 0 0;
      0 0 0 0 0 1 1 0;
      0 0 0 0 0 0 1 0;
      0 0 0 0 0 0 0 1 ]
    
  • t&=Rs

    'aaababbc'
    [ 1 2 3 1 4 2 3 1 ]
    
  • t&=Rs3<

    'aaababbc'
    [ true true false true false true false true ]
    
  • t&=Rs3<)

    'aabbc'
    

4

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

D`(.)(?<=\1.*)

सभी परीक्षण मामलों की जाँच करें। ( %प्रति पंक्ति मोड सक्षम करता है)

कोबी के दृष्टिकोण पर एक युगल बाइट को बचाने के लिए नए "डेडुप्लिकेट" चरण का उपयोग करता है । डेडुप्लिकेट रेगेक्स के सभी मैचों की एक सूची एकत्र करता है और सभी को प्रतिस्थापित करता है लेकिन खाली स्ट्रिंग के साथ पहला। रेगेक्स एक चरित्र से मेल खाता है जो पहले से ही एक बार स्ट्रिंग में दिखाई देता है, जिसका अर्थ है कि पहले दो को रखा जाएगा।



3

के, 18 बाइट्स

  g:{x{?x@<x}@,/2#'=x}
  g "abc"
"abc"
  g "aaabcbccdbabdcd"
"aabcbcdd"

  /k4 request test vectors from internet
  R:"GET /raw/ftHe0bpE HTTP/1.0\r\nHost: pastebin.com\r\n\r\n"
  t:+0N 2#t@1_&|\(0=#:)'t:1_"\r\n"\:`:http://pastebin.com:80 R 

  /k4 no internet? use a file called "t.txt" in current directory
  t:+0N 2#0:`:t.txt

  /k6?
  t:+0N 2#0:"t.txt"

  /visually inspect test cases
  g't[0]
(();"xx";"abcabc";"abcdabc";"abacbdc";"aabcbcdd")

  /do all tests pass?
  |/ t[1] {$[0=#x;0=#y;x~y]}' g't[0]
1b

K4 मुफ्त डाउनलोड के लिए उपलब्ध है ; K6 विकास में है । यदि आपने केडीबी डाउनलोड किया है, तो आप बैकस्लैश के साथ के में प्रवेश कर सकते हैं ।

इस टूटे हुए को देखना सबसे आसान हो सकता है, लेकिन पहले कुछ सिंटैक्स: g:xसेट gकरने के लिए x{x+1}एक फ़ंक्शन है जो एक तर्क x लेता है । K में एक फ़ंक्शन का पहला तर्क है x(दूसरा है yऔर तीसरा है z। चौथे की आवश्यकता नहीं है)।

अभी व:

x:"aaabcbccdbabdcd"

=xसमूह x का अर्थ है , जो उत्पादन करता है:

"abcd"!(0 1 2 10;3 5 9 11;4 6 7 13;8 12 14)

2#'दो का अर्थ है (प्रत्येक) जो उत्पादन करता है

"abcd"!(0 1;3 5;4 6;8 12)

जैसा कि आप देख सकते हैं, ये प्रत्येक वर्ण के पहले दो मैचों के ऑफसेट हैं। 2 सामान्यीकृत किया जा सकता है।

,/प्रत्येक में शामिल होने का मतलब है और अक्सर इसे भूलभुलैया कहा जाता है । यह हमें हमारे शब्दकोश के मूल्यों को ही प्राप्त करने वाला है। इस प्रकार, ,/"abcd"!(0 1;3 5;4 6;8 12)उत्पादन:

0 1 3 5 4 6 8 12

जिसे हमें क्रमबद्ध करने की आवश्यकता है। {x@<x}@एक मुहावरा है K प्रोग्रामर अक्सर देखते हैं (Q इसे asc कहता है ), जो ग्रेड-एक्स पर x कहता है । इसे तोड़कर:

  <0 1 3 5 4 6 8 12
0 1 2 4 3 5 6 7

सॉर्ट किए गए सरणी के सूचकांकों को लौटाया, जो हम मूल सरणी से लेना चाहते हैं। y काx@y मतलब x है, इसलिए यह सरणी के सूचकांकों के साथ सरणी को अनुक्रमित करता है (यदि वह कोई अर्थ रखता है)।

  {x@<x}@0 1 3 5 4 6 8 12
0 1 3 4 5 6 8 12

जिसे हम अभी अपने मूल सरणी में अनुक्रमित करते हैं। हम यहां कह सकते हैं x@, लेकिन K वास्तव में एक शक्तिशाली अवधारणा का समर्थन करता है जिसका हम यहां लाभ उठा सकते हैं: फ़ंक्शन एप्लिकेशन अनुक्रमण है। इसका मतलब है कि a[0]ज़ीरोथ स्लॉट की तलाश की जा सकती है aया इसे 0फंक्शन नाम से लागू किया जा सकता है a। जिस कारण से हमें @पहले की आवश्यकता थी {x@<x}क्योंकि x<yइसका मतलब है कि xs y से कम है : K में ऑपरेटर्स का एक डाइएडिक फॉर्म (दो-तर्क) और एक मोनडिक फॉर्म (एक-तर्क) है जो APL से आता है। Q में यह "अस्पष्टता" नहीं है।


PPCG में आपका स्वागत है! शानदार पहला जवाब। :)
मार्टिन एंडर

मेरे पास दो सवाल है। 1. क्या K4 वही भाषा है जिसे आप (Q / kdb +) से लिंक करते हैं? 2. क्या आप दिखा सकते हैं कि किसी इनपुट पर अपने फ़ंक्शन को कैसे कॉल करें या टेस्टवेक्टर्स में आइटम कैसे लिखें।
डेनिस

@ डेनिस 1. हाँ। Q से K तक पहुंचने के लिए बैकस्लैश दबाएं। जैसा कि वे प्रश्न में दिखाई देते हैं: pastebin.com/ftHe0bpE उदाहरण कॉल:g"aaabcbccdbabdcd"
geocar

ठीक है धन्यवाद। फ़ाइल का हिस्सा काम नहीं कर सका, लेकिन g"..."चाल है। दुर्भाग्य से, आपका कोड aabbccइनपुट के लिए वापस आ जाता है abc
डेनिस

@ डेनिस आपने कुछ गलत किया होगा: {x{?x@<x}@,/2#'=x}"abc"निश्चित रूप से रिटर्न "abc""aabbcc"यदि आप ?विशिष्ट याद करते हैं तो यह वापस आ जाएगी ।
जियोकार

2

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

f=lambda s:s and f(s[:-1])+s[-1]*(s.count(s[-1])<3)

Ideone पर इसका परीक्षण करें ।


2

जावा 8 लैम्ब्डा, 90 अक्षर

i->{int[]o=new int[128];String r="";for(char c:i.toCharArray())if(++o[c]<3)r+=c;return r;}

Ungolfed संस्करण:

public class Q86503 {

    static String detriplicate(String input) {
        int[] occurences = new int[128];
        String result = "";
        for (char c : input.toCharArray()) {
            if (++occurences[c] < 3) {
                result += c;
            }
        }
        return result;
    }
}

सभी ascii वर्णों के लिए एक सरणी बनाता है। यदि कोई वर्ण होता है, तो संबंधित काउंटर को बढ़ाया जाएगा। यदि यह 2 से अधिक है तो चरित्र परिणाम स्ट्रिंग में जोड़ा नहीं जाएगा। बहुत आसान, बहुत कम;)


2

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

{.comb.grep({++%.{$_} <3})}

स्पष्टीकरण:

{.comb.grep({++%.{$_} <3})}
{                         } # a function
 .comb                      # get all the characters in the argument
      .grep({           })  # filter
               %.           # an anonymous hash (shared between calls to grep)
             ++  {$_}       # increment the value at the current key (current letter).
                            # if the key doesn't exist, it defaults to 0 (then gets incremented)
                      <3    # return True if it wasn't seen 3 times

(नोट: पर्ल 6 अपनी बहन पर्ल 5 के रूप में "गोल्फ-ओरिएंटेड" नहीं है ... हां, इससे पहले कि अंतरिक्ष <आवश्यक है। %.{}एक अनाम हैश है)।



2

स्माइलबासिक, 77 72 69 68 बाइट्स

DIM R[#Y]READ S$WHILE""<S$Q=ASC(S$)INC R[Q]?SHIFT(S$)*(R[Q]<3);
WEND

व्याख्या की:

DIM R[128] 'array to store letter frequencies
READ S$ 'get input string
WHILE""<S$ 'much shorter than LEN(S$)
 Q=ASC(S$) 'get ascii value of first character in S$
 INC R[Q]
 ?SHIFT(S$)*(R[Q]<3); 'remove the first character of S$, and print it if there are less than 3 occurrences.
WEND

Ppcg में आपका स्वागत है! अच्छी पहली पोस्ट!
R

1

आम लिस्प, 127

(lambda(s)(map()(lambda(x)(flet((p(b)(1+(position x s :start b))))(setf s(remove x s :start(p(p 0))))))(remove-duplicates s))s)

सुंदर मुद्रित

(lambda (s)
  (map nil
       (lambda (x)
         (flet ((p (b)
                  (1+ (position x s :start b))))
           (setf s (remove x s :start (p (p 0))))))
       (remove-duplicates s))
  s)

1

क्यू , 52 बाइट्स

q)f2:{x asc raze{distinct 2#where x}each x~'/:distinct x}
q)f2 each testList
"xx"
"abcabc"
"abcdabc"
"abacbdc"
"aabcbcdd"
q)

1

के , 27 बाइट्स

    f:{x{x@<x}@,/{?2#&x}'x~'/:?x}
    testList:("xxxxx";"abcabc";"abcdabcaba";"abacbadcba";"aaabcbccdbabdcd")
    f'testList
("xx";"abcabc";"abcdabc";"abacbdc";"aabcbcdd")

1

रूबी , 79 62 57 बाइट्स

यह बहुत ही सुंदर है, लेकिन मुझे यकीन नहीं है कि मैं इस समय इसे बेहतर कर सकता हूं। किसी भी गोल्फ सुझाव का स्वागत है। इसे ऑनलाइन आज़माएं!

संपादित करें: -17 बाइट्स, ट्रिपल इंक को हटाने के लिए गोल्फर का सुझाव देकर वैल्यू इंक के लिए धन्यवाद। -5 बाइट्स .uniqविधि को हटाने से ।

->s{s.chars.map{|a|s[s.rindex a]=""while s.count(a)>2};s}

Ungolfed:

def g(s)
 s.chars.each do |a|
  while s.count(a) > 2
   i = s.rindex(a)
   s[i] = ""
  end
 end
 return s
end

62 बाइट्स:->s{s.chars.uniq.map{|a|s[s.rindex a]=""while s.count(a)>2};s}
वैल्यू इंक

1

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

v=>v.filter(x=>!(v[x]+=x)[11])

उस विधि का उपयोग करना जो @ edc65 की गिनती के लिए आया लेकिन एक सरणी फ़िल्टर के साथ। पहली बार चरित्र दिखाई देता है, ऑब्जेक्ट वैल्यू "अपरिभाषित" प्लस चरित्र (यानी "अपरिभाषित") हो जाता है। अगली बार ऑब्जेक्ट मान "अपरिभाषित" हो जाता है।

उसके बाद, v [x] [११] सही हो जाता है और जब संचालक के साथ नहीं जोड़ा जाता है, तो झूठे, अर्थ वाले अक्षर जो पहले ही दो बार दिखाई दे चुके हैं, फ़िल्टर किए जाएंगे।


0

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (80 बाइट्स)

यह एक अच्छा वाला था! जीत नहीं थी, लेकिन यह मजेदार था

n=>{a={};return _.From(n).Where(x=>{b=a[x]?a[x]++:a[x]=1;return b<2}).Write("")}

लिंक ऑफ लिब: https://github.com/mvegh1/Enumerable/

कोड स्पष्टीकरण: विधि एक स्ट्रिंग को स्वीकार करती है, लाइब्रेरी इसे चार सरणी के रूप में पार्स करती है, और जहां क्लॉज एक जटिल फ़िल्टरिंग विधेय है जो वर्तमान चार्ट की उपस्थिति के लिए 'a' हैशमैप की जांच करता है। यदि मौजूद है, तो वृद्धि काउंटर, और 1 पर सेट है। यदि <2, विधेय (और वर्तमान चार) गुजरता है, तो अन्य विफल

यहाँ छवि विवरण दर्ज करें


आप returnकोष्ठकों में अभिव्यक्तियों की अल्पविराम से अलग सूची बनाकर अपने कार्य का उपयोग करने से बच सकते हैं n=>(a={},_From(n)....):। अंतिम अभिव्यक्ति रिटर्न वैल्यू है। अपने Whereफ़ंक्शन में, आप bअसाइनमेंट या वेतन वृद्धि के परिणाम की तुलना करके मध्यवर्ती को पूरी तरह से समाप्त कर सकते हैं x=>(a[x]?a[x]++:a[x]=1)<2:।
अप्सिलर्स

अंत में, आप सभी (और बाइट्स सेव) पर एक बाहरी लाइब्रेरी का उपयोग कर स्ट्रिंग विभाजित अंडाकार और का उपयोग कर से बचने कर सकते filterके साथ join: [...n].filter(...).join("")। सही / गलत तर्क फ्लिप जब बदल रहा Whereकरने के लिए filter
अप्सिलर्स

आह अच्छा अवलोकन! बीमार अपने सुझाव पर बाद में एक करीब से देखो
applejacks01

0

क्लोजर, 72 बाइट्स

#(apply str(reduce(fn[r c](if(<(count(filter #{c}r))2)(conj r c)r))[]%))

इतने सारे बाइट्स ...


0

पास्कल (एफपीसी) , 103 बाइट्स

var a:array['a'..'z']of word;c:char;begin repeat read(c);inc(a[c]);if a[c]<3then write(c)until eof end.

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

स्पष्टीकरण:

var a:array['a'..'z']of word; //used for counting occurences of characters in the input
                              //array indices are accessed by chars
    c:char;
begin
  repeat
    read(c);                  //read a character from input
    inc(a[c]);                //increment the count of that character (its number in array)
    if a[c]<3 then write(c)   //if this is character's 1st or 2nd occurence, output it
  until eof                   //go back to reading if input is not read completely
end.
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.