10

आपका लक्ष्य इस तरह से एक इनपुट स्ट्रिंग लेना है:

"'Twas a dark and stormy night..."

और वर्णमाला में प्रत्येक वर्ण की स्थिति युक्त एक स्ट्रिंग लौटाएं, रिक्त स्थान द्वारा अलग किया गया और इस तरह से गैर-वर्णानुक्रमिक वर्णों को अनदेखा किया गया:

"20 23 1 19 1 4 1 18 11 1 14 4 19 20 15 18 13 25 14 9 7 8 20"

एक अतिरिक्त चुनौती के लिए, आप मूल स्ट्रिंग में किसी भी संख्यात्मक अक्षर को स्वयं के साथ बदल सकते हैं + 27. उदाहरण के लिए, "25"बन जाएगा "29, 32"। यह पूरी तरह से वैकल्पिक है।

आप 1 अनुक्रमण का उपयोग करना चाहिए ( 'a'==1, 'b'==2, आदि)

अतिरिक्त नियम:

आपको एक स्ट्रिंग लौटना चाहिए, न कि एक सरणी।
ट्रेलिंग व्हाट्सएप ठीक है।

विजेता के पास सबसे कम बाइट की गिनती है।

सौभाग्य!

code-golf string number

— O.c
स्रोत

निकटता से संबंधित

— Giuseppe

5

@ क्यों? आम सहमति यह है कि उत्तर किसी भी उचित प्रारूप में आउटपुट करने में सक्षम होना चाहिए, क्योंकि यह बहुत अधिक ब्लोट को जोड़ सकता है और इसे उन भाषाओं के साथ अनुचित बना सकता है जो छोटे तरीके से रिक्त स्थान से जुड़ सकते हैं।

— ओकेक्स

1

@ थियोसी आप दोनों की अनुमति क्यों नहीं देते?

— ओकेक्स

3

PPCG में आपका स्वागत है! यह समग्र रूप से एक अच्छी चुनौती है, लेकिन अगली बार जब आप एक चुनौती पोस्ट करते हैं, तो यहां कुछ बातों का ध्यान रखना चाहिए। 1) यह चुनौती बहुत आसान है। मुझे लगता है कि यह अधिक दिलचस्प होगा यदि वैकल्पिक भाग अनिवार्य था (ध्यान दें, अब उस हिस्से को न बदलें, यह बहुत देर हो चुकी है)। 2) आप कुछ मनमाने भागों के बारे में बहुत प्रतिबंधक हैं। एक सरणी की अनुमति क्यों नहीं? वर्णों की एक सरणी की तुलना में यह हमारा मानक है एक स्ट्रिंग है । मैं विचारों के लिए इस सूत्र के माध्यम से पढ़ने की सलाह दूंगा।

— जेम्स

2

भविष्य के नोट: 1 और 0 अनुक्रमण आमतौर पर एक और समान होते हैं, और दोनों को आमतौर पर अनुमति दी जाती है। साथ ही, आउटपुट फॉर्मेट में बाधा उत्पन्न होती है। यदि यह मानों की सूची है, तो भाषा को प्रारूप तय करने दें। चुनौती आउटपुट स्वरूपण के बारे में नहीं है और न ही यह सूचकांक को स्थानांतरित करने के बारे में है। इसलिए, यह एक बाधा नहीं होनी चाहिए जब आप भाषाओं को वे करने की अनुमति दे सकते हैं जो वे स्वाभाविक रूप से करते हैं और चुनौती के इरादे पर ध्यान केंद्रित करते हैं।

— मैजिक ऑक्टोपस Urn

5

05AB1E , (5?) 7 बाइट्स

^{सही दो बाइट्स आउटपुट स्वरूपण हैं}

áÇ32%ðý

मेरे जेली उत्तर का एक बंदरगाह , लेकिन O5AB1E वर्णमाला फ़िल्टरिंग के लिए अधिक कठिन है।

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

कैसे?

áÇ32%ðý - take input implicitly
á       - filter keep alphabetical characters
 Ç      - to ordinals
  32    - thirty-two
    %   - modulo (vectorises)
     ð  - push a space character
      ý - join

— जोनाथन एलन
स्रोत

चूंकि ओपी चाहता है कि इसे रिक्त स्थान द्वारा विभाजित किया जाए, एक अनुगामी ðýजोड़ा जा सकता है। लेकिन उत्तर आउटपुट सूचियों के आधा होने के बाद से मुझे लगता है कि इसे अभी के लिए छोड़ दें।

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

आह। मैंने इसे अपने उत्तरों में याद किया है ...

— जोनाथन एलन

5

जावा 8, 82 78 72 69 62 बाइट्स

s->{for(int c:s)System.out.print(c>64&~-c%32<26?c%32+" ":"");}

-13 बाइट्स @ OlivierGrégoire को धन्यवाद ।

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

स्पष्टीकरण:

s->                    // Method with character-array parameter and no return-type
  for(int c:s)         //  Loop over its characters as integers
    System.out.print(  //   Print:
     c>64&~-c%32<26?   //    If the current character is a letter:
      c%32+" "         //     Print the position in the alphabet with a trailing space
     :                 //    Else:
      "");}            //     Print nothing

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

1

s->s.chars().forEach(c->{if(c>64&~-c%32<26)System.out.print(c%32+" ");})(72bytes)।

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

1

@ OlivierGrégoire धन्यवाद! और -3 अधिक बाइट्स को एक टर्नरी में बदलकर यदि। :)

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

s->{for(int c:s)System.out.print(c>64&~-c%32<26?c%32+" ":"");}(62 बाइट्स) एक char[]के बजाय एक इनपुट के रूप में उपयोग करना String।

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

4

पायथन 3 , 62 60 49 बाइट्स

-5 बाइट्स जो किंग के लिए धन्यवाद ।
-8 बाइट्स pLOPeGG के लिए धन्यवाद ।

इन सुधारों के बाद, यह उत्तर अब जोनाथन एलन के उत्तर के समान है ।

print(*[ord(c)%32for c in input()if c.isalpha()])

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

— OVS
स्रोत

ओह, मुझे लगता है कि %32काम करता है

— जो किंग

4

आर , 55 50 बाइट्स

cat(utf8ToInt(gsub("[^A-Za-z]","",scan(,"")))%%32)

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

स्टड से इनपुट पढ़ता है, ~~अपरकेस में कनवर्ट करता है,~~ नॉन- ~~अपरकेस~~ अल्फाबेटिक लेटर्स को हटाता है , कोड पॉइंट्स में कनवर्ट करता है, 32 ~~तक 64~~ मॉड ~~को घटाता है~~ और स्टैडआउट को प्रिंट करता है, स्पेस से अलग करता है।

गोल्फ के लिए केविन क्रूज़सेन को धन्यवाद!

— ग्यूसेप
स्रोत

50 बाइट्स

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

@ केविनक्रूजसेन * फेसपालम * डुह

— गिउसेप्पे

मैंने दो टिप्पणियों (प्रश्नों) को प्रश्न में जोड़ा है - जवाब के आधार पर इसे नीचे 46 या यहां तक कि 39 वर्णों को गोल्फ करने का अवसर है।

— JayCe

1

आप 47 का उपयोग करके कर सकते हैं[^A-z]

— मिकी

4

एपीएल (डायलॉग यूनिकोड) , 24, 20, 14 13 बाइट्स

-4 बाइट Zacharý (और मिस्टर एक्सकोडर) के लिए धन्यवाद!

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

-1 बाइट धन्यवाद ngn करने के लिए!

⎕A⍳⎕A∩⍨≡819⌶⊢

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

स्पष्टीकरण:

        ≡819⌶⊢  - to uppercase
   ⎕A∩⍨         - intersect with the letters A-Z (args swapped to preserve the order)
   ⍳              - index in
⎕A               - the A-Z letters list

मेरा प्रारंभिक समाधान:

एपीएल (डायलॉग यूनिकोड) , 24 20 बाइट्स

{⍵/⍨27>⍵}⎕A⍳1(819⌶)⊢

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

स्पष्टीकरण:

             ⍳           indices of     
              1(819⌶)⊢  the right argument (⊢) changed to uppercase
          ⎕A            in the list of uppercase letters
{⍵/⍨     }              copy (filter) those items from the list of indeces
     27>⍵               which are smaller than 27 (all non A-Z chars will have index 27)

मुझ पर हंसो मत, मैं एपीएल के लिए नया हूं :)

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

1

यह वास्तव में एपीएल के लिए किसी के लिए उल्लेखनीय रूप से अच्छा है! आपको कोष्ठक की आवश्यकता नहीं है, उन्हें मान लिया गया है। भी, {1(819⌶)⍵}हो सकता है 1(819⌶)⊢। अन्यथा, अद्भुत काम! आशा है कि आप भविष्य में एपीएल का आनंद लेंगे!

— Zacharý

@ Zacharý धन्यवाद! मुझे आशा है कि (मुझे जे में कुछ ज्ञान है, मैं सरणी भाषाओं में बिल्कुल नया नहीं हूं)

— गैलेन इवानोव

1

जैसा कि ज़ाचारी ने उल्लेख किया है, कोष्ठक मान लिए गए हैं , इसलिए आपको उन्हें बाइट की संख्या में शामिल करने की आवश्यकता नहीं है, जिसके परिणामस्वरूप 20 बाइट्स हैं।

— श्री एक्सकोडर

1

@ जोनाह मैंने एक स्पष्टीकरण जोड़ा। आप सही कह रहे हैं, पूंजीकरण और वर्णमाला में ही जे। में अधिक लागत

— गैलेन इवानोव

1

अच्छी नौकरी! आप रचना से एक बाइट बचा सकते हैं 1करने के लिए 819⌶सीधे 27s को हटाने के द्वारा और पांच बचाने: 27~⍨⎕A⍳819⌶⍨∘1; या वर्णमाला के साथ चौराहे ले:⎕A⍳⎕A∩⍨819⌶⍨∘1

— Adám

3

पायथन 2 , (45?) 55 बाइट्स

^{11 बाइट्स को आउटपुट स्वरूपित करने के लिए जोड़ा गया है, जो कि पायथन 3 के साथ भी असंगत बनाता है)}

lambda s:' '.join(`ord(c)%32`for c in s if c.isalpha())

मेरे जैली जवाब का एक और बंदरगाह।

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

गैर-स्वरूपित संस्करण (पूर्णांकों की सूची लौटाते हुए):

lambda s:[ord(c)%32for c in s if c.isalpha()]

— जोनाथन एलन
स्रोत

1

ऐसा लगता है कि ओपी रिक्त स्थान द्वारा अलग किए गए स्ट्रिंग आउटपुट पर जोर दे रहा है, दुर्भाग्य से

— सोक

1

हां - मुझे याद है कि मेरे सभी जवाबों पर - एक साइट के मानदंडों के आदी हो जाते हैं!

— जोनाथन एलन

3

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

t=>t.match(/[a-z]/gi).map(i=>parseInt(i,36)-9).join` `

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

स्पष्टीकरण:

t =>                       // lambda function accepting a string as input
    t.match(/a-z/gi).      // returns all parts of string that match as an array 
        map(i=>            // map over that array with argument i 
            parseInt(i,36) // convert to base 36 
                - 9        // and subtract 9 from it
        ).                 // end map
        join` `            // convert to space separated string

11 बाइट्स ने @ क्वीन को धन्यवाद दिया

1 और बाइट्स @Neil की बदौलत

आप कुछ अतिरिक्त बाइट्स के लिए संख्यात्मक के लिए समर्थन जोड़ सकते हैं (@neil के लिए धन्यवाद)

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

t=>t.match(/[^_\W]/g).map(i=>(parseInt(i,36)+26)%36+1).join` `

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

— मुहम्मद सलमान
स्रोत

बदलकर -11 बाइट्स a-zकरने के लिए A-Za-zऔर i.toLowerCase().charCodeAt()-96करने के लिएi.charCodeAt()%32

— केविन Cruijssen

1

parseInt(i,36)-9एक और बाइट बचाता है।

— नील

.match(/[^_\W]/g).map(i=>(parseInt(i,36)+26)%36+1)आपको संख्याओं का समर्थन करने देता है, सुनिश्चित नहीं है कि यह सबसे अच्छा तरीका है।

— नील

2

जेली , (7?) 8 बाइट्स

^{राइट बाइट आउटपुट स्वरूपण है}

fØẠO%32K

एक पूर्ण कार्यक्रम पायथन प्रारूप में एक स्ट्रिंग को स्वीकार करता है जो परिणाम STDOUT को प्रिंट करता है

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

कैसे?

fØẠO%32K - Main Link: list of characters (created from the string input)
 ØẠ      - yield the alphabet = ['A','B',...,'Z','a','b',...,'z']
f        - filter keep (discard non alphabet characters)
   O     - ordinals          ('A':65, 'Z':90, 'a':97, 'z':122, etc.)
     32  - literal thirty-two
    %    - modulo            (65:1,   90':26,  97:1,  122:26,  etc.)
       K - join with spaces (makes a list of characters and integers)
         - implicit print

— जोनाथन एलन
स्रोत

2

जाप v2.0a0 `-S`, 12 10 बाइट्स

r\L ¬®c uH

कोशिश करो

व्याख्या

r              :Remove
 \L            :  Non-letter characters
    ¬          :Split to array
     ®         :Map
      c        :  Character code
        u      :  Modulo
         H     :  32
               :Implicitly join with spaces and output

— झबरा
स्रोत

2

x86 ओपकोड, 35 बाइट्स

0080h: AC 3C 24 75 04 88 45 FF C3 0C 20 2C 60 76 F1 D4
0090h: 0A 0D 30 30 86 E0 3C 30 74 01 AA 86 E0 AA B0 20
00a0h: AA EB DD                                       

f:  lodsb
    cmp al, '$'
    jnz @f
        mov [di-1], al
        ret
    @@:
    or al, 32
    sub al, 96
    jbe f
    aam
    or ax, 3030H
    xchg ah, al
    cmp al, 48
    jz @f
        stosb
    @@:
    xchg ah, al
    stosb
    mov al, 32
    stosb
    jmp f

परिणाम को मानते हुए कम से कम एक अक्षर होता है, और नहीं {|}~

40 बाइट्स, सभी ASCII वर्णों को अनुमति देते हैं

0080h: AC 3C 24 75 04 88 45 FF C3 0C 20 2C 60 76 F1 3C
0090h: 1A 77 ED D4 0A 0D 30 30 86 E0 3C 30 74 01 AA 86
00a0h: E0 AA B0 20 AA EB D9

— l4m2
स्रोत

"X86 ओपकोड" क्या है? क्या यह सिर्फ एक x86 मशीन कोड सबमिशन है?

— जैकब

@ जाकोब सच। मैं यहाँ ".COM" नहीं कहता, यह एक फ़ंक्शन है और ".COM" प्रारूप पर भरोसा न करें

— l4m2

हम्म। हाँ, मुझे लगता है कि यह माना जाता है कि मशीन कोड समाधानों को पूर्ण निष्पादन योग्य नहीं होना चाहिए। वास्तव में इसे "x86 मशीन कोड" लेबल करने के लिए बेहतर हो सकता है

— जैकब

2

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

üpÉÿ%}},√

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

-1 बाइट थैंक्स टू @recursive

स्पष्टीकरण:

v{VaIvm0-J Full program, unpacked, implicit input
v          Lowercase
 {    m    Map:
  VaI        Index in lowercase alphabet (0-based, -1 for not found)
     ^       Increment
       0-  Remove zeroes
         J Join by space
           Implicit output

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

É▌Xl»↔"

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

यह एक न्यूलाइन-अलग-अलग आउटपुट करता है। पैक नहीं किया गया: vmVaI^|c। इसी तरह, लेकिन नक्शे के साथ, जो स्पष्ट रूप से न्यूलाइन की अनुगामी के साथ आउटपुट करता है।

— wastl
स्रोत

हम्म। वहाँ एक समस्या पैकिंग प्रोग्राम है कि अंतरिक्ष में समाप्त हो प्रतीत होता है

— पुनरावर्ती

@recursive ओह, ध्यान नहीं दिया (आमतौर पर मैं लिंक की कोशिश करता हूं, लेकिन जाहिर है कि मैं इसे भूल गया था)। मैंने एक वर्कअराउंड जोड़ा।

— wastl

मैंने कभी इस बग पर ध्यान नहीं दिया। मैं इसे स्टेक्स की अगली रिलीज़ में ठीक करूँगा। मौजूदा पैक्ड प्रोग्राम अपरिवर्तित रहेंगे।

— पुनरावर्ती

यहाँ अपनी परेशानी के लिए एक 9 वापस है ।

— पुनरावर्ती

2

व्हॉट्सएप , 152 117 बाइट्स

-35 बाइट्स @Lynn को धन्यवाद ।

[N
S S N
_Create_Label_LOOP][S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][S N
S _Duplicate_input][S S S T S S S S S N
_Push_32][T S T T   _Modulo][S N
T   _Swap_top_two][S S S T  T   T   T   T   T   N
_Push_63][T S T S _Integer_divide][T    S S N
_Multiply][S N
S _Duplicate][S S S T   T   S T T   N
_Push_27][S T   S S T   N
_Copy_1st][S S S T  N
_Push_1][T  S S S _Add][T   S T S _Integer_divide][T    S S N
_Mulitply][N
T   S N
_If_0_Jump_to_Label_LOOP][T N
S T _Print_as_number][S S S T   S S S S S N
_Push_32_space][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

पत्र S(स्थान), T(टैब), और N(नई-पंक्ति) केवल हाइलाइटिंग के रूप में जोड़े गए।
[..._some_action]केवल स्पष्टीकरण के रूप में जोड़ा गया।

इसे ऑनलाइन आज़माएं (केवल कच्चे स्थानों, टैब और नई-लाइनों के साथ)।

छद्म कोड में स्पष्टीकरण:

Start LOOP:
  Character c = STDIN as character
  Integer n = (c modulo-32) * (c integer-divided by 63)
  Integer m = 27 integer-divided by (n + 1) * n;
  If(m == 0):
    Go to next iteration of LOOP
  Else:
    Print n as integer to STDOUT
    Print a space to STDOUT
    Go to next iteration of LOOP

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

1

मेरे पास इसे व्हॉट्सएप में लिखने का समय नहीं है, लेकिन शायद आप कुछ इस

— लिन

1

लगता है कि यह 117 बाइट्स है ! (* मैंने कोड में 64 से 63 को बदल दिया, क्योंकि यह व्हाट्सएप में प्रतिनिधित्व करने के बराबर लेकिन छोटा है :) :)

— लिन

@ लियन बुरा नहीं है, -35 बाइट वहीं है। धन्यवाद। :)

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

1

05AB1E , 8 बाइट्स

láÇ96-ðý

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

या, यदि हम एक सरणी लौटा सकते हैं:

05AB1E , 6 बाइट्स

láÇ96-

स्पष्टीकरण:

l         Lowercase
 á        Only letters
  Ç       Codepoints
   96-    Subtract 96.

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

या यदि आप संख्याओं को गिनना चाहते हैं:

05AB1E , 13 बाइट्स

lAžh«DŠÃSk>ðý

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

— Okx
स्रोत

1

05AB1E , 14 बाइट्स

साथ ही नंबर संभालता है

žKÃlvžKlÙyk>ðJ

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

— Emigna
स्रोत

1

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

≔⁺β⭆χιβＦ↧Ｓ¿№βι«Ｉ⊕⌕βι→

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

≔⁺β⭆χιβ

पूर्वनिर्धारित लोअरकेस अक्षरों में अंकों को परिचालित करें।

Ｆ↧Ｓ

लोअरकेस इनपुट पर लूप करें।

¿№βι«

यदि वर्तमान वर्ण एक अक्षर या अंक है,

Ｉ⊕⌕βι

अपने 1-अनुक्रमित सूचकांक को प्रिंट करें,

→

और अगले मूल्य के लिए एक स्थान छोड़ दें।

— नील
स्रोत

1

लाल , 93 बाइट्स

func[s][a: charset[#"a"-#"z"]parse lowercase s[any[copy c a(prin[-96 + to-char c""])| skip]]]

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

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

मुझे रेड के बारे में पर्याप्त जानकारी नहीं है, लेकिन #"a"-#"z"निचले और बड़े अक्षरों दोनों में बदला जा सकता है; और फिर lowercaseहटाया जा सकता है; और -96 + to-char cमोडुलो -32 हो सकता है? यकीन नहीं होता है कि भले ही बाइट्स इन रेड बचाता है, हालांकि।

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

@ केविन क्रूज़सेन धन्यवाद, मैं इसे बाद में आज़माऊंगा

— गैलेन इवानोव

@ केविनक्रूजसेन parseफंक्शन तब भी स्ट्रिंग्स इकट्ठा करता है जब मैच एक एकल चरित्र होता है, इसलिए मुझे हमेशा इसकी आवश्यकता होती है to-char। अपरकेस अक्षरों के लिए मुझे charset # "A" - # "Z" जोड़ना होगा, जो कि लाभ (यदि कोई हो) को नष्ट करने से खराब कर देता है lowercase।

— गैलेन इवानोव

हाँ, मैं थोड़े डर गया था की #"A"-#"Z"तुलना में ज्यादा लाभ नहीं हो सकता है lowercase, क्योंकि यह केवल 1 बाइट छोटा है। और मुझे पता था कि आपको इसकी आवश्यकता होगी to-char, बस यकीन नहीं था कि -96 + और मोडुलो -32 आकार में समान होगा।

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

1

पर्ल 5 , 47 बाइट्स

पार्सिंग अंकों की अतिरिक्त चुनौती के साथ:

print map{(ord(uc)-64)%43," "}<>=~/([A-Z\d])/gi

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

अंकों को नजरअंदाज करके 38 बाइट्स में कमी

print map{ord()%32," "}<>=~/([A-Z])/gi

— fockjef
स्रोत

1

PHP , 70 बाइट्स

for(;$c=$argv[1][$i++];)if(($c=ord($c))>64&($c%=32)>0&$c<27)echo"$c ";

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

-5 बाइट्स केविन की बदौलत

— user2803033
स्रोत

स्निपेट्स को यहां प्रस्तुतियाँ के रूप में अनुमति नहीं है, लेकिन आप इसे एक फ़ंक्शन या पूर्ण प्रोग्राम बना सकते हैं।

— निसा

क्षमा करें, अब यह इनपुट के रूप में पहले तर्क का उपयोग करता है

— user2803033

नमस्ते, PPCG में आपका स्वागत है! यदि आप पहले से ही नहीं हैं, तो PHP में गोल्फिंग के लिए सुझाव और <सभी भाषाओं में गोल्फिंग के लिए युक्तियाँ> के माध्यम से पढ़ने के लिए दिलचस्प हो सकता है। भागों के लिए आप गोल्फ कर सकते हैं: &&हो सकता है &, और ord(strtolower($c))-96हो सकता है ord($c)%32। इसके अलावा, मुझे लगता है कि आप ~पहले हटा सकते हैं $c, लेकिन मुझे यकीन नहीं है। PHP में बहुत अधिक प्रोग्राम नहीं किया गया है, और वास्तव में यह नहीं जानते कि ~यहाँ वैसे भी क्या उपयोग किया जाता है।

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

आपके सहयोग के लिए धन्यवाद। मॉड 32 एक अच्छा विचार है। यह कुछ बाइट्स बचाता है, लेकिन यह सुनिश्चित करने के लिए एक अतिरिक्त जांच की आवश्यकता है कि ऑर्ड ($ c) 64 से बड़ा है।

— user2803033

1

पर्ल 5 `-p` , 35 बाइट्स

$_="@{[map{(-64+ord uc)%43}/\w/g]}"

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

अंकों के बारे में अतिरिक्त भाग शामिल है।

— Xcali
स्रोत

1

/\w/शामिल हैं_

— ब्रैड गिल्बर्ट b2gills

मैं क्या खेल रहा था की तुलना में बहुत छोटा है! आप एक बाइट को बचा सकते हैं, और उल्लिखित बग @ BradGilbertb2gills का उपयोग करके ठीक कर सकते हैं -F/[^0-9\pL]|/: इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स

1

जाप 2.0 `-S`, 9 बाइट्स

f\l ®c %H

इसे ऑनलाइन चलाएं

स्पष्टीकरण:

f\l ®c %H                                    Input: "Hello..."
f            Match:
 \l             [A-Za-z]                     ["H","e","l","l","o"]
    ®        Map Z over the results:
     c         char-code of Z                [72,101,108,108,111]
       %H      mod 32                        [8,5,12,12,15]
-S           Join the chars with a space     8 5 12 12 15

— ओलिवर
स्रोत

1

पर्ल 6 , 32 बाइट्स (अल्फा), 41 बाइट्स (अल्फा + अंक)

{~(.uc.comb(/<:L>/)».ord X-64)}

इसे आज़माएं (32 बाइट्स अल्फा)

{~((.uc.comb(/<:L+:N>/)».ord X-64)X%43)}

इसे आज़माएं (41 बाइट्स अल्फा + अंक)

विस्तारित:

32 बाइट्स अल्फा

{  # bare block lambda with implicit parameter $_

  ~( # coerce to string (space separated)

      .uc                      # uppercase
      .comb( / <:L > / )\      # get letters as a sequence
      ».ord                    # get the ordinal of each
      X- 64                    # subtract 64 from each
  )
}

41 बाइट्स अल्फा + अंक

{  # bare block lambda with implicit parameter $_

  ~( # coerce to string (space separated)
    (
      .uc                      # uppercase
      .comb( / <:L + :N > / )\ # get letters and numbers as a sequence
      ».ord                    # get the ordinal of each
      X- 64                    # subtract 64 from each
    ) X% 43                    # modulus 43 for each
  )
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

यह भी गैर- ASCII वर्णों से मेल खाता है Э, लेकिन मैंने ओपी से स्पष्टीकरण मांगा है कि इनपुट ASCII- केवल है या नहीं।

— जो राजा

1

Tcl , 93 बाइट्स

puts [lmap c [split $argv ""] {if [string is alp $c] {expr ([scan $c %c]-64)%32} {continue}}]

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

— sergiol
स्रोत

1

PHP 108 105 बाइट्स

इसे ऑनलाइन आज़माएं (108 बाइट्स)

इसे ऑनलाइन ट्राई करें (105 बाइट्स)

-3 बाइट्स, @manassehkatz के लिए धन्यवाद (स्ट्रेटोलॉवर का स्तर बदलें और AZ को रेगेक्स से हटा दें)

कोड, किसी भी लूप से बचने की कोशिश की

<?=strtr(implode(" ",str_split(preg_replace(
"/[^a-z]/",'',strtolower($argv)))),array_flip(range("`",z)));

व्याख्या

$string = preg_replace("/[^a-z]/",'',strtolower($argv))  
//the string only contains letters

$string = implode(" ",str_split($string)); 
//the string has a space after every letter

$string = strtr($string, array_flip(range("`",z)));  
//replace every letter   acording to the array

$replacementArray = array_flip(range("`",z));
//this array contains the ansi characters from "`" to the "z"
//array_flip to change the keys with the values
//final array ["`"=>0,"a"=>1, "b"=>2...."z"=>26]

— फ्रांसिस्को हैन
स्रोत

चेतावनियों के बिना इसे चलाने के लिए, मुझे (a) $ argv को $ argv [1] और (b) "z" को अंतिम z के आसपास जोड़ना होगा। लेकिन उन परिवर्तनों के साथ या बिना (जो संस्करण निर्भर हो सकता है - I 5.6 का उपयोग कर रहा हूँ), आप एक स्तर में स्ट्रेटोलॉवर () को हटाकर 3 बाइट्स बचा सकते हैं strtolower($argv)और A-Zरेगेक्स से पूंजी हटा सकते हैं।

— manassehkatz-चलती 2 कोडिडैक्ट

Php 7 पर यह एक चेतावनी देता है, im अब उत्तर को संशोधित करता है। मुझे खेद है कि किसी भी वाई के पास जांच करने का समय नहीं था:

— फ्रांसिस्को हैन

1

@manassehkatz ने आपके सुझाव को लिया, और 3 बाइट्स को बचाया, बहुत बहुत धन्यवाद।

— फ्रांसिस्को हैन

नहीं होना चाहिए $argv[1]या $argnइसके बजाय $argv? join3 बाइट्स से छोटा है implode।

— टाइटस

0

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

print(*filter(int,['abcdefghijklmnopqrstuvwxyz'.find(c)+1for c in input().lower()]))

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

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

0

उपयोगकर्ता इनपुट के साथ पायथन 2, 110 बाइट्स 104 बाइट्स

a="abcdefghijklmnopqrstuvwxyz";print" ".join(str(a.index(l)+1)for l in list(input().lower())if l in a)

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

पायथन 2, 105 बाइट्स 104 बाइट्स 96 बाइट्स , जहां `t`पूर्वनिर्धारित है:

a="abcdefghijklmnopqrstuvwxyz";print" ".join(str(a.index(l)+1)for l in list(t.lower())if l in a)

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

चलो इसे और अधिक पठनीय संस्करण के साथ तोड़ते हैं:

alphabet = "abcdefghijklmnopqrstuvwxyz"
foo = [str(alphabet.index(letter) + 1) for letter in list(t.lower()) if letter in alphabet]
print " ".join(foo)

सबसे पहले, हम परिभाषित करते हैं alphabet, ठीक है, वर्णमाला।

अगला, हम सूची बोध का उपयोग करते हैं:

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

अंत में, हम इसे एक साथ जोड़ते हैं और इसे प्रिंट करते हैं।

संपादित करें:print बाइट्स को बचाने और इसे एक फ़ंक्शन के बाहर काम करने के लिए (और खो पोर्टेबिलिटी) में बदल दिया गया है

2 संपादित करें:input() पूर्वनिर्धारित चर के बजाय एक संस्करण जोड़ा गया

एडिट 3: सॉल्यूशंस 1 और 2 में 8 बाइट्स हटाकर जो किंग के लिए धन्यवाद

— O.c
स्रोत

आपको अपने कोड में 6 बाहरी स्थान मिले हैं

— जो किंग

@ जोकिंग मैंने पाया तीन (अर्धविराम के बाद, आसपास +), अन्य लोग कहां हैं?

— थियो सी

इससे पहले if, forऔर" "

— जो किंग

तुम भी निकाल सकते हैं []मेंjoin

— जो राजा

फिर से, PPCG में आपका स्वागत है! डिफ़ॉल्ट रूप से FYI (अर्थात यदि प्रश्न में स्पष्ट रूप से ओवरराइड नहीं किया गया है) उत्तर प्रस्तुतियाँ फ़ंक्शंस या फुल-प्रोग्राम (जैसे आपके 104 बाइट संस्करण) हो सकती हैं, लेकिन स्निपेट (आपके 96 बाइट संस्करण की तरह) नहीं। यहां आप एक संस्करण प्रस्तुत कर सकते हैं जो एक फ़ंक्शन बनाता है जो 100 बाइट्स के लिए स्ट्रिंग लौटाता है :)

— जोनाथन एलन

0

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

"$(([char[]]"$args".ToUpper()|%{$_-($_,64)[$_-in65..90]})-ne0)"

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

(लंबा लगता है ...)

इनपुट लेता है $args, इस .ToUpperमामले को परिवर्तित करता है, इसे एक char-रे के रूप में रखता है, जो एक for eachलूप में फीड करता है । लूप के अंदर, हम (ASCII int) मान से या तो खुद को या 64 घटाते हैं, इस पर आधारित है कि वर्तमान मूल्य -inसीमा 65है 90(यानी, यह ASCII पूंजी पत्र है)। उन मूल्यों को पाइपलाइन पर छोड़ दिया जाता है, और हम गैर-अक्षर मान को समाप्त करने के लिए एक -nओटी eयोग्यता का उपयोग करते हैं (क्योंकि वे सभी शून्य हैं)। उन संख्याओं को एक स्ट्रिंग में इनकैप्सुलेट किया जाता है क्योंकि एक सरणी का डिफ़ॉल्ट स्ट्रिंगकरण इसे अलग करने के लिए है, इसलिए हमें यह बहुत सस्ते में मिलता है। उस तार को पाइप लाइन पर छोड़ दिया गया है और आउटपुट निहित है।

— AdmBorkBork
स्रोत

0

MS-SQL, 133 बाइट्स

SELECT STRING_AGG(ASCII(substring(upper(s),number+1,1))-64,' ')FROM
spt_values,t WHERE type='P'AND substring(s,number+1,1)LIKE'[a-z]'

हमारे आईओ नियमों के अनुसार , इनपुट एक पूर्व मौजूदा तालिका के माध्यम से लिया जाता है टी varchar क्षेत्र के साथ रों ।

SQL 2017 या बाद के संस्करण की आवश्यकता है। masterडेटाबेस में भी चलाया जाना चाहिए , क्योंकि मैं एक सिस्टम टेबल का लाभ ले रहा हूं spt_values, जिसे (जब फ़िल्टर किया जाता है type='P') में 0 से 2047 तक की गिनती होती है।

मूल रूप से मैं इनपुट स्ट्रिंग के साथ एक नंबर टेबल का उपयोग कर रहा हूं SUBSTRING(), जो प्रत्येक व्यक्तिगत चरित्र के लिए एक अलग पंक्ति देता है। यह केवल अक्षरों का उपयोग करने के लिए फ़िल्टर किया जाता है LIKE'[a-z]', फिर हम उनका ASCII मान प्राप्त करते हैं और 64 घटाते हैं। इन नंबरों को एक स्ट्रिंग में वापस शामिल किया जाता है (नए SQL 2017) फ़ंक्शन का उपयोग करके STRING_AGG।

— BradC
स्रोत

0

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

jdfTmhxGr0

मुझे पूरा यकीन है कि यह थोड़ा-थोड़ा कर सकता है ... -2 बाइट्स अगर मैं एक सूची के रूप में आउटपुट कर सकता हूं, तो कुछ उत्तर लगते हैं, लेकिन यह कल्पना में नहीं है

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

— डेव
स्रोत

आप अंतिम d( jdfTmhGr0, 10 बाइट्स) को हटा सकते हैं ।

— मिस्टर एक्सकोडर

0

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

c;f(char*s){for(;*s;)(c=tolower(*s++)-96)>0&c<27&&printf("%d ",c);}

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

प्रत्येक वर्ण को लोअरकेस में परिवर्तित करता है, इसके कोड को -96 से बंद कर देता है और यदि यह 1-अनुक्रमित वर्णमाला की सीमा में आता है, तो ऑफसेट कोड प्रिंट करता है

— vazt
स्रोत

0

jq , 45 बाइट्स

[gsub("\\W";"")|explode[]%32|@text]|join(" ")

 gsub("\\W";"")                                # remove non-alpha characters
               |explode[]                      # get decimal values of characters
                         %32                   # get positions in alphabet
                            |@text             # convert back to string
[                                 ]|join(" ")  # join with a space

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

— नाओम फ़ेवियर
स्रोत

वर्णमाला स्थिति खोजक

05AB1E , (5?) 7 बाइट्स

कैसे?

जावा 8, 82 78 72 69 62 बाइट्स

पायथन 3 , 62 60 49 बाइट्स

आर , 55 50 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 24, 20, 14 13 बाइट्स

स्पष्टीकरण:

मेरा प्रारंभिक समाधान:

एपीएल (डायलॉग यूनिकोड) , 24 20 बाइट्स

स्पष्टीकरण:

पायथन 2 , (45?) 55 बाइट्स

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

स्पष्टीकरण:

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

जेली , (7?) 8 बाइट्स

कैसे?

जाप v2.0a0 -S, 12 10 बाइट्स

व्याख्या

x86 ओपकोड, 35 बाइट्स

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

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

व्हॉट्सएप , 152 117 बाइट्स

05AB1E , 8 बाइट्स

05AB1E , 6 बाइट्स

05AB1E , 13 बाइट्स

05AB1E , 14 बाइट्स

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

लाल , 93 बाइट्स

पर्ल 5 , 47 बाइट्स

PHP , 70 बाइट्स

पर्ल 5 -p , 35 बाइट्स

जाप 2.0 -S, 9 बाइट्स

स्पष्टीकरण:

पर्ल 6 , 32 बाइट्स (अल्फा), 41 बाइट्स (अल्फा + अंक)

विस्तारित:

32 बाइट्स अल्फा

41 बाइट्स अल्फा + अंक

Tcl , 93 बाइट्स

PHP 108 105 बाइट्स

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

उपयोगकर्ता इनपुट के साथ पायथन 2, 110 बाइट्स 104 बाइट्स

पायथन 2, 105 बाइट्स 104 बाइट्स 96 बाइट्स , जहां tपूर्वनिर्धारित है:

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

MS-SQL, 133 बाइट्स

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

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

jq , 45 बाइट्स

जाप v2.0a0 `-S`, 12 10 बाइट्स

पर्ल 5 `-p` , 35 बाइट्स

जाप 2.0 `-S`, 9 बाइट्स

पायथन 2, 105 बाइट्स 104 बाइट्स 96 बाइट्स , जहां `t`पूर्वनिर्धारित है: