एक पीढ़ी उत्पन्न करें

19

यह एक संक्षिप्त विवरण बनाने के समान है , लेकिन कई महत्वपूर्ण अंतर हैं, जिसमें संक्षिप्तता लाने की विधि और लचीले आउटपुट सहित यह चुनौती शामिल है।

कार्य

एक स्ट्रिंग (वर्णों की सूची / लंबाई 1 तार की अनुमति दी जाती है) में केवल मुद्रण योग्य ASCII होता है, इनपुट में सभी बड़े अक्षरों का उत्पादन होता है जो या तो किसी स्थान या डैश से पहले होते हैं, या इनपुट में पहला वर्ण होता है। खाली स्ट्रिंग अपरिभाषित व्यवहार है।

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

आउटपुट के प्रारूप में हो सकता है "TEST", ["T","E","S","T"]आप के लिए, या जो कुछ भी किसी और काम करता है।

Self-contained Underwater Breathing Apparatus
SUBA

a Programming Language
PL

NATO Atlantic TREATY Organization
NATO

DEFCON 2
D

hello, world!


light-Emitting dioDe
E

What Does the Fox Say?
WDFS


3D mov-Ies
I

laugh-Out Lou-D
OLD

Best friends FOREVE-r
BF

--


<space>


--  --a -  - --


--  -- -  - -- A
A

Step-Hen@Gmail-Mail Mail.CoM m
SHMM

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

code-golf  string 
— स्टीफन
स्रोत
— स्टीफन
क्या हम स्ट्रिंग्स की सूची (पात्रों की सूची) के रूप में इनपुट ले सकते हैं?
— श्री एक्सकोडर
@ Mr.Xcoder हाँ।
— स्टीफन
क्या आप एक ऐसा परीक्षण मामला जोड़ सकते हैं जिसमें एक या एक से अधिक वर्णों के अलग-अलग अक्षर शामिल हों जो अक्षर, संख्या, स्थान या डैश नहीं हैं। एक ई-मेल पता, उदाहरण के लिए My-Name@Some-Domain.TLD:।
— Shaggy
1
@ शैगी ने जोड़ा, धन्यवाद।
— स्टीफन

जवाबों:

8

वी , 7 बाइट्स

ÍÕü¼À!õ

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

यहाँ बाइट गिनती साबित करने के लिए एक हेक्सडम्प है:

00000000: cdd5 fcbc c021 f5                        .....!.

स्पष्टीकरण:

Í       " Search and replace all occurrences on all lines:
        " (Search for)
 Õ      "   A non-uppercase letter [^A-Z]
  ü     "   OR
      õ "   An uppercase letter
    À!  "   Not preceded by...
   ¼    "   A word-boundary
        " (implicitly) And replace it with:
        "   Nothing

यह वी के अद्भुत रेगेक्स संपीड़न के लिए सभी धन्यवाद है ।

— DJMcMayhem
स्रोत
यह बहुत छोटा है 0.o
— स्टीफन
@StepHen क्यों धन्यवाद! मुझे लगता है कि यह इष्टतम के बहुत करीब है। :)
— DJMcMayhem
2
शब्द सीमा से आपका क्या तात्पर्य है? सवाल यह लगता है कि केवल स्थान और -अनुमति दी जाती है।
— नील
8

आर , 66 63 बाइट्स

function(s)(s=substr(strsplit(s,' |-')[[1]],1,1))[s%in%LETTERS]

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

-3 बाइट्स स्कारबी की बदौलत

एक अनाम फ़ंक्शन; एक सदिश के रूप में दिया जाता है, c("N","A","T","O")जो स्पष्ट रूप से मुद्रित होता है।

एक बार के लिए, यह R में बहुत बुरा नहीं है! पर विभाजित करता है , -या (space)उनमें से प्रत्येक का पहला तत्व लेता है, और फिर जो भी राजधानियां हैं (जो LETTERSकि बड़े अक्षरों के साथ एक आर बिलिन है) क्रम में है।

— ग्यूसेप
स्रोत
मुझे लगता है कि आप कुछ बाइट्स बचा सकते हैं:function(s)(s=substr(strsplit(s,' |-')[[1]],1,1))[s%in%LETTERS]
— स्कारबी
1
@Scarabee धन्यवाद। खेद है कि अद्यतन करने में 2 साल लग गए।
— ग्यूसेप
6

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

-3 बाइट्स लिन का धन्यवाद 

lambda s:[b for a,b in zip(' '+s,s)if'@'<b<'['>a in' -']

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

— छड़ी
स्रोत
मैंने आपकी चाल '@'<b<'[', बहुत अच्छा समाधान +1 उधार लिया
— श्री एक्सकोडर
तुलना जंजीर के बारे में मत भूलना! '@'<b<'['>a in' -'3 बाइट्स बचाता है।
— लिन
5

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

एक स्ट्रिंग इनपुट लेता है और संक्षिप्त वर्ण वाले स्ट्रिंग की एक सरणी आउटपुट करता है

x=>x.match(/\b[A-Z]/g)

व्याख्या

यह शब्द-सीमा के लिए केवल एक वैश्विक रेगेक्स मैच है जिसके बाद एक कैपिटल लेटर है।

— asgallant
स्रोत
4

दिल्लोग एपीएल, 29 23 बाइट्स

बोनस टेस्ट केस: एक प्रोग्रामिंग लैंग्वेज (एपीएल)।

'(?<=^| |-)[A-Z]'⎕S'&'⊢

चार वर्णों की एक सरणी लौटाता है (टीआईओ पर अलग-अलग जगह दिखाता है)।

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

पुरानी पोस्ट, 29 बाइट्स

{(⎕AV~⎕A)~⍨'(\w)\w+'⎕R'\1'⊢⍵}

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

कैसे?

'(\w)\w+'⎕R - वर्णमाला वर्णों के प्रत्येक समूह को बदलें

    '\1' - इसके पहले किरदार के साथ

~⍨ - हर चार को हटा दें

    (⎕AV~⎕A) - यह एक ASCII अपरकेस नहीं है

— Uriel
स्रोत
3

पायथन, 53 बाइट्स

import re
lambda s:re.findall("(?<=[ -])[A-Z]"," "+s)

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

अंतरिक्ष या पानी का छींटा के लिए एक साधारण नियमित अभिव्यक्ति। प्रारंभ से मेल खाने के बजाय, एक स्थान को प्राथमिकता दें।

— क्रिस एच
स्रोत
MrXCoder के परीक्षण सूट के साथ एक TIO लिंक में संपादित किया गया।
— स्टीफन
धन्यवाद @StepHen - आपने मुझे इसके लिए हराया और मुझे इस प्रयास से बचाया
— क्रिस एच।
50
— नकारात्मक सात
3

सी #, 84 78 बाइट्स

using System.Linq;s=>s.Where((c,i)=>c>64&c<91&(i>0?s[i-1]==32|s[i-1]==45:1>0))

सहेजे गए 6 बाइट @jkelm की बदौलत ।

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

पूर्ण / स्वरूपित संस्करण:

using System.Collections.Generic;
using System.Linq;

class P
{
    static void Main()
    {
        System.Func<string, IEnumerable<char>> f = s => s.Where((c, i) => c > 64 & c < 91 & (i > 0 ? s[i-1] == 32 | s[i-1] == 45: 1 > 0));

        System.Console.WriteLine(string.Concat(f("Self-contained Underwater Breathing Apparatus")));
        System.Console.WriteLine(string.Concat(f("a Programming Language")));
        System.Console.WriteLine(string.Concat(f("NATO Atlantic TREATY Organization")));
        System.Console.WriteLine(string.Concat(f("DEFCON 2")));
        System.Console.WriteLine(string.Concat(f("hello, world!")));
        System.Console.WriteLine(string.Concat(f("light-Emitting dioDe")));
        System.Console.WriteLine(string.Concat(f("What Does the Fox Say?")));
        System.Console.WriteLine(string.Concat(f("3D mov-Ies")));
        System.Console.WriteLine(string.Concat(f("laugh-Out Lou-D")));
        System.Console.WriteLine(string.Concat(f("Best friends FOREVE-r")));
        System.Console.WriteLine(string.Concat(f(" ")));
        System.Console.WriteLine(string.Concat(f("--  --a -  - --")));
        System.Console.WriteLine(string.Concat(f("--  -- -  - -- A")));

        System.Console.ReadLine();
    }
}
— TheLethalCoder
स्रोत
using System.Linqअगर आपको using System.Collections.Genericछूट है तो आपको बाइट की गिनती में शामिल क्यों होना है ? क्या कुछ आम सहमति है जिस पर usingभरोसा किया जा सकता है?
using System.Linq;मेरे जवाब में LinD कोड के लिए @DaveParsons की आवश्यकता है। हालाँकि, IEnumerbale<char>उत्तर का हिस्सा नहीं है और यह उस कोड का हिस्सा है जिसे using System.Collections.Generic;संकलित करने की आवश्यकता है।
— TheLethalCoder
समझ में आता है; स्पष्टीकरण के लिए धन्यवाद।
आप कुछ बाइट्स को बड़े अक्षरों में चेक के रूप में उपयोग करके बचा सकते हैं। c> 64 & c <91 आपको 6 बाइट्स नेट करना चाहिए।
— jkelm
@jkelm नाइस :) मैं हमेशा उस ट्रिक को भूल जाता हूँ!
— TheLethalCoder
3

जूलिया 0.6.0 (57 बाइट्स)

s=split(s,r" |-");for w∈s isupper(w[1])&&print(w[1])end

स्पष्टीकरण: यह मेरा पहला कोड-गोल्फ है। बहुत सीधा। शब्दों को विभाजित करें, प्रत्येक के ऊपरी अक्षर को प्रिंट करें।

शायद रेगेक्स का उपयोग करके बेहतर करना आसान है लेकिन मैं इसके लिए नया हूं

— Goysa
स्रोत
1
PPCG में आपका स्वागत है! मैं अभी वोटों से बाहर हूं, मैं इसे बाद में बढ़ा दूंगा।
— स्टीफन
2
@ स्टेपहेन मैं गेटचू कवर कर चुका हूं। : पी
— DJMcMayhem
2

सी # (.NET कोर) , 108 बाइट्स

n=>{var j="";n=' '+n;for(int i=0;++i<n.Length;)if(" -".IndexOf(n[i-1])>=0&n[i]>64&n[i]<91)j+=n[i];return j;}

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

— jkelm
स्रोत
जाँच नहीं की गई, लेकिन ifटर्नरी में बदलने से आप बाइट्स बचा सकते हैं। यह सूचकांक के 2बजाय शुरू होता है 1, बस इसे ठीक int i=1करने के int i=0लिए बदलें । इसके अलावा, मुझे नहीं लगता कि आप यहाँ बहुत कुछ कर सकते हैं।
— लीथलकोडर
एक टर्नरी यहाँ मदद नहीं करेगा, क्योंकि यह एक बयान के रूप में एक ही बाइट गिनती होगी। हालाँकि, आप सही हैं कि मुझे प्रारंभिक i मान
— jkelm
मैं पूरी तरह से निश्चित नहीं था, लेकिन वे आमतौर पर कम निकलते हैं इसलिए यह हमेशा जांच के लायक होता है।
— द लीथेलकोडर
2

जेली ,  11  10 बाइट्स

-1 बाइट की बदौलत एरिक द आउटगोलर ( Ḳस्थानों पर विभाजन> _ <)

⁾- yḲḢ€fØA

पात्रों की सूची लेने और लौटाने की एक विवादास्पद कड़ी।
एक पूर्ण कार्यक्रम के रूप में एक स्ट्रिंग को स्वीकार करता है और परिणाम प्रिंट करता है।

इसे ऑनलाइन आज़माएं! या एक परीक्षण सूट देखें।

कैसे?

⁾- yḲḢ€fØA - Link: list of characters, x       e.g. "Pro-Am Code-golf Association"
   y       - translate x with:
⁾-         -   literal list of characters ['-',' '] "Pro Am Code golf Association"
    Ḳ      - split at spaces               ["Pro","Am","Code","golf","Association"]
     Ḣ€    - head each (1st character of each)      "PACgA"
        ØA - yield uppercase alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
       f   - filter keep                            "PACA"
           - if running as a full program: implicit print
— जोनाथन एलन
स्रोत
उम्म, क्यों नहीं के Ḳबजाय का उपयोग करें ṣ⁶?
— आउटगॉल्फ जूल
हेह, क्योंकि मैं इसके बारे में भूल गया था। धन्यवाद!
— जोनाथन एलन
2

पर्ल ५ , 25 बाइट्स

24 बाइट्स कोड + 1 के लिए -n ।

grep -Pचर लंबाई का समर्थन करने वाली एनाउंडिंग पीछे-पीछे दिखती है, लेकिन पर्ल नहीं है :(।

print/(?:^| |-)([A-Z])/g

-1 बाइट @ दादा को धन्यवाद !

इसे ऑनलाइन आज़माएं! - -lएक ही बार में सभी परीक्षण चलाने के लिए शामिल है।

— डोम हेस्टिंग्स
स्रोत
आप बहुत बेहतर तरीके से ऐसा कर सकते हैं: इसे ऑनलाइन आज़माएं! ;-)
— दादा
@ दादा हा! बेशक ... मैं एटीएम से बाहर हूं लेकिन जब मैं वापस आऊंगा तो अपडेट करूंगा। धन्यवाद! मैं काफी निराश हूं कि मैं नहीं मिला s///या $_=नकार नहीं सकता print...
— डोम हेस्टिंग्स
हाँ, मैं इसे s///हल करने के लिए एक की तलाश में था, लेकिन यह स्पष्ट नहीं है ... मैं काम पर हूँ, शायद मैं इसे बाद में एक और कोशिश दूंगा!
— दादा
2

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

,Ṣ↻s₂ᶠ{h∈" -"&t.∧Ạụ∋}ˢ

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

(-2 बाइट्स @Fatalize के लिए धन्यवाद।)

,Ṣ↻                      % prepend a space to input
   s₂ᶠ                   % get all substrings of length 2 from that, to get prefix-character pairs
      {              }ˢ  % get the successful outputs from this predicate: 
       h∈" -"              % the prefix is - or space
               &t.∧        % then the character is the output of this predicate if:
                  Ạụ∋        % the alphabet uppercased contains the character
— sundar - मोनिका को बहाल करना
स्रोत
आप दो बाइट बचाने Ṣके " "लिए उपयोग कर सकते हैं
— जूल
2

जाप , १ ९ १६ 14 बाइट्स

-2 बाइट्स शैगी को धन्यवाद

f/^| |-)\A/ mÌ

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

— ओलिवर
स्रोत
आप v2 का उपयोग कर रहे के बाद से, मुझे लगता है कि आप बदल सकते हैं "(^| |-)%A"करने के लिए /^| |-)\A/एक बाइट को बचाने के लिए
— ETHproductions
1
mf\A-> mÌ2 बाइट्स को बचाने के लिए।
— झबरा
2

स्विफ्ट 5 , 110 बाइट्स

-5 Cœur के लिए धन्यवाद

import UIKit
func f(s:[String]){for i in zip(s,[" "]+s){if i.0.isUppercase()&&"- ".contains(i.1){print(i.0)}}}

विस्तृत विवरण

  • import Foundation- उस मॉड्यूल का आयात करता है Foundationजो zip()इस कोड का मुख्य टुकड़ा है।

  • func f(s:[String]){...}- एक पैरामीटर के साथ एक फ़ंक्शन बनाता है s, जो स्ट्रिंग्स की एक सूची है, इनपुट के पात्रों का प्रतिनिधित्व करता है।

  • for i in zip(s,[" "]+s){...}- मैं iइनपुट के ज़िप के माध्यम से और इनपुट को शुरुआत में जोड़े गए स्थान के साथ जोड़ता है , जो स्ट्रिंग में पिछले चरित्र को प्राप्त करने के लिए बहुत सहायक है।

  • if - जाँच करता है कि क्या:

    • i.0==i.0.uppercased() - वर्तमान चरित्र अपरकेस है,

    • &&"- ".contains(i.1) - और अगर पिछला पात्र एक स्पेस या डैश है।

  • यदि उपरोक्त शर्तें पूरी होती हैं, तो:

    • print(i.0) - चरित्र मुद्रित होता है, क्योंकि यह संक्षिप्त का हिस्सा है।
— श्री Xcoder
स्रोत
-5 के import UIKitबजाय के साथ import Foundation।
— C --ur
1

पायथन 3 , 73 70 बाइट्स

lambda n:[n[x]for x in range(len(n))if'@'<n[x]<'['and(' '+n)[x]in' -']

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

व्याख्या

  • lambda n:- स्ट्रिंग पैरामीटर के साथ एक अनाम लंबो-फ़ंक्शन बनाता है n।

  • n[x]- nसूचकांक में चरित्र हो जाता है x।

  • for x in range(len(n))- वैरिएबल 0का nनामकरण, की लंबाई से होता है x।

  • if - चेक:

    • '@'<n[x]<'[' - यदि चरित्र अपरकेस है,

    • and(' '+n)[x]in' -'- और अगर यह एक अंतरिक्ष या एक अंतरिक्ष द्वारा गठित स्ट्रिंग में एक पानी का छींटा से पहले है और n।

— मिस्टर एक्सकोडर
स्रोत
2
क्या यह बुरा है कि मैंने उसे पढ़ा i supper, और मुझे पता नहीं क्यों?
— TheLethalCoder
@ द लीथलकोडर इट्स .isupper(), मुझे नहीं पता कि आप क्या पढ़ते हैं: p
— श्री एक्सकोडर
1

बैश (grep), 29 28 बाइट्स

grep -oP'(?<=^| |-)[A-Z]' a

मेरे अजगर जवाब का एक बंदरगाह लेकिन क्योंकि pgrep चर लंबाई लुकबाइंड का समर्थन करता है यह काफी छोटा है (यहां तक ​​कि अजगर के सिर के लिए लेखांकन)। परीक्षण मामलों को नामक फ़ाइल में चिपका देंa , आउटपुट प्रति पंक्ति 1 वर्ण है।

-1 नील को धन्यवाद

— क्रिस एच
स्रोत
^| |-एक छोटी परीक्षा हो सकती है?
— नील
@ नील जो यहाँ काम करता है, धन्यवाद। इसे याद किया क्योंकि यह पायथन में काम नहीं करता है
— क्रिस एच।
1

RProgN 2 , 18 बाइट्स

`-` rû#ùr.'[a-z]'-

व्याख्या की

`-` rû#ùr.'[a-z]'-
`-`                     # Push "-" literal, and " " literal.
    r                   # replace, Replaces all "-"s with " "s.
     û                  # Split, defaultly by spaces.
      #ù                # Push the head function literally.
        r               # Replace each element of the split string by the head function, which gets each first character.
         .              # Concatenate, which collapses the stack back to a string.
          '[a-z]'-      # Push the string "[a-z]" literally, then remove it from the string underneith, giving us our output.

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

— Ataco
स्रोत
1

PHP, 62 बाइट्स

for(;~$c=$argn[$i++];$p=$c!="-"&$c!=" ")$c<A|$c>Z|$p?:print$c;

साथ पाइप के रूप में चलाएँ -nRऑनलाइन के या इसे आज़माएं ।

अन्य समाधान:

foreach(preg_split("#[ -]#",$argn)as$s)$s[0]>Z|$s<A?:print$s[0];  # 64 bytes
preg_match_all("#(?<=\s|-)[A-Z]#"," $argn",$m);echo join($m[0]);  # 64 bytes
preg_match_all("#(?<=\s|-)\p{Lu}#"," $argn",$m);echo join($m[0]); # 65 bytes
— टाइटस
स्रोत
1

सी ++, 168 बाइट्स

#include<string>
auto a=[](auto&s){auto r=s.substr(0,1);if(r[0]<65||r[0]>90)r="";for(int i=1;i<s.size();++i)if(s[i]>64&&s[i]<91&&(s[i-1]==32||s[i-1]==45))r+=s[i];s=r;};

पैरामीटर के माध्यम से किया गया आउटपुट

— HatsuPointerKun
स्रोत
यह पूरी तरह से दूर करने के लिए संभव है #include<string>और यह मान तर्क sएक है std::string?
— ज़ाचरी
1

लुआ , 79 75 बाइट्स

for i=1,#t do for i in(" "..t[i]):gmatch"[%-| ]%u"do print(i:sub(2))end end

कोशिश करो!

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

इनपुट को तालिका की संख्या के रूप में दिया गया है: स्ट्रिंग, संख्या में वृद्धि हर बार 1 से शुरू होती है और 1 से शुरू होती है।

स्पष्टीकरण:

यह प्रत्येक इनपुट स्ट्रिंग के एक गमच के माध्यम से छोरों के लिए है। गमच खोज निम्नानुसार है:

[% - | ] - समूह, एक - या एक स्थान के लिए खोज

% u - एक बड़े अक्षर के लिए खोजें

फिर प्रत्येक मैच के लिए, यह पूर्ववर्ती डैश या स्थान को घटा देता है

संपादित करें: 'a' की घोषणा को हटाकर और लूप इन फॉर लूप के अंदर इनपुट में स्थान को जोड़ने के साथ 4 बाइट्स, साथ ही उप इनपुट को 2,2 के बजाय केवल 2 में बदल दिया (जो समकक्ष परिणाम उत्पन्न करता है)

— AI221
स्रोत
1

Pyth , 12 बाइट्स

प्रारंभिक उत्तर के एक साल बाद बनाया गया।

rI#1hMcXQ\-d

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

Pyth , 21 बाइट्स

प्रारंभिक उत्तर।

:+dQ"(?<=[ -])[A-Z]"1

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

— श्री Xcoder
स्रोत
-| एक बाइट से कम है[ -]
— एटीएओ
@ कैटको यह काम नहीं लगता है
— श्री एक्सकोडर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.