एक स्ट्रिंग को देखते हुए, प्रत्येक अक्षर (केस असंवेदनशील) से शुरू होने वाले पहले शब्द को खोजें।

नमूना

Ferulas flourish in gorgeous gardens.इनपुट के रूप में उपयोग करना :

"Ferulas flourish in gorgeous gardens."
 ^^^^^^^          ^^ ^^^^^^^^
 |                |  |
 |                |  --> is the first word starting with `g`
 |                --> is the first word starting with `i`
 --> is the first word starting with `f`

फिर, इस नमूने के लिए आउटपुट एक एकल स्थान से जुड़ने वाले शब्दों से मेल खाना चाहिए:

"Ferulas in gorgeous"

चुनौती

इनपुट और आउटपुट दोनों एक स्ट्रिंग प्रतिनिधित्व, या आपकी भाषा में निकटतम विकल्प होना चाहिए।

कार्यक्रम या समारोह की अनुमति दी।

आप एक शब्द के कम से कम एक होने पर विचार कर सकते हैं: lowercase or uppercase letters, digits, underscore।

यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा जवाब।

एक अन्य नमूने:

input: "Take all first words for each letter... this is a test"
output: "Take all first words each letter is"

input: "Look ^_^ .... There are 3 little dogs :)"
output: "Look _ There are 3 dogs"

input: "...maybe some day 1 plus 2 plus 20 could result in 3"
output: "maybe some day 1 plus 2 could result in 3"

code-golf string

— हटा दिया
स्रोत

क्या ट्रेलिंग / स्टार्टिंग स्पेस की अनुमति है? <s> क्या मैं मान सकता हूं कि शब्द मूल स्ट्रिंग में एक स्थान से अलग हो गए हैं? </ s>

— Qwertiy

इसे उदाहरणों से समझा, इसलिए टिप्पणी में from है। ट्रिमिंग स्पेस के बारे में क्या?

— Qwertiy

17

रेटिना , 28 बाइट्स:

एम! मैं `घ \ b (\ डब्ल्यू) (? <! \ B \ 1। +) \ डब्ल्यू *
¶

M! - प्रत्येक कार्य का मिलान करें और सभी शब्दों को अलग-अलग करके प्रिंट करें।
i - मामले की अनदेखी करें।
\b(\w) - प्रत्येक शब्द के पहले अक्षर पर कब्जा
(?<!\b\1.+)- पत्र के मिलान के बाद, जांचें कि क्या पिछला शब्द उसी अक्षर से शुरू नहीं हुआ था। \1.+कम से कम दो अक्षर सुनिश्चित करता है, इसलिए हम वर्तमान शब्द को छोड़ रहे हैं।
\w*- बाकी के शब्द से मिलान करें।
उपरोक्त शब्द केवल शब्दों से मेल खाते हैं - अन्य सभी वर्ण हटा दिए गए हैं।
¶\n - रिक्त स्थान के साथ newlines बदलें।

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

— कोबी
स्रोत

9

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

मैं `घ \ b ((\ डब्ल्यू) \ डब्ल्यू *) \ ख (? <= \ b \ 2 \ डब्ल्यू। * \ बी +)

\ डब्ल्यू +
 
^ | $

एक ही \wचरित्र के साथ शुरू होने वाले शब्दों को हटाने के लिए बस एक एकल रेगेक्स का उपयोग करता है ( iविकल्प के साथ असंवेदनशील ), \Wएक ही स्थान पर चलाता है, फिर परिणाम से किसी भी अग्रणी / अनुगामी स्थान को हटा देता है।

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

संपादित करें: एक छोटे संस्करण का उपयोग करके @ कोबी का उत्तर देखेंM!`

— Sp3000
स्रोत

यह मुश्किल है, मुश्किल से मुझे यह हरा! मैं हालांकि तलाश के बारे में पता नहीं लगा सका।

— GamrCorps

3

मैंने एक और रेटिना उत्तर जोड़ा है - मुझे लगता है कि यह ठीक है अगर वे अलग-अलग हैं (मूल अवधारणा समान है, बिल्कुल)।

— कोबी

1

@ कोबी यह बहुत बेहतर है, इसलिए मुझे यह देखकर खुशी हुई है :) मुझे यह एहसास कराता है कि मुझे रेटिना के लाइन विकल्पों के बारे में और कितना सीखने की जरूरत है और क्या नहीं।

— Sp3000

क्या आप कुछ बाइट्स को बचाने के लिए ऐसा कर सकते हैं? i` \b((\w)\w*)\b(?<=\b\2\w*\b.+)(पहले एक जगह \b) क्या लाइनें बाद में अनावश्यक हैं?

— लीके नन

@ केनीलाऊ दुर्भाग्य से, मुझे नहीं लगता है कि काम करता है क्योंकि शब्द आवश्यक रूप से रिक्त स्थान से अलग नहीं होते हैं, उदाहरण के लिएa...a -> a

— Sp3000

9

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

s=>s.match(u=/\w+/g).filter(w=>u[n=parseInt(w[0],36)]?0:u[n]=1).join` `

2 बाइट्स @ edc65 की बदौलत सहेजे गए!

परीक्षा

var solution = s=>s.match(u=/\w+/g).filter(w=>u[n=parseInt(w[0],36)]?0:u[n]=1).join` `;
var testCases = [
  "Ferulas flourish in gorgeous gardens.",
  "Take all first words for each letter... this is a test",
  "Look ^_^ .... There are 3 little dogs :)",
  "...maybe some day 1 plus 2 plus 20 could result in 3"
];
document.write("<pre>"+testCases.map(t=>t+"\n"+solution(t)).join("\n\n")+"</pre>");

स्निपेट का विस्तार करें

— user81655
स्रोत

का उपयोग कर parseInt("_",36) = NaN? ईश - निंदा!

— Sp3000

1

मजेदार तथ्य यह है कि यह @ Sp3000

— edc65

U = regexp का उपयोग करना वास्तव में चतुर है। 2 बाइट्स बचाएंs=>s.match(u=/\w+/g).filter(w=>u[w=parseInt(w[0],36)]?0:u[w]=1).join' '

— edc65

@ edc65 धन्यवाद। यह वास्तव में काफी सुविधाजनक है कि एक एकल बेस -36 अंकों के लिए 37 संभावित आउटपुट हैं।

— user81655

7

पायथ, 23 बाइट्स

J:z"\w+"1jdxDJhM.grhk0J

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

J:z"\w+"1रेगेक्स का उपयोग करके इनपुट में सभी शब्दों को ढूंढता है \w+और उन्हें स्टोर करता है J।

.grhk0Jसमूहों को उनके निचले अक्षर के पहले अक्षर hMसे समूहित करता है, प्रत्येक समूह से पहला लेता है, xDJइन शब्दों को इनपुट स्ट्रिंग में उनके सूचकांक के आधार पर क्रमबद्ध करता है और jdउनके साथ रिक्त स्थान डालता है।

— Jakube
स्रोत

4

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

{.words.grep({!%.{.substr(0,1).lc}++})}

— Ven
स्रोत

1

42 बाइट्स जो शब्दों को मैच \w+और गोल्फ के substrभाग को ठीक करता है

— जो किंग

3

सी, 142 132 122 बाइट्स

10 बाइट्स हल्का करने के लिए धन्यवाद @tucuxi!

b[200],k;main(c){for(;~c;isalnum(c)|c==95?k&2?:(k|=!b[c|32]++?k&1?putchar(32):0,7:2),k&4?putchar(c):0:(k&=1))c=getchar();}

~~अंतिम आउटपुट शब्द के बाद एक अनुगामी स्थान प्रिंट करता है।~~

— mIllIbyte
स्रोत

1

आप c>47c<58isalnumisalpha

— tucuxi

3

MATL , 23 बाइट्स

'\w+'XXtck1Z)t!=XRa~)Zc

यह एक ही समय में अवांछित वर्णों को हटाने और विभाजित करने के लिए रेक्सक्सप का उपयोग करने के जकूबे के विचार को उधार लेता है ।

इनपुट एकल उद्धरण द्वारा संलग्न एक स्ट्रिंग है।

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

व्याख्या

'\w+'XX  % find words that match this regexp. Gives a cell array
t        % duplicate
c        % convert into 2D char array, right-padded with spaces
k        % make lowercase
1Z)      % get first column (starting letter of each word)
t!=      % duplicate, transpose, test for equality: all combinations  
XR       % set diagonal and below to 0
a~       % true for columns that contain all zeros       
)        % use as a logical index (filter) of words to keep from the original cell array
Zc       % join those words by spaces

— लुइस मेंडो
स्रोत

2

विम 57 कीस्ट्रोक्स

:s/[^a-zA-Z_ ]//g<cr>A <cr>ylwv$:s/\%V\c<c-v><c-r>"\h* //eg<c-v><cr>@q<esc>0"qDk@q

स्पष्टीकरण:

:s/[^a-zA-Z_ ]//g                                 #Remove all invalid chars.
A <cr>                                            #Enter insert mode, and enter 
                                                  #a space and a newline at the end
ylwv$:s/\\c%V<c-v><c-r>"\h* //eg<c-v><cr>@q<esc>  #Enter all of this text on the 
                                                  #next line

0                                                 #Go to the beginning of the line
"qD                                               #Delete this line into register
                                                  #"q"
k@q                                               #Run "q" as a macro  

#Macro
ylw                                               #Yank a single letter
   v$                                             #Visual selection to end of line
     :s/                                          #Substitute regex
       \%V\c                                      #Only apply to the selection and 
                                                  #ignore case
            <c-v><c-r>"                           #Enter the yanked letter
                       \h*                        #All "Head of word" chars
                                                  #And a space
                           //                     #Replace with an empty string
                             eg                   #Continue the macro if not found
                                                  #Apply to all matches
                               <c-v><cr>          #Enter a <CR> literal
                                        @q<esc>   #Recursively call the macro

मैं वास्तव में इस बात से विमुख हूं कि यह कब तक है। "अवैध" वर्ण (सब कुछ लेकिन a-z, A-Z, _और अंतरिक्ष) वास्तव में मुझे फेंक दिया बंद। मुझे यकीन है कि ऐसा करने का एक बेहतर तरीका है:

:s/[^a-zA-Z_ ]//g

चूंकि \hअंतरिक्ष के लिए यह सब अपेक्षा से मेल खाता है, लेकिन मैं यह अनुमान नहीं लगा सकता कि मेटाकार को एक सीमा में कैसे रखा जाए। अगर किसी के पास सुझाव हैं, तो मैं उन्हें सुनना पसंद करूंगा।

— DJMcMayhem
स्रोत

3

क्यों a-zA-Z_और क्या नहीं \w? अंक मान्य हैं

— edc65

2

जूलिया, 165 155 151 129 129 बाइट्स

g(s,d=[])=join(filter(i->i!=0,[(c=lcfirst(w)[1])∈d?0:(d=[d;c];w)for w=split(s,r"\W",keep=1<0)])," ")

यह एक फ़ंक्शन है जो एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग लौटाता है।

Ungolfed:

function g(s, d=[])
    # Split the string into an array on unwanted characters, then for
    # each word, if the first letter has been encountered, populate
    # this element of the array with 0, otherwise note the first letter
    # and use the word. This results in an array of words and zeros.
    x = [(c = lcfirst(w)[1]) ∈ d ? 0 : (d = [d; c]; w) for w = split(s, r"\W", keep=1<0)]

    # Remove the zeros, keeping only the words. Note that this works
    # even if the word is the string "0" since 0 != "0".
    z = filter(i -> i != 0, x)

    # Join into a string and return
    return join(z, " ")
end

Sp3000 की मदद से 53 बाइट्स बचाए!

— एलेक्स ए।
स्रोत

2

जेली, 32 31 बाइट्स

ØB;”_
e€¢¬œṗf€¢¹ÐfµZḢŒlQi@€$ịj⁶

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

— डेनिस
स्रोत

2

C # (LINQPAD) - 136 128 बाइट्स

var w=Util.ReadLine().Split(' ');string.Join(" ",w.Select(s=>w.First(f=>Regex.IsMatch(""+f[0],"(?i)"+s[0]))).Distinct()).Dump();

— jzm
स्रोत

2

05AB1E , 40 बाइट्स

कोड:

94L32+çJžj-DU-ð¡""Kvy¬Xsl©åï>iX®«Uy}\}ðý

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

स्पष्टीकरण:

हम पहले सभी वर्ण उत्पन्न करते हैं जिन्हें इनपुट स्ट्रिंग से हटा दिया जाना चाहिए 94L32+ç( यहां देखें )। हम इस स्ट्रिंग से जुड़ते हैं Jऔर हटाते हैं [a-zA-Z0-9_]जो žj में संग्रहीत है ( यहां देखें )। हम उन सभी वर्णों को हटा देते हैं जो पहले तार से दूसरे तार में हैं, जो हमें छोड़ देंगे:

!"#$%&'()*+,-./:;<=>?@[\]^`{|}~

यहाँ भी इसका परीक्षण किया जा सकता है । हम Dइसे बढ़ाते हैं और स्टोर के Xसाथ में स्टोर करते हैं U। फिर हम उन सभी वर्णों को हटा देते हैं जो इनपुट से इस स्ट्रिंग में हैं। हम तब व्हाट्सएप पर विभाजित करते हैं ð¡और सभी खाली स्ट्रिंग्स (उपयोग ""K) को हटाते हैं । अब हमारे पास यह है ।

यह इनपुट का स्वच्छ संस्करण है, जिसके साथ हम काम करेंगे। हम प्रत्येक तत्व का उपयोग करके नक्शा करते हैं v। यह yस्ट्रिंग चर के रूप में उपयोग करता है । हम स्ट्रिंग के पहले वर्ण का उपयोग करते हैं ¬और धक्का देते हैं X, जिसमें सभी निषिद्ध वर्णों के साथ एक स्ट्रिंग होती है ( !"#$%&'()*+,-./:;<=>?@[\]^`{|}~)। हम lजांचते हैं कि क्या पहले चरित्र का ऑवरकेस संस्करण, (जो ©रजिस्टर में भी विरोध किया जाएगा ), इस स्ट्रिंग का उपयोग कर रहा है å। इस भाग से आच्छादित:, ï>iयदि पहला अक्षर निषिद्ध वर्णों की स्ट्रिंग में मौजूद नहीं है ( X), हम इस पत्र को निषिद्ध वर्णों की सूची में जोड़ते हैं (साथ किया गया X®«U) और हम yस्टैक के शीर्ष पर धक्का देते हैं ।

अंत में, जब स्ट्रिंग्स को फ़िल्टर किया जाता है, तो हम स्टैक के साथ रिक्त स्थान से जुड़ते हैं ðý।

— अदनान
स्रोत

1

... स्पष्टीकरण? :-)

— लुइस मेंडो

@LuisMendo मुझे याद दिलाने के लिए धन्यवाद! संपन्न :)

— अदनान

2

पीएचपी

अधिकांश उत्तरों में रेगेक्स के उपयोग से प्रेरित होकर, मैंने मूल रूप से एक स्वच्छ बदलाव दिखाने के लिए रेगेक्स का उपयोग किए बिना ऐसा करने की कोशिश की, लेकिन इनपुट के रूप में स्वच्छ तारों के न होने के चिपके बिंदु ने उस विचार को बर्बाद कर दिया। उदास।

फ़ंक्शन आवरण के साथ, 89 बाइट्स

function f($s){foreach(preg_split('/\W/',$s)as$w)$c[lcfirst($w)[0]]++?:$v.=" $w";echo$v;}

फंक्शन रैपर के बिना ($ s पूर्व घोषित), 73 बाइट्स

foreach(preg_split('/\W/',$s)as$w)$c[lcfirst($w)[0]]++?:$v.=" $w";echo$v;

स्पष्टीकरण:

foreach(preg_split('/\W/',$s)as$w)$c[lcfirst($w)[0]]++?:$v.=" $w";echo$v;
        preg_split('/\w/',$s)                                             Break input on all non-word characters
foreach(                     as$w)                                        Loop through each 'word'
                                     lcfirst($w)[0]                       Take the first letter of the lowercase version of the word
                                  $c[              ]++?:                  Increment an array element with a key of that letter after checking if it's false-y (0)
                                                        $v.=" $w";        Add the word if the letter wasn't found (if the previous condition evaluated to false)
                                                                  echo$v; Print the new string to screen.

मेरा एकमात्र खेद यह है कि मुझे पत्र मामले की जाँच / परिवर्तित करने का तेज़ तरीका नहीं मिला।

— Xanderhall
स्रोत

2

अजगर, 103 बाइट्स

import re
lambda s,d=[]:[w for w in re.findall("\w+",s)if(d.append(w.lower()[0])or d[-1])not in d[:-1]]

— orlp
स्रोत

1

लुआ, 172 बाइट्स

यह लंबे समय तक समाप्त हो गया था जो मुझे चाहिए था ...

t={}(...):gsub("[%w_]+",function(w)b=nil for i=1,#t
do b=t[i]:sub(1,1):lower()==w:sub(1,1):lower()and 1 or b
end t[#t+1]=not b and w or nil end)print(table.concat(t," "))

Ungolfed

t={}                           -- initialise the accepted words list
(...):gsub("[%w_]+",function(w)-- iterate over each group of alphanumericals and underscores
  b=nil                        -- initialise b (boolean->do we have this letter or not)
  for i=1,#t                   -- iterate over t
  do
    b=t[i]:sub(1,1):lower()    -- compare the first char of t's i word
       ==w:sub(1,1):lower()    -- and the first char of the current word
           and 1               -- if they are equals, set b to 1
           or b                -- else, don't change it
  end
  t[#t+1]=not b and w or nil   -- insert w into t if b isn't set
end)

print(table.concat(t," "))     -- print the content of t separated by spaces

— Katenkyo
स्रोत

1

गंभीरता से, 43 बाइट्स

6╙¬▀'_+,;)-@s`;0@Eùk`M┬i;╗;lrZ`i@╜í=`M@░' j

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

रेगेक्स क्षमताओं की कमी ने इसे और अधिक कठिन बना दिया जितना कि यह आवश्यक था।

स्पष्टीकरण:

6╙¬▀'_+,;)-@s`;0@Eùk`M┬i;╗;lrZ`i@╜í=`M@░' j
6╙¬▀                                         push digits in base 62 (uppercase and lowercase letters and numbers)
    '_+                                      prepend underscore
       ,;)                                   push two copies of input, move one to bottom of stack
          -                                  get all characters in input that are not letters, numbers, or underscores
           @s                                split input on all occurrences of non-word characters
             `;0@Eùk`M                       for each word: push the first letter (lowercased)
                      ┬i                     transpose and flatten (TOS is list of first letters, then list of words)
                        ;╗                   push a copy of the first letters list to register 0
                          ;lrZ               zip the list of first letters with their positions in the list
                              `i@╜í=`M       for each first letter: push 1 if that is the first time the letter has been encountered (first index of the letter matches its own index) else 0
                                      @░     filter words (take words where corresponding element in the previous list is truthy)
                                        ' j  join on spaces

— मै जाऊं
स्रोत

1

रूबी 76 बाइट्स

s;f={};s.scan(/(([\w])[\w]*)/).map{|h,i|f[j=i.upcase]?nil:(f[j]=!p; h)}.compact.*' '

या विधि के साथ 88 बाइट्स परिभाषा

def m s;f={};(s.scan(/((\w)\w*)/).map{|h,i|f[j=i.upcase]?nil:(f[j]=1; h)}-[p]).*' ';end

Ungolfed और इकाई परीक्षण के साथ:

def m_long(s)
  #found  - Hash with already found initials
  f={}
  #h=hit, i=initial, j=i[0].downcase
  s.scan(/(([\w\d])[\w\d]*)/).map{|h,i| 
    f[j=i.upcase] ? nil : (f[j] = true; h)
  }.compact.join(' ')
end
#true == !p
#~ def m(s)
  #~ f={};s.scan(/(([\w\d])[\w\d]*)/).map{|h,i|f[j=i.upcase]?nil:(f[j]=!p; h)}.compact.join' '
#~ end
def m s;f={};s.scan(/(([\w\d])[\w\d]*)/).map{|h,i|f[j=i.upcase]?nil:(f[j]=!p; h)}.compact.join' ';end

#~ s = "Ferulas flourish in gorgeous gardens."
#~ p s.split

require 'minitest/autorun'
class FirstLetterTest < Minitest::Test
  def test_1
    assert_equal("Ferulas in gorgeous",m("Ferulas flourish in gorgeous gardens."))
    assert_equal("Ferulas in gorgeous",m_long("Ferulas flourish in gorgeous gardens."))
  end
  def test_2
    assert_equal("Take all first words each letter is",m("Take all first words for each letter... this is a test"))
    assert_equal("Take all first words each letter is",m_long("Take all first words for each letter... this is a test"))
  end
  def test_3
    assert_equal("Look _ There are 3 dogs",m("Look ^_^ .... There are 3 little dogs :)"))
    assert_equal("Look _ There are 3 dogs",m_long("Look ^_^ .... There are 3 little dogs :)"))
  end
  def test_4
    assert_equal("maybe some day 1 plus 2 could result in 3",m("...maybe some day 1 plus 2 plus 20 could result in 3"))
    assert_equal("maybe some day 1 plus 2 could result in 3",m_long("...maybe some day 1 plus 2 plus 20 could result in 3"))
  end
end

— नूट
स्रोत

रेगेक्स में, \wसंख्या वर्ण शामिल हैं, इसलिए [\w\d]इसके साथ प्रतिस्थापित किया जा सकता है \w। इसके अलावा, यदि nilआप कॉल करते समय मान किसी सरणी में हैं join' '(या अभी तक बेहतर है, *' 'तो एक शॉर्टहैंड है जिसे आप अधिक बाइट्स को बचाने के लिए उपयोग कर सकते हैं), वे गायब हो जाते हैं, इसलिए कॉल compactअनावश्यक है।

— वैल्यू इंक

@ केविनलाउ धन्यवाद। \w\dमेरे लिए शर्मनाक है। लेकिन अगर मैं हटाता हूं तो मुझे compactअतिरिक्त स्थान मिलते हैं, (देखें ['x',nil,'x']*'y' == 'xyyx')। या किसी को याद किया था?

— नूट

वूप्स, तुम सही हो। उस स्थिति में, (list-[p])बाइट्स को बचाता है list.compact। के /\w/बराबर भी है /[\w]/। अंत में, आप अपने जगह ले सकता है nilके साथ pऔर अपने !pसाथ 1(अपने हैश केवल उस में truthy मूल्यों की जरूरत है के बाद से)

— मूल्य इंक

धन्यवाद, मैं अपनी टिप्पणियों कहा, के प्रतिस्थापन nilके साथ pकाम नहीं करता। अगर मैं अपने कोड के अंदर इसका उपयोग करता हूं तो मुझे एक सिंटैक्स त्रुटि मिलती है। मुझे जैसे एनकैप्सुलेट करना है (p)- लेकिन फिर मेरे पास फिर से 3 कैरेक्टर हैं।

— नूट

टर्नरी को पलटें और फिर यह एक बाइट को बचाने के लिए काम करता है !f[j=i.upcase]?(f[j]=1;h):p:। इसके अलावा सिर्फ इसके बारे में सोचा, लेकिन स्ट्रिंग अनुक्रमण के कारण, कार्यों के पक्ष में उपयोग करना s.scan(/\w+/)और निकालना भी। ih[0]

— मूल्य इंक

1

grep और awk, 68 56 बाइट्स

लिपी:

echo `grep -o '\w*'|awk '!x[tolower(substr($0,1,1))]++'`

स्पष्टीकरण:

grep -o कानूनी शब्दों से मेल खाता है, प्रत्येक को अपनी लाइन पर प्रिंट करता है।
awkके साथ प्रत्येक पंक्ति का पहला अक्षर लेता है substr, इसे निचला बनाता है, और फिर उस कुंजी के साथ हैशटेबल प्रविष्टि बढ़ाता है। यदि मान वेतन वृद्धि से पहले परेशान था, तो लाइन मुद्रित होती है।
echo ... शब्दों में वापस लाइनों को बदल देता है

मैंने पहले बिना awkउपयोग , और uniq, के बिना एक समाधान बनाने की कोशिश कीsortgrepbash लेकिन सिर्फ कम गिर गया। संपादन में इतिहास।

कुछ सुधारों के लिए डेनिस को धन्यवाद।

— joeytwiddle
स्रोत

0

पायथन 3.5, 138 बाइट्स:

import re;lambda o,t=[]:''.join([y[0]for y in[(u+' ',t.append(u[0].lower()))for u in re.sub('\W+',' ',o).split()if u[0].lower()not in t]])

असल में, क्या हो रहा है ..

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

— आर। कप
स्रोत

0

PHP 120bytes

function a($s){foreach(preg_split('/\W/',$s)as$w)if(!$o[ucfirst($w[0])]){$o[ucfirst($w[0])]=$w;}return implode(" ",$o);}

यह चेतावनी का एक समूह उत्पन्न करता है लेकिन यह ठीक है।

— user52869
स्रोत

है functionआवश्यक?

— AL

0

जावास्क्रिप्ट ईएस 6, 108 107 वर्ण

107 वर्ण, परिणाम स्ट्रिंग को छंटनी की जाती है

r=s=>s.split``.reverse().join``
f=s=>r(r(s).replace(/\b\w*(\w)\b(?=.*\1\b)/gi,'')).replace(/\W+/g,' ').trim()

परीक्षा:

["Take all first words for each letter... this is a test",
"Look ^_^ .... There are 3 little dogs :)",
"...maybe some day 1 plus 2 plus 20 could result in 3"
].map(f) + '' == [
"Take all first words each letter is",
"Look _ There are 3 dogs",
"maybe some day 1 plus 2 could result in 3"
]

— Qwertiy
स्रोत

f= गिनती नहीं है ।

— क्वर्टी '’

0

Tcl , 150 बाइट्स

proc F {s D\ {}} {lmap w [split $s] {regsub -all \[^\\w] $w "" f
if {![dict e $D [set k [string tol [string in $f 0]]]]} {dict se D $k $f}}
dict v $D}

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

— sergiol
स्रोत

प्रत्येक अक्षर से शुरू होने वाला पहला शब्द खोजें

नमूना

चुनौती

एक अन्य नमूने:

रेटिना , 28 बाइट्स:

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

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

परीक्षा

पायथ, 23 बाइट्स

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

सी, 142 132 122 बाइट्स

MATL , 23 बाइट्स

व्याख्या

विम 57 कीस्ट्रोक्स

जूलिया, 165 155 151 129 129 बाइट्स

जेली, 32 31 बाइट्स

C # (LINQPAD) - 136 128 बाइट्स

05AB1E , 40 बाइट्स

पीएचपी

अजगर, 103 बाइट्स

लुआ, 172 बाइट्स

Ungolfed

गंभीरता से, 43 बाइट्स

रूबी 76 बाइट्स

या विधि के साथ 88 बाइट्स परिभाषा

grep और awk, 68 56 बाइट्स

पायथन 3.5, 138 बाइट्स:

जावास्क्रिप्ट ईएस 6, 108 107 वर्ण

107 वर्ण, परिणाम स्ट्रिंग को छंटनी की जाती है

Tcl , 150 बाइट्स