परिचय

किसी दिए गए स्ट्रिंग उपयोग में अंग्रेजी वर्णमाला का कितना हिस्सा है? पिछला वाक्य 77% का उपयोग करता है। इसमें 20 अनोखे अक्षर (howmucftenglisapbdvr), और 20/26 (0.77 हैं।

चुनौती

इनपुट स्ट्रिंग के लिए, स्ट्रिंग में मौजूद अंग्रेजी वर्णमाला के अक्षरों का प्रतिशत लौटाएं।

इसका उत्तर प्रतिशत या दशमलव रूप में हो सकता है।
इनपुट स्ट्रिंग में ऊपरी और निचले मामले, साथ ही विराम चिह्न हो सकते हैं। हालाँकि आप मान सकते हैं कि उनके पास कोई विकृति विज्ञान या उच्चारण वर्ण नहीं हैं।

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

इनपुट

"Did you put your name in the Goblet of Fire, Harry?" he asked calmly.

कुछ मान्य आउटपुट

77%, 76.9, 0.7692

इनपुट:

The quick brown fox jumps over the lazy dog

सभी मान्य आउटपुट:

100%, 100, 1

के लिए अपेक्षित आउटपुट "@#$%^&*?!"और ""0 है।

code-golf

— टेलीपोर्टिंग बकरी
स्रोत

3

सुझाए गए परीक्षण मामलों: "@#$%^&*?!",""

— एडम

4

तो 77%और 76.9स्वीकार किया जाता है, है 77भी स्वीकार किए जाते हैं?

— ग्रेज़गोरज़ ओलेदज़की

प्रतिशत में दशमलव भाग भी हो सकते हैं ...

— जो राजा

2

@ शगुन ओपी के लिए अंतिम संपादित 16 घंटे पहले किया गया था, आपका जवाब 15 पर था और आपकी टिप्पणी 14 पर। मेरा मतलब है, आप सही हैं लेकिन ???

— विस्काह

6

यदि 20/26 को 0.7692, 0.769 या 0.77 के लिए रखा जा सकता है, तो क्या मैं इसे 0.8, 1 या 0 के लिए भी गोल कर सकता हूं? ;-)

— नूरलेफ़

18

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

lambda s:len({*s.upper()}-{*s.lower()})/26

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

हम अपरकेस और लोअरकेस अभ्यावेदन का (सेट) अंतर लेकर स्ट्रिंग से सभी गैर-अक्षर वर्णों को फ़िल्टर करते हैं। फिर, हम लंबाई लेते हैं और 26 से विभाजित करते हैं।

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

lambda s:sum(map(str.isalpha,{*s.lower()}))/26

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

अद्वितीय वर्णमाला (लोअरकेस) वर्णों की गणना करें, और 26 से विभाजित करें। पायथन 2 में इसे 3 और पात्रों की आवश्यकता होगी; बदलने के {*...}लिए दो set(...), और 26 को एक फ्लोट बनाने के लिए:, 26.फर्श विभाजन से बचने के लिए।

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

lambda s:sum('`'<c<'{'for c in{*s.lower()})/26

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

समान लंबाई, अनिवार्य रूप से पिछले एक के समान है, लेकिन "अंतर्निहित" स्ट्रिंग विधि के बिना।

— अरबो
स्रोत

दूसरा क्यों लौटता है 1.0और क्या नहीं 1? (मैं इसे विशेष रूप से अस्वीकार नहीं करना चाहता था, इसलिए यह विशिष्ट भाषाओं को नुकसान नहीं पहुंचाएगा, लेकिन मैं उत्सुक हूं)

— बकरी

10

एक एकल स्लैश के साथ @TeleportingGoat डिवीजन हमेशा पायथन 3 में फ़्लोट देता है, भले ही ऑपरेंड पूर्णांक हो। पूर्णांक विभाजन के लिए, आप उपयोग करेंगे //, लेकिन फिर यह हमेशा पूर्णांक विभाजन होगा, जो कि जाहिर है कि हम यहां नहीं चाहते हैं। यह समझ में आता है कि वे ऑपरेंड के विशिष्ट मूल्यों पर निर्भर डेटा प्रकार को आउटपुट नहीं करते थे, जिसका अर्थ है हमेशा तैरता है, भले ही यह पूरी संख्या हो।

— अर्बो

11

MATL , 8 बाइट्स

2Y2jkmYm

इसे MATL ऑनलाइन पर आज़माएं

व्याख्या

2Y2    % Predefined literal for 'abcdefghijklmnopqrstuvwxyz'
j      % Explicitly grab input as a string
k      % Convert to lower-case
m      % Check for membership of the alphabet characters in the string. 
       % Results in a 26-element array with a 1 where a given character in 
       % the alphabet string was present in the input and a 0 otherwise
Ym     % Compute the mean of this array to yield the percentage as a decimal
       % Implicitly display the result

— Suever
स्रोत

8

ऑक्टेव / MATLAB, 33 बाइट्स

@(s)mean(any(65:90==upper(s)',1))

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

व्याख्या

@(s)                               % Anonymous function with input s: row vector of chars
             65:90                 % Row vector with ASCII codes of uppercase letters
                    upper(s)       % Input converted to uppercase
                            '      % Transform into column vector
                  ==               % Equality test, element-wise with broadcast. Gives a
                                   % matrix containing true and false
         any(                ,1)   % Row vector containing true for columns that have at
                                   % least one entry with value true
    mean(                       )  % Mean

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

7

05AB1E , 8 7 6 बाइट्स

lASåÅA

-1 बाईट @ थैंक्स मेन्डो के लिए धन्यवाद ।

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

6 बाइट्स विकल्प @Grimy द्वारा प्रदान किया गया :

láÙg₂/

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

दोनों प्रोग्राम आउटपुट को दशमलव के रूप में।

स्पष्टीकरण:

l       # Convert the (implicit) input-string to lowercase
 AS     # Push the lowercase alphabet as character-list
   å    # Check for each if it's in the lowercase input-string
        # (1 if truthy; 0 if falsey)
    ÅA  # Get the arithmetic mean of this list
        # (and output the result implicitly)

l       # Convert the (implicit) input-string to lowercase
 á      # Only leave the letters in this lowercase string
  Ù     # Uniquify it
   g    # Get the amount of the unique lowercase letters by taking the length
    ₂/  # Divide this by 26
        # (and output the result implicitly)

— केविन क्रूज़सेन
स्रोत

@LuisMendo वैकल्पिक रूप से, láêg₂/एक 6- बायटर भी है।

— ग्रिम्मी

1

@LuisMendo धन्यवाद (और आप के रूप में अच्छी तरह से गंभीर )! :)

— केविन क्रूज़सेन

7

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

a=>a.ToUpper().Distinct().Count(x=>x>64&x<91)/26f

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

-6 बाइट्स innat3 के लिए धन्यवाद

— समय सीमा समाप्त डेटा
स्रोत

1

आप वर्णों के दशमलव मानों की तुलना करके 6 बाइट्स बचा सकते हैं 50 बाइट्स ( चरित्र कोड )

— Innat3

@ बदलकर Innat3 49 बाइट्स &&के लिए &।

— केविन क्रूज़सेन

@ केविनक्रूजसेन ~ 2 मिनट -1 बाइट क्रेडिट प्राप्त कर रहे हैं, पहले ही ऐसा कर चुके थे और संपादन कर रहे थे

— डाटा

@ExpiredData Np, यह एक स्पष्ट गोल्फ था। मुख्य रूप से इसे इनत :) में निर्देशित कर रहा था :)

— केविन क्रूज़सेन

6

एपीएल (Dyalog विस्तारित) , 10 बाइट्स ^SBCS

बेनामी tacit उपसर्ग समारोह। दशमलव अंश लौटाता है।

26÷⍨∘≢⎕A∩⌈

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

⌈ अपरकेस

⎕A∩ अपरकेस साथ चौराहे एक lphabet

≢ टैली की लंबाई

∘ फिर

26÷⍨ छब्बीस से भाग दो

— एडम
स्रोत

⌹∘≤⍨⎕A∊⌈

— ngn

@ng यह बहुत चालाक है, लेकिन पूरी तरह से अलग है। आगे बढ़ो और अपने आप को पोस्ट करें। यदि आप मुझे चाहते हैं तो मुझे स्पष्टीकरण डालकर खुशी होगी।

— अड्म

किया और समझाया

— ngn

6

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

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

*.uc.comb(/<:L>/).Set/26

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

— मजाक कर रहा है
स्रोत

1

+1। इसके अलावा, जबकि यह .lcएक "शुद्धता" के दृष्टिकोण से ठीक काम करता है (और भी काम करेगा), .fcबेहतर हो सकता है (विशेषकर यदि चुनौती गैर-अंग्रेजी अक्षर थे)

— user0721090601

6

बैश और ग्नू के बर्तन ( 81 78 68 60 42 बाइट्स)

bc -l<<<`grep -io [a-z]|sort -fu|wc -l`/26

-8 बाइट्स @ थॅस्टल को धन्यवाद

-18 बाइट्स नाहुएल के लिए धन्यवाद कुछ ट्रिक्स का उपयोग करके मैं नहीं जानता:

sort -fऔर grep -iमामले को अनदेखा करें
sort -u के लिए एक प्रतिस्थापन है | uniq

— ग्रेज़गोरोज़ ओलेदज़की
स्रोत

1

— बंजर

सही। चर एक और प्रयास के बाद एक अनुस्मारक है। धन्यवाद!

— ग्रेजेगॉर्ज ओलेडज़की

3

42 बाइट्स

— नहुएल फौलीउल

"Grep -io [az]" को "grep -o [Az]" तक छोटा नहीं किया जा सकता है?

— ग्नुडीफ

@Gnudiff ASCII की मानें, तो यह सब [\ _ _`] से भी मेल खाएगा।

— jnfnt

6

के (ओके) , 19 15 बाइट्स

समाधान:

1%26%+/26>?97!_

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

स्पष्टीकरण:

लोअरकेस में कनवर्ट करें इनपुट, modulo 97 ("az" ASCII में 97-122 है, modulo 97 0-25 देता है), अनूठे, योग परिणाम जो 26 से कम हैं, और 26 के प्रतिशत में परिवर्तित करें।

1%26%+/26>?97!_ / the solution
              _ / lowercase
           97!  / modulo (!) 97
          ?     / distinct
       26>      / is 26 greater than this?
     +/         / sum (+) over (/)
  26%           / 26 divided by ...
1%              / 1 divided by ...

टिप्पणियाँ:

-1 बाइट्स ngn, 1-%[;26]=> के लिए धन्यवाद1-1%26%
-3 बाइट्स ngn #(!26)^=> से प्रेरित है+/26>?

— streetster
स्रोत

1

मैं स्पष्टीकरण के लिए आगे देख रहा हूँ! मुझे कुछ पता नहीं है कि 97यहां क्या हो रहा है

— बकरी का

एक और 19 बाइट्स विकल्प

— स्ट्रीटस्टर

1

%[;26]->1%26%

— ngn

2

1%26%#?(26>)#97!_

— ngn

1

1%26%+/26>?97!_15 के लिए

— स्ट्रीट

6

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

($args|% *per|% t*y|sort|gu|?{$_-in65..90}).count/26

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

पहला प्रयास, अभी भी यादृच्छिक विचारों की कोशिश कर रहा है

EDIT: @Veskah ने बताया कि टूपर नंबर रेंज के कारण एक बाइट बचाता है, अतिरिक्त ()और एक स्थान को भी हटा देता है

विस्तार:
($args|% ToUpper|% ToCharArray|sort|get-unique|where{$_-in 65..90}).count/26

स्ट्रिंग को सभी ~~निचले~~ अपरकेस में बदल देता है, एक सरणी में फैलता है, तत्वों को छांटता है और अनूठे अक्षरों (ग्वार सॉर्ट किए गए इनपुट) का चयन करता है, केवल अस्सी मूल्य के अक्षरों को ~~97 से 122 (ए से जेड)~~ 65 से 90 (ए टू जेड) रखें कुल की गणना करें और दशमलव आउटपुट के लिए 26 से विभाजित करें

— sinusoid
स्रोत

अपरकेस एक बाइट बचाता है

— Veskah

1

ओह, बस आपने देखा कि आपके बाद एक अतिरिक्त जगह है।

— विस्काह

6

आर , 47 बाइट्स

function(x)mean(65:90%in%utf8ToInt(toupper(x)))

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

ऊपरी मामले में तब ASCII कोड-बिंदुओं में परिवर्तित होता है, और A: Z के समान 65:90 के मानों की जाँच करता है।

— रॉबिन राइडर
स्रोत

1

यह विफल रहता है जब इनपुट में उद्धरण होते हैं।

— सी। ब्रौन

1

@ C.Braun मेरे परीक्षणों में नहीं ... उदाहरण के लिए, TIO पर पहले परीक्षण मामले में उद्धरण शामिल हैं और सही परिणाम देता है। क्या आप एक उदाहरण दे सकते हैं?

— रॉबिन राइडर

1

मुझे समझ में नहीं आ रहा है कि आपने TIO पर हेडर भाग में क्या किया है, लेकिन आर इंटरप्रेटर में सिर्फ ऊपर दिए कोड को चलाने से काम नहीं चलता है। आप scanउद्धरण चिह्नों पर विभाजित नहीं होने के लिए पुनर्परिभाषित करते हैं, जैसे डिफ़ॉल्ट करता है?

— सी। ब्रौन

1

@ C.Braun समझ गया, धन्यवाद! मैंने इसे स्पष्ट रूप से एक फ़ंक्शन (3 बाइट्स की लागत पर) में बनाया है और मुझे लगता है कि यह अब ठीक है।

— रॉबिन राइडर

4

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

T`Llp`ll_
+`(.)(.*\1)
$2
.
100$*
^
13$*
.{26}

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

T`Llp`ll_

अक्षरों को कम करें और विराम चिह्न हटाएं।

+`(.)(.*\1)
$2

Deduplicate।

.
100$*

100 से गुणा करें।

^
13$*

13 जोड़ें।

.{26}

पूर्णांक 26 से विभाजित होता है और दशमलव में परिवर्तित होता है।

— नील
स्रोत

मुझे लगता है कि रेटिना आउटपुट के लिए प्रतिशत का उपयोग करने वाली एकमात्र भाषा है!

— बकरी

ओह, विभाजित करने से पहले एकतरफा 13 जोड़ने के साथ अच्छी चाल! मैंने ऐसा क्यों नहीं सोचा ..>>> यह मेरे जवाब को 44 बाइट्स बना देगा । मैं अभी भी अपने पिछले संस्करण को छोड़ दूँगा।

— केविन क्रूज़सेन

@TeleportingGoat शायद, क्योंकि रेटिना भी केवल एक ही भाषा है जो इस प्रकार पोस्ट की गई है जिसमें दशमलव विभाजन उपलब्ध नहीं है। केवल (unary) पूर्णांक-विभाजन संभव है।

— केविन क्रूज़सेन

4

APL (Dyalog Extended) , 8 बाइट्स

⌹∘≤⍨⎕A∊⌈

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

बहुत अदमा के जवाब पर आधारित है

⌈ अपरकेस

⎕A∊बूलियन (0 या 1) लंबाई के वेक्टर 26 जो दर्शाता है कि अंग्रेजी के कौन से अक्षर एक वर्णमाला में हैं

⌹∘≤⍨ अंकगणित का अर्थ है, तर्क का मैट्रिक्स विभाजन और समान लंबाई का एक सभी -1 वेक्टर

— NGN
स्रोत

3

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

Ｉ∕ＬΦβ№↧θι²⁶

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। आउटपुट एक दशमलव (या 1pangrams के लिए) के रूप में है। स्पष्टीकरण:

  Ｌ         Length of
    β       Lowercase alphabet
   Φ        Filtered on
     №      Count of
        ι   Current letter in
      ↧     Lowercased
       θ    Input
 ∕          Divided by
         ²⁶ Literal 26
Ｉ           Cast to string
            Implicitly printed

— नील
स्रोत

3

बैच, 197 बाइट्स

@set/ps=
@set s=%s:"=%
@set n=13
@for %%c in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)do @call set t="%%s:%%c=%%"&call:c
@cmd/cset/an/26
@exit/b
:c
@if not "%s%"==%t% set/an+=100

एसटीडीआईएन पर इनपुट लेता है और एक गोल प्रतिशत आउटपुट करता है। स्पष्टीकरण:

@set/ps=

स्ट्रिंग इनपुट करें।

@set s=%s:"=%

पट्टी उद्धरण, क्योंकि वे बैच में निपटने के लिए सिरदर्द हैं।

@set n=13

गोलाई उद्देश्यों के लिए आधे अक्षर से शुरू करें।

@for %%c in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)do @call set t="%%s:%%c=%%"&call:c

प्रत्येक अक्षर को स्ट्रिंग से बदले में हटाएं। बैच के पार्स करने के तरीके के कारण, कुछ भी बदल गया है या नहीं, यह जांचने के लिए सबरूटीन को आमंत्रित करें।

@cmd/cset/an/26

परिणाम की गणना प्रतिशत के रूप में करें।

@exit/b
:c

सबरूटीन की शुरुआत।

@if not "%s%"=="%t%" set/an+=100

यदि किसी अक्षर को हटाने से स्ट्रिंग बदल जाती है तो अक्षर गणना बढ़ाएं।

— नील
स्रोत

3

पेपे , 155 138 बाइट्स

rEeEeeeeeEREeEeEEeEeREERrEEEEErEEEeReeReRrEeeEeeeeerEEEEREEeRERrErEErerREEEEEeREEeeRrEreerererEEEEeeerERrEeeeREEEERREeeeEEeEerRrEEEEeereEE

इसे ऑनलाइन आज़माएं! आउटपुट दशमलव रूप में है।

स्पष्टीकरण:

rEeEeeeeeE REeEeEEeEe # Push 65 -> (r), 90 -> (R)
REE # Create loop labeled 90 // creates [65,66,...,89,90]
  RrEEEEE # Increment (R flag: preserve the number) in (r)
  rEEEe # ...then move the pointer to the last
Ree # Do this while (r) != 90

Re # Pop 90 -> (R)
RrEeeEeeeee rEEEE # Push 32 and go to first item -> (r)
REEe # Push input -> (R)
RE RrE # Push 0 on both stacks, (r) prepend 0
rEE # Create loop labeled 0 // makes input minus 32, so the
    # lowercase can be accepted, since of rEEEEeee (below)
  re # Pop 0 -> (r)
  rREEEEEe REEee # Push item of (R) minus 32, then go to next item 
  RrE # Push 0 -> (R)
ree # Do while (R) != 0

rere # Pop 0 & 32 -> (r)
rEEEEeee # Remove items from (r) that don't occur in (R)
         # Remove everything from (r) except the unique letters
rE # Push 0 -> (r)
RrEeee # Push reverse pointer pos -> (r)
REEEE # Move pointer to first position -> (R)
RREeeeEEeEe # Push 26 -> (R)
rRrEEEEee reEE # Divide it and output it

— u_ndefined
स्रोत

चूंकि पेपे केवल 4 कमांड की भाषा है, यह वास्तव में 34.5 बाइट्स की तरह है यदि आपने इसे 2 बिट प्रति आरई के रूप में एनकोड किया है?

— डेटा

3

के (ओके) , 19 बाइट्स

1%26%26-#(!26)^97!_

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

जे , 30 बाइट्स

26%~26-u:@(97+i.26)#@-.tolower

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

— गैलेन इवानोव
स्रोत

1

32!बहुत व्यापक है - यह अभिव्यक्ति के बाकी हिस्सों को कुछ विराम चिह्नों को अक्षरों के रूप में :

— मानता है

@ पहले मैंने विराम चिह्न के साथ परीक्षण नहीं किया था। मुझे याद दिलाने के लिये धन्यवाद।!

— गैलन इवानोव

3

रेटिना , 57 46 35 बाइट्स

.
$L
[^a-z]

D`.
.
100*
^
13*
_{26}

-11 बाइट्स प्रेरणा लेने से पहले @Neil की चाल को जोड़ने से पहले 13 जोड़ते हैं ।
एक और -11 बाइट्स सीधे @Neil की बदौलत ।
पूरे पूर्णांक तक सीमा (सही ढंग से)।

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

57 46 40 बाइट्स संस्करण जो दशमलव आउटपुट के साथ काम करता है:

.
$L
[^a-z]

D`.
.
1000*
C`_{26}
-1`\B
.

उसी -11 बाइट्स के साथ-साथ एक अतिरिक्त -6 बाइट्स @Neil के लिए धन्यवाद ।

$0.1538$ $\frac{4}{26}$ 15.315.4 $\lfloor{\frac{1000 × \text{unique_letters}}{26}\rfloor}$

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

स्पष्टीकरण:

सभी अक्षरों को लोअरकेस में बदलें:

.
$L

सभी गैर अक्षर निकालें:

[^a-z]

सभी पत्रों को विशिष्ट बनाएं:

D`.

1000 अंडरस्कोर के साथ हर अद्वितीय पत्र को बदलें:

.
1000*

26 आसन्न अंडरस्कोर की राशि की गणना इसमें फिट करें:

C`_{26}

सही जगह पर एक डॉट डालें:

-1`\B
.

— केविन क्रूज़सेन
स्रोत

1

यह .*सिर्फ .1 बाइट की बचत के लिए हो सकता है , लेकिन आप Dमैन्युअल रूप से करने के बजाय एडुप्लिकेट का उपयोग करके एक और 10 बाइट बचा सकते हैं !

— नील

@ नील आह, -बिल्टिन के बारे में नहीं जानता था D, धन्यवाद! और निश्चित नहीं है कि मैंने .*इसके बजाय क्यों इस्तेमाल किया ... दोनों संस्करणों में -11 बाइट्स के लिए धन्यवाद! :)

— केविन क्रूज़सेन

1

FYI करें मैं एक ही बाइट गिनती के लिए थोड़ा अलग दृष्टिकोण था: इसे ऑनलाइन आज़माएं!

— नील

1

दशमलव संस्करण के लिए मैंने पाया कि -1`\Bवांछित प्रविष्टि स्थिति से सीधे मेल खाता है।

— नील

@ नील फिर से धन्यवाद।

— केविन क्रूज़सेन

3

जावा 8, 62 59 बाइट्स

s->s.map(c->c&95).distinct().filter(c->c%91>64).count()/26.

-3 बाइट्स @ ओलिवियरग्रेगायर के लिए धन्यवाद ।

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

स्पष्टीकरण:

s->                     // Method with IntStream as parameter and double return-type
  s.map(c->c&95)        //  Convert all letters to uppercase
   .distinct()          //  Uniquify it
   .filter(c->c%91>64)  //  Only leave letters (unicode value range [65,90])
   .count()             //  Count the amount of unique letters left
    /26.                //  Divide it by 26.0

— केविन क्रूज़सेन
स्रोत

1

59 बाइट्स

— ओलिवियर ग्रेगोइरे

@ OlivierGrégoire धन्यवाद! मैं हमेशा किसी कारण के c&95साथ संयोजन में भूल जाता हूं c%91>64। मुझे लगता है कि आपने मेरे सामने कुछ समय पहले ही उस गोल्फ का सुझाव दिया है।

— केविन क्रूज़सेन

हां, मैंने पहले से ही उन लोगों का सुझाव दिया था, लेकिन यह ठीक है, कोई चिंता नहीं; ;-)

— ओलिवियर ग्रेजायर

रास्ता लंबा, लेकिन अधिक मजेदार: s->{int r=0,b=0;for(var c:s)if((c&95)%91>64&&b<(b|=1<<c))r++;return r/26.;}(75 बाइट्स)

— ओलिवियर ग्रेजायर

3

जूलिया 1.0 , 34 बाइट्स

s->sum('a':'z'.∈lowercase(s))/26

सदिश का उपयोग करता हैTo ऑपरेटर संस्करण का , एक से लेकर z तक की सीमा में सभी वर्णों के लिए स्ट्रिंग में जाँच की जाँच करता है। फिर परिणामी बिटआरे पर रकम जमा करता है और संभावित पत्रों की कुल संख्या से विभाजित करता है।

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

— TimD
स्रोत

आपका स्वागत है और महान पहले जवाब!

— mbomb007

2

सी, 96 बाइट्स

float f(char*s){int i=66,l[256]={};for(;*s;)l[1+*s++&~32]=1;for(;i<92;*l+=l[i++]);return*l/26.;}

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

— Steadybox
स्रोत

2

पर्ल 5 `-MList::Util=uniq -p` , 24 बाइट्स

$_=uniq(lc=~/[a-z]/g)/26

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

— Xcali
स्रोत

2

स्टैक्स , 9 बाइट्स

░║üy$}╙+C

इसे चलाएं और डीबग करें

— पुनरावर्ती
स्रोत

1

आप छोड़ने uऔर उपयोग करके अनपैक्ड संस्करण से एक बाइट ले सकते हैं |b, लेकिन पैकिंग के तहत बचत गायब हो जाती है। मेरा 8-बटर हो सकता है, लेकिन ऑनलाइन दुभाषिया अजीब और छोटी बात है।

— खुल्द्रेसैथ न’बैरीया

@ खुलद्रसेठना’बर्या: अच्छा लगा। मुझे लगता है कि बग शायद एक सरणी उत्परिवर्तन है। मैं अब उस व्यवहार को देख रहा हूँ। न्यूनतम रेप्रो पर काम करना ...

— पुनरावर्ती

यहाँ एक repro है समस्या है जो मुझे लगता है कि आप के साथ कर रहे हैं |b। यह कॉपी बनाने के बजाय अपने ऑपरेंड को गलत तरीके से म्यूट करता है। मैंने बग के लिए एक github मुद्दा बनाया है। github.com/tomtheisen/stax/issues/29 वर्कअराउंड के रूप में, |bपहली बार सही ढंग से काम करेगा। उसके बाद, आपको पृष्ठ को फिर से लोड करना पड़ सकता है। यदि आपको एक अलग बग मिला है, यदि आप एक प्रजनन प्रदान कर सकते हैं, तो मैं शायद इसे ठीक कर पाऊंगा।

— पुनरावर्ती

स्टेक्स 1.1.4, 8 बाइट्स। निर्देश: अनपैक, vप्रारंभ में डालें, इसके |bबाद डालेंVa , , चलाएं, पहले vनिकालें |b, हटाएं , फिर से निकालें । हां, यह वह बग है जो मुझे मिला।

— खुल्दरेसथ न'बर्या

@ खुल्द्रसेठना'बैरी: मैंने १.१.५ को रिलीज़ किया है, और मुझे विश्वास है कि यह बग अब तय हो गया है। यदि आप अभी भी परेशान हैं तो आप मुझे बता सकते हैं। धन्यवाद।

— पुनरावर्ती

2

जेली , 8 बाइट्स

ŒuØAe€Æm

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

व्याख्या

Œu       | Convert to upper case
  ØAe€   | Check whether each capital letter is present, returning a list of 26 0s and 1s
      Æm | Mean

— निक केनेडी
स्रोत

2

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

s=>~-s.match(/$|([a-z])(?!.*\1)/ig).length/26

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

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

s=>(s.match(/([a-z])(?!.*\1)/ig)||[]).length/26

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

— TSH
स्रोत

2

अजगर ३ , 51 49 बाइट्स

51 -> 49 बाइट्स, alexz02 के लिए धन्यवाद

lambda s:len({*filter(str.isalpha,s.lower())})/26

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

— ruohola
स्रोत

49 बाइट्सlambda s:len({*filter(str.isalpha,s.lower())})/26

— अलेक्सा 02

@ alexz02 धन्यवाद! :)

— रूहोला

1

जाप , 9 बाइट्स

;CoU Ê/26

कोशिश करो

;CoU Ê/26     :Implicit input of string U
;C            :Lowercase alphabet
  oU          :Remove the characters not included in U, case insensitive
     Ê        :Length
      /26     :Divide by 26

— झबरा
स्रोत

1

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

lambda i:len(set(o for o in i.lower()if o.isalpha()))/26.

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

ArBo से Python 3 के उत्तर से थोड़ा लंबा, लेकिन Python 2 में एक अलग दृष्टिकोण के रूप में वैसे भी पोस्ट किया गया है।

— ElPedro
स्रोत

1

रूबी `-n` , 38 34 बाइट्स

@Historcrat से -4 बाइट्स!

p (?A..?Z).count{|c|~/#{c}/i}/26.0

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

— मूल्य स्याही
स्रोत

@ हिस्टोक्रेट आप सही हैं

— वैल्यू इंक

1

सी, 95 बाइट्स

f(char*s){int a[256]={},z;while(*s)a[*s++|32]=1;for(z=97;z<'z';*a+=a[z++]);return(*a*100)/26;}

(नोट: गोल नीचे)

वैकल्पिक दशमलव-वापसी संस्करण (95 बाइट्स):

float f(char*s){int a[256]={},z;while(*s&&a[*s++|32]=1);for(z=97;z<'z';*a+=a[z++]);return*a/26.;}

यह @Steadybox के उत्तर से कुछ उधार लेता है।

— गुमनाम
स्रोत

1

स्वागत हे! अच्छा पहला जवाब। यदि आप अपने कोड या एक ungolfed संस्करण का संक्षिप्त विवरण प्रदान करते हैं तो यह आपके उत्तर को पढ़ने वाले लोगों के लिए मददगार हो सकता है। यह आपके रन करने योग्य कोड के साथ एक ऑनलाइन दुभाषिया को एक लिंक प्रदान करने के लिए भी सहायक हो सकता है (उदाहरण के लिए कुछ अन्य उत्तर देखें)। कई लोग TIO का उपयोग करते हैं, और यहाँ gcc दुभाषिया है

— mbomb007

वर्णमाला पूर्ण होने की दर

परिचय

चुनौती

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

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

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

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

MATL , 8 बाइट्स

ऑक्टेव / MATLAB, 33 बाइट्स

व्याख्या

05AB1E , 8 7 6 बाइट्स

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

एपीएल (Dyalog विस्तारित) , 10 बाइट्स SBCS

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

बैश और ग्नू के बर्तन ( 81 78 68 60 42 बाइट्स)

के (ओके) , 19 15 बाइट्स

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

आर , 47 बाइट्स

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

APL (Dyalog Extended) , 8 बाइट्स

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

बैच, 197 बाइट्स

पेपे , 155 138 बाइट्स

के (ओके) , 19 बाइट्स

जे , 30 बाइट्स

रेटिना , 57 46 35 बाइट्स

जावा 8, 62 59 बाइट्स

जूलिया 1.0 , 34 बाइट्स

सी, 96 बाइट्स

पर्ल 5 -MList::Util=uniq -p , 24 बाइट्स

स्टैक्स , 9 बाइट्स

जेली , 8 बाइट्स

व्याख्या

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

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

अजगर ३ , 51 49 बाइट्स

जाप , 9 बाइट्स

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

रूबी -n , 38 34 बाइट्स

सी, 95 बाइट्स

वैकल्पिक दशमलव-वापसी संस्करण (95 बाइट्स):

एपीएल (Dyalog विस्तारित) , 10 बाइट्स ^SBCS

पर्ल 5 `-MList::Util=uniq -p` , 24 बाइट्स

रूबी `-n` , 38 34 बाइट्स