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

आपको इस सटीक स्ट्रिंग को stdout में प्रिंट करना होगा:

A: Alfa
B: Bravo
C: Charlie
D: Delta
E: Echo
F: Foxtrot
G: Golf
H: Hotel
I: India
J: Juliet
K: Kilo
L: Lima
M: Mike
N: November
O: Oscar
P: Papa
Q: Quebec
R: Romeo
S: Sierra
T: Tango
U: Uniform
V: Victor
W: Whiskey
X: Xray
Y: Yankee
Z: Zulu

नियम:

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

code-golf kolmogorov-complexity alphabet

— sagiksp
स्रोत

1

सम्बंधित।

— मार्टिन एंडर

4

मैं इसे एक ठग के रूप में बंद कर रहा हूं क्योंकि इसमें कोई शोषणकारी संरचना नहीं है जो कस्टम संपीड़न योजनाओं को अंतर्निहित संपीड़न से बेहतर प्रदर्शन करने की अनुमति देगा, और लक्ष्य चुनौती अंतर्निहित संपीड़न के लिए हमारी वास्तविक मानक चुनौती है।

— मेगो

1

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

— मार्टिन एंडर

3

पहले वाला नहीं होना चाहिए A: Alpha?

— SeanC

3

@ सीन: विकिपीडिया के अनुसार (प्रश्न में लिंक देखें), नहीं। कि एटीएस, नाटो नहीं है। लेकिन फिर, यह होना चाहिए Juliett, इसके बजाय Julietऔर नहीं । X-rayXray

— टाइटस

18

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

i=65
for w in"lfa ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu".split():print'%c: %c'%(i,i)+w;i+=1

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

पिछला: (यह अच्छा था, लेकिन मुझे लगा कि सरल संस्करण को बाइट से छोटा किया जा सकता है)

w=''
i=65
for c in"lfAravOharliEeltAchOoxtroTolFoteLndiAulieTilOimAikEovembeRscaRapAuebeComeOierrAangOniforMictoRhiskeYraYankeEulU":
 w+=c.lower()
 if'_'>c:print'%c: %c'%(i,i)+w;w='';i+=1

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

12

जैली , 76 बाइट्स

“ṭṡl°ẠkWßġȮRẎ+wḋñȥạġ¢ƊḌ¬kạẠ¦WṡỊƒK⁹ç}⁶hm}Kñ£ɦ/lṇẊɠƓ}pƤ°⁸Ụ.g⁹Ġh9ṁ{f»ḲØAżj€⁾: Y

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

कैसे?

बहुत ज्यादा सिर्फ शब्दकोश मूल्यों और संपीड़न। के बीच कोड “और »सिर्फ एक संकुचित मूल्य कि स्ट्रिंग बनेगी है "Alfa Bravo Charlie Delta Echo Foxtrot Golf Hotel India Juliet Kilo Lima Mike November Oscar Papa Quebec Romeo Sierra Tango Uniform Victor Whiskey Xray Yankee Zulu"सभी शब्दों ऊपर देखकर भी (एकल अंतरिक्ष उपसर्गों के साथ के लिए छोड़कर, "Alfa") (के लिए छोड़कर जेली के शब्दकोश में " Xray"जो शब्दकोश में नहीं है, इसलिए प्रत्यक्ष स्ट्रिंग मान " X"और शब्दकोश "ray"इसके बजाय प्रविष्टि का उपयोग किया जाता है)।

बाकी कोड बाकी काम करता है:

“...»ḲØAżj€⁾: Y - Main link: no arguments
“...»           - the string described above (really a list of characters)
     Ḳ          - split at spaces
      ØA        - alphabet yield - ['A','B','C', ...,'X','Y','Z']
        ż       - zip - makes a list of lists [['A'],['A','l','f','a']],[['B'],['B','r','a','v','o']], ...]
         j€     - join each with
           ⁾:   - the string ": "
              Y - join with line feeds
                - implicit print

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

(नोट: मैंने कभी भी जेली में प्रोग्राम नहीं किया।) जब मैं आपका कोड देखता हूं तो मैं दो चीजों को सोच रहा होता हूं: 1. आप वर्तमान में वर्णमाला पर लूप करते हैं और उन्हें शब्दों के साथ जोड़ते हैं। क्या जेली में एक स्ट्रिंग के पहले चरित्र को प्राप्त करना संभव है, इसलिए आप वर्णमाला के बजाय शब्दों पर लूप करते हैं, और उन्हें first_letter_of_word + ":" + शब्द के साथ जोड़ते हैं? और 2. आप रिक्त स्थान सहित सभी शब्दों को पुनः प्राप्त करते हैं और फिर अंतरिक्ष द्वारा विभाजित होते हैं। क्या प्रमुख पूंजी पत्रों द्वारा समावेशी-विभाजन संभव है? पता नहीं अगर ये स्थान अपने संपीड़ित रूप में अतिरिक्त बाइट्स देते हैं या नहीं, और अगर वे 2 पर मेरे विवरण के साथ कम हो सकते हैं

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

1

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

— जोनाथन एलन

2

शब्दकोश में प्रमुख स्थान नहीं हैं। हालाँकि, जब एक पंक्ति में कई शब्दों को विघटित किया जाता है, तो डिफ़ॉल्ट उन्हें रिक्त स्थान द्वारा अलग करना है; पहले शब्द में एक अग्रणी स्थान नहीं होगा, लेकिन निम्नलिखित सभी शब्द होंगे।

— डेनिस

11

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

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।


AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu
[A-Z]
¶$&: $&
G`.

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

— मार्टिन एंडर
स्रोत

11

05AB1E , 102 98 बाइट्स

बच निकले 4 बाइट्स के लिए धन्यवाद एग्री द आउटग्राफर

”AlfaÐ†vo¼¯¤œ®È¨›trotŠˆƒ‹Š™ÈŸt Kilo´àma—……ÍÐ—Žêpa¼°«Äoµ†Çâgo¸šÉµ Whiskey Xrayµ‹nkeeâ¸lu”#vy¬„: «ì,

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

व्याख्या

05AB1E के शब्दकोश में शब्दों के लिए शब्दकोश संपीड़न का उपयोग करता है।
अन्य शब्दों के लिए जब भी संभव हो आंशिक शब्दकोश संपीड़न का उपयोग करता है।
सादा पाठ शब्द जहाँ न तो संभव है।

#          # split on spaces
 v         # for each word
  y        # push the word
   ¬       # get the first letter of the word
    „:     # push the string ": "
       «   # append this to the letter
        ì  # prepend the result to the word
         , # print with newline

— Emigna
स्रोत

2

बजाय इस संकुचित स्ट्रिंग का उपयोग 98 के लिए नीचे जाओ:

”AlfaÐ†vo¼¯¤œ®È¨›trotŠˆƒ‹Š™ÈŸt Kilo´àma—……ÍÐ—Žêpa¼°«Äoµ†Çâgo¸šÉµ Whiskey Xrayµ‹nkeeâ¸lu”

।

— आउटगोल्फर

@EriktheOutgolfer: धन्यवाद! मुझे यकीन था कि मैंने डिक्शनरी में देखा था paऔर liमैंने उन्हें याद किया होगा। मैंने विचार नहीं किया yaऔर zuयद्यपि शब्दों के रूप में :)

— Emigna

6

रूबी, 169 अक्षर

(भारी रूप से जोनाथन एलन के 2 समाधान पर आधारित है । यदि आप विचार पसंद करते हैं, तो कृपया मूल उत्तर को बढ़ाएं।)

i=?@
"LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu".scan(/.[a-z]+/){|w|puts i.succ!+": "+i+w.downcase}

नमूना रन:

bash-4.3$ ruby -e 'i=?@;"LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu".scan(/.[a-z]+/){|w|puts i.succ!+": "+i+w.downcase}' | head
A: Alfa
B: Bravo
C: Charlie
D: Delta
E: Echo
F: Foxtrot
G: Golf
H: Hotel
I: India
J: Juliet

— आदमी काम पर है
स्रोत

6

जावा 7, 242 225 222 217 बाइट्स

void d(){char c=65;for(String s:"lpha ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu".split(" "))System.out.println(c+": "+c+++s);}

स्पष्टीकरण:

void d(){                          // Method
  char c = 65;                     //  Starting character 'A'
  for(String s : "lpha ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu"
      .split(" "))                 //  Loop over the word-parts
    System.out.println(            //   Print line with:
      c                            //    The current character
      + ": "                       //    + ": "
      + c++ + s                    //    + the current character + word-part (and raise the character afterwards)
    );                             //   End of print line
                                   //  End of loop (implicit / single-line body)
}                                  // End of method

टेस्ट कोड:

इसे यहाँ आज़माएँ।

class M{
  static void d(){char c=65;for(String s:"lpha ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu".split(" "))System.out.println(c+": "+c+++s);}

  public static void main(String[] a){
    d();
  }
}

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

जावा 5 और उसके बाद के सभी संस्करणों के साथ काम करना चाहिए।

— होल्गर

5

ऑक्टेव, 215 210 209 बाइट्स

~~लुइस मेंडो की बदौलत 5 बाइट्स बचाए।~~ मैंने लुइस मेंडो की बदौलत 4 बाइट्स बचाए, लेकिन दृष्टिकोण बदलने से मुझे एक और बचाने में मदद मिली

fprintf('%s: %s%s\n',[k=num2cell(65:90);k;regexp('lfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu','[A-Z]','split')]{:})

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

~~यदि मुझे रिक्त स्थान से छुटकारा मिल गया है, तो~~ मैं ~~25 बाइट बचाऊंगा, लेकिन फिर~~ मुझे एक regex का उपयोग करना होगा। रेगेक्स खुद में काफी कुछ बाइट्स होगा, और यह सभी शब्दों के कैपिटल लेटर को भी हटा देगा, मुझे शब्दों के साथ छोड़ देगा lfa, ravoआदि इसलिए मुझे अग्रणी पात्रों के साथ नए तार को जोड़ना होगा। यह सब बाइट्स का खर्च है।

पुरानी व्याख्या:

fprintf('%s: %s\n',      % Print a string with the format "str: str\n"
num2cell(65:90)          % Create a cell array with the numbers 65 - 90, one in each cell
strsplit('Alfa ...       % Split the string on the default delimiter: space
[num2cell();strsplit()]  % Concatenate cell arrays, leaving us with
                         % {'A',    'B'
                         %  'Alfa', 'Bravo'}
[...]{:}                 % Convert the cell array to a comma-delimited vector
                         % 'A', 'Alfa', 'B', 'Bravo' ...

— स्टीवी ग्रिफिन
स्रोत

धन्यवाद! यह थोड़ा गड़बड़ था! , और तीन बाइट्स लंबे समय तक ...

— स्टिव ग्रिफ़िन

आह, हाँ, 'split'अब यहाँ होगा

— लुइस मेंडू

'split'कम था: 209 :)

— स्टिव ग्रिफ़िन

समझा! बहुत बढ़िया!

— लुइस मेन्डो

आप रिक्त स्थान पर विभाजित कर सकते हैं और 5 और बाइट्स बचा

— लुइस मेंडो

5

PHP, 202 227 196 187 बाइट्स

9 बाइट बचाने के लिए डेवी मॉर्गन को धन्यवाद

echo preg_replace('/([A-Z])[a-z]+/',"$1: $0\n",AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu);

https://repl.it/GMkH/1

पुराने संस्करण

31 बाइट्स बचाने के लिए मैनटवर्क और इन्सर्टसर्नमेयर के लिए धन्यवाद !

foreach(preg_split('/\B(?=[A-Z])/',AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu)as$k)echo"$k[0]: $k\n";

https://eval.in/749541

पिछले संस्करण के साथ आउटपुट गलत नहीं होने के लिए यह सम्मिलित करने के लिए धन्यवाद ।

$a=preg_split('/(?=[A-Z])/',AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu,-1,PREG_SPLIT_NO_EMPTY);foreach($a as $k)echo "$k[0]: $k\n";

https://repl.it/GKS8/3

$a=preg_split('/(?=[A-Z])/',AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu);foreach($a as $k)echo"$k[0]: $k\n";

https://repl.it/GKS8/2

— ʰᵈˑ
स्रोत

चर क्यों $a? बस पूरे preg_split()कॉल को foreachपैरामीटर में स्थानांतरित करें । फिर आसपास का कोई भी स्थान asअब आवश्यक नहीं होगा।

— मैनटवर्क

निरंतर के बजाय PREG_SPLIT_NO_EMPTY, बेहतर इसके मूल्य का उपयोग करें 1:। लेकिन व्यक्तिगत रूप से मैं इसके बजाय नियमित अभिव्यक्ति को ट्विक करूंगा /\B(?=[A-Z])/:।

— मैनटवर्क

1

धन्यवाद @insertusernamehere मैं कि संपादित अब बनाती हूँ :Dफिर भी codegolfing करने के लिए इस्तेमाल हो रही है

— ʰᵈˑ

इसके बजाय एक सादे सरणी के साथ एक बाइट कम होगी preg_split।

— टाइटस

1

10 अक्षर छोटे:echo preg_replace('/([A-Z])[a-z]+/',"$1 = $0\n",Alfa...Zulu);

— डेवी मोर्गन

4

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

"Alfa Bravo Charlie Delta Echo Foxtrot Golf Hotel India Juliet Kilo Lima Mike November Oscar Papa Quebec Romeo Sierra Tango Uniform Victor Whiskey Xray Yankee Zulu"ṇ₁{hw": "w?ẉ}ᵐ

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

व्याख्या

"…"ṇ₁               Split the string on spaces
     {         }ᵐ   Map on each word:
      hw              Write the first letter
        ": "w         Write ": "
             ?ẉ       Write the word followed by a new line

— Fatalize
स्रोत

4

PHP, 188 186 180 174 बाइट्स

कोई अनुगामी रिक्त स्थान, एक अग्रणी नई रेखा

<?=preg_filter("#[A-Z]#","
$0: $0",AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu);

बस के साथ संपीड़ित स्ट्रिंग में सभी बड़े अक्षरों को बदलता है
<newline><letter><colon><space><letter>

— टाइटस
स्रोत

इस बार प्रतिस्पर्धी ? ;)

— क्रिस्टोफ

gzinflateके परिणाम के साथ -13 बाइट्स gzdeflate(Alfa...Zulu)।

— टाइटस

दुर्भाग्य से, किसी भी प्रमुख न्यूलाइन की अनुमति नहीं है, केवल एक (एकल)

— न्यूलाइन को पार

@ सकल: कल से ओप्स की टिप्पणी देखें:and for your other question, yes, but just one.

— टाइटस

4

x86 असेंबली, 512 बाइट्स

NASM के साथ संकलित और QEMU के साथ परीक्षण किया गया। बूट करने के लिए आपको बूटेक्टर (फाइल में 510 बाइट्स) के अंत में एक 2 बाइट बूट सिग्नेचर लगाने की आवश्यकता होती है, इसलिए मैंने शून्य कोड के साथ संकलित कोड को भरने के लिए 317 बाइट खो दिया। यह मेरा पहला गोल्फ है इसलिए मुझे किसी भी बड़ी त्रुटि के लिए माफी मांगनी होगी।

[org 7c00h]     ;So NASM can change the labels into memory locations correctly.

cld             ;Tells lodsb to look forward in memory

mov bh, 65      ;Moves the ASCII value of A into the BH register
mov si, NATO    ;Moves the first byte of NATO into the si register
call print      ;Call the 'print' subroutine

jmp $            ;Loops forever

print:
    mov ah, 0eh ;Moves the hex value 0E into the AH register. Tells interrupt 10h that we want subfucntion 0E
    lodsb       ;Load a byte of SI into AL and increments a register (DL i think) that tells it the offset to look at

    cmp al, 3   ;Compares the AL register that now has a byte from our string to ASCII value 3 (Enf Of Text)
    je R        ;If AL == 3 then jump to R

    cmp al, 0   ;Comapre AL to ASCII 0 (NULL)
    je newWord  ;If AL == 0 hump to newWord
    int 10h     ;Execute interrupt 10h Subfunction 0Eh (stored in AH register) which prints character value in AL
    jmp print   ;Jump to print

newWord:
    mov al, 10  ;Move ASCII 10 (New Line) into AL
    int 10h     ;Print character

    mov al, 13  ;Move ASCII 13 (Carriage Return) into AL
    int 10h     ;Print character

    mov al, bh  ;Move BH (which has our starting letter) into AL
    int 10h     ;Print Character

    mov al, 58  ;Move ASCII 58 (:) into AL
    int 10h     ;Print Character

    mov al, 32  ;Move ASCII 32 (Space) into AL
    int 10h     ;Print Character

    mov al, bh  ;Move BH into AL
    int 10h     ;Print Character

    inc bh      ;Increments BH by one (BH++)
    jmp print   ;Jump to print

R:
    ret         ;Returns from a subroutine

;Below defines bytes (db) of our string to print. I used 0 as word seperators and 3 to end the string.
NATO: db 0,"lfa",0,"ravo",0,"harlie",0,"elta",0,"cho",0,"oxtrot",0,"olf",0,"otel",0,"ndia",0,"uliet",0,"ilo",0,"ima",0,"ike",0,"ovember",0,"scar",0,"apa",0,"uebec",0,"omeo",0,"ierra",0,"ango",0,"niform",0,"ictor",0,"hiskey",0,"ray",0,"ankee",0,"ulu",3

times 0200h - 2 - ($ - $$) db 0 ;Zerofill the file with upto 510 bytes (This is where all my bytes are)
dw 0AA55H   ;Write the bootsignature

उत्पादन

यह उपरोक्त कोड आउटपुट है। जैसा कि आप देख सकते हैं A: अल्फा गायब है और ऐसा इसलिए है क्योंकि प्रॉम्प्ट 25 लाइनों लंबा है ... कोड आउटपुट से ऊपर

साबित करने के लिए मैं मुद्रित एक: अल्फा मैं प्रतिस्थापित 0,"ulu"के साथ 32,"Z: Zulu"इतना है कि ज़ुलु यांकी के रूप में एक ही लाइन पर एक है। परिवर्तित कोड

मैं इसकी सराहना करूंगा अगर कोई मुझे बताए कि क्या मैं अपने कोड से 317 बाइट्स के ज़ोर्फिल को घटा पाऊंगा तो यह 195 बाइट होगा। यह भी अगर यह मान्य है क्योंकि आउटपुट स्क्रीन पर फिट नहीं होगा।

— भयभीत डिनो
स्रोत

4

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

print''.join('\n%s: '%c*('['>c)+c for c in'AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu')

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

— फेलिप नारदी बतिस्ता
स्रोत

2

प्रश्न पर टिप्पणी देखें: एक अग्रणी नई पंक्ति (अब) स्वीकृत है

— टाइटस

PPCG में आपका स्वागत है! अच्छी सामग्री।

— जोनाथन एलन

4

सी (मिनगव, क्लैंग), 218 बाइट्स

@Gastropner को धन्यवाद!

i;f(){char s[]="lfa:ravo:harlie:elta:cho:oxtrot:olf:otel:ndia:uliet:ilo:ima:ike:ovember:scar:apa:uebec:omeo:ierra:ango:niform:ictor:hiskey:ray:ankee:ulu";for(i=64;++i<91;)printf("%c: %c%s\n",i,i,strtok(i^65?0:s,":"));}

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

सी, 259 236 बाइट्स

i;f(){char*s="lfa\0ravo\0harlie\0elta\0cho\0oxtrot\0olf\0otel\0ndia\0uliet\0ilo\0ima\0ike\0ovember\0scar\0apa\0uebec\0omeo\0ierra\0ango\0niform\0ictor\0hiskey\0ray\0ankee\0ulu";for(i=64;++i<91;s+=strlen(s)+1)printf("%c: %c%s\n",i,i,s);}

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

— Steadybox
स्रोत

मैं इसे कैसे संकलित करूंगा?

— इते ग्रामदेव

1

@ यहगुरुदेव, जीसीसी और क्लैंग दोनों को संकलित करना चाहिए जैसा कि है। gcc src.cया clang src.c। यहाँ जोड़ा एक मुख्य कार्य के साथ एक नमूना रन है, तो कोड होगा वास्तव में लिंक और रन: ideone.com/4Eowlh

— क्रिस

@ क्रिस 4 बाइट्स की कीमत पर, कोड को मान्य है, या मैं कुछ गोल्फ सम्मेलन याद कर रहा हूँ के fसाथ प्रतिस्थापित नहीं किया जाना चाहिए main।

— इत्ते ग्रुदेव

2

@ इताग्रुदेव, जिस तरह से मैं इसे देखता हूं, सवाल केवल कार्यक्षमता के लिए पूछा गया है, न कि एक पूर्ण, आत्म-निहित कार्यक्रम।

— क्रिस

1

218 स्ट्रटोक () के साथ और कुछ स्ट्रिंग के साथ कुछ

i;f(){char s[]="lfa:ravo:harlie:elta:cho:oxtrot:olf:otel:ndia:uliet:ilo:ima:ike:ovember:scar:apa:uebec:omeo:ierra:ango:niform:ictor:hiskey:ray:ankee:ulu";for(i=64;++i<91;)printf("%c: %c%s\n",i,i,strtok(i^65?0:s,":"));}

अस्पष्ट अगर यह हर जगह काम करता है: TIO segfaults लेकिन कम से कम MinGW में काम करता है। यह काम नहीं करेगा एक कारण के बहुत कुछ नहीं देख सकता ।

— गैस्ट्रोपनर

3

गामा, 168 वर्ण

\A=@subst{?<J>=\?: \$0\\n;AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu}@end

नमूना रन:

bash-4.3$ gema '\A=@subst{?<J>=\?: \$0\\n;AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu}@end' | head
A: Alfa
B: Bravo
C: Charlie
D: Delta
E: Echo
F: Foxtrot
G: Golf
H: Hotel
I: India
J: Juliet

— आदमी काम पर है
स्रोत

3

बैश , 224 205 188 180 बाइट्स

17 बाइट्स हटाने के लिए डिजिटल ट्रॉमा और 8 बाइट्स के लिए मैनटवर्क का धन्यवाद ।

set {A..Z}
for i in lfa ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu;{ echo $1: $1$i;shift;}

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

— luk3yx
स्रोत

1

कुछ गोल्फ

— डिजिटल ट्रामा

अनुक्रमण सरणी aबहुत लंबी है। set {A..Z};for i in lfa … ulu;{ echo $1: $1$i;shift;}

— मैनटवर्क

2

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

for x in'Alfa Bravo Charlie Delta Echo Foxtrot Golf Hotel India Juliet Kilo Lima Mike November Oscar Papa Quebec Romeo Sierra Tango Uniform Victor Whiskey Xray Yankee Zulu'.split():print x[0]+': '+x

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

रोमांचक या चालाक नहीं। बस सूची के माध्यम से लूप और पहले अक्षर को प्रिंट करता है ':' फिर पूरा शब्द।

— ElPedro
स्रोत

2

PHP, 184 बाइट्स 179 बाइट्स 178

<?=preg_filter('/(.)[a-z]+/',"$1: $0
",AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu);

preg_replace के बजाय preg_filter का उपयोग करके एक एकल बाइट को बचाया।

मूल उत्तर ~~184 बाइट्स~~ 179 बाइट्स

for($c=A;$s=[lfa,ravo,harlie,elta,cho,oxtrot,olf,otel,ndia,uliet,ilo,ima,ike,ovember,scar,apa,uebec,omeo,ierra,ango,niform,ictor,hiskey,ray,ankee,ulu][+$i++];$c++)echo"$c: $c$s
";

इस तथ्य का उपयोग करता है कि मक्खी पर पहले चार उत्पन्न करने के लिए इसकी छंटनी की।

5 बिट्स @ टिट्स द्वारा बचाए गए।

— क्रिस्टोफ
स्रोत

2

अपने मूल को 180-1 से नीचे गोल्फ करें for($c=A;$s=[lfa,...,ulu][+$i++];$c++)echo"$c: $c$s\n";। हालांकि रेगेक्स अच्छा लगा।

— टाइटस

@ मुझे लगता है कि वहाँ एक बेहतर तरीका होना चाहिए था, लेकिन Preg करने के लिए बंद कर दिया। पारितोषिक के लिए धन्यवाद !

— क्रिस्टोफ

2

एसओजीएल , 91 बाइट्स

╗D↕«∙φā¡75↔TI.½!γΜΧ…¡%<F┼0h╔κy|▓@TņV≈%⁹cr_σy░mgļΕžΕ⅝ »τ{M╔|«▼↔»aΓ²⁹┘′⅓G…└g↔bFΞ‽‘θ{KUtƧ: ooo

स्पष्टीकरण:

...‘θ{KUtƧ: ooo  that gibberish is a compressed string                 
...‘             push the compressed string of the words
    θ            split on spaces
     {           for each
      K          pop the 1st letter off & push it
       U         uppercase it
        t        output in newline a copy of the letter
         Ƨ: o    append ": "
             o   append the alphabet letter
              o  append the rest of the word

— dzaima
स्रोत

2

GNU sed , 165 बाइट्स

यह स्क्रिप्ट मार्टिन एंडर के रेटिना उत्तर पर आधारित है ।

s/$/AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu/
s/[A-Z]/\n&: &/g
s/.//

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

स्पष्टीकरण:

s/$/AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu/
   # generate the alphabet words in concatenated form
s/[A-Z]/\n&: &/g
   # prepend '\nUL: ' before each upper-case letter (UL), getting the needed format
s/.//
   # delete the leading newline, plus implicit printing at the end

— seshoumara
स्रोत

2

बैश , 184 बाइट्स

printf '%c: %s
' {Alfa,Bravo,Charlie,Delta,Echo,Foxtrot,Golf,Hotel,India,Juliet,Kilo,Lima,Mike,November,Oscar,Papa,Quebec,Romeo,Sierra,Tango,Uniform,Victor,Whiskey,Xray,Yankee,Zulu}{,}

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

— डेनिस
स्रोत

+1। {,}ब्रेस विस्तार में चाल प्रत्येक सूची सदस्य अप दोगुना करने के लिए एक बहुत ही चतुर तरीका है!

— डिजिटल ट्रामा

2

लुआ, 278 260 बाइट्स

18 बाइट बचाने के लिए मैनटवर्क के लिए फिर से धन्यवाद !

function f(w)print(w.sub(w,0,1)..": "..w)end
f"Alfa"f"Bravo"f"Charlie"f"Delta"f"Echo"f"Foxtrot"f"Golf"f"Hotel"f"India"f"Juliet"f"Kilo"f"Lima"f"Mike"f"November"f"Oscar"f"Papa"f"Quebec"f"Romeo"f"Sierra"f"Tango"f"Uniform"f"Victor"f"Whiskey"f"Xray"f"Yankee"f"Zulu"

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

पुराने संस्करण

a={"Alfa","Bravo","Charlie","Delta","Echo","Foxtrot","Golf","Hotel","India","Juliet","Kilo","Lima","Mike","November","Oscar","Papa","Quebec","Romeo","Sierra","Tango","Uniform","Victor","Whiskey","Xray","Yankee","Zulu"}
for i=1,26 do print(a[i].sub(a[i],0,1) .. ": " .. a[i]) end

https://repl.it/GK8J

पहली बार लुआ करते हुए, संभवत: अधिक गोल्फ कर सकते हैं, लेकिन मैंने सोचा कि मैं इसे उत्तर के रूप में जोड़ूंगा।

— ʰᵈˑ
स्रोत

मेरा प्रश्न उबाऊ हो सकता है, लेकिन फिर से: क्यों चर a? ;) आप के अंदर पूरे सरणी घोषणा को स्थानांतरित कर सकते हैं for। और for.. inवाक्यविन्यास उन लंबी सरणी सूचकांकों को लिखने से बचने में मदद करता है: pastebin.com/rxck79md अजीब लुआ बात: यदि आप एक फ़ंक्शन की घोषणा करते हैं और इसे 26 बार "मैन्युअल रूप से" कहते हैं (मेरा मतलब है, लूप में नहीं) छोटा है - पास्टबिन। com / FMF9GmLJ

— मैनटवर्क

¯\_(ツ)_/¯इस कारण से कि मैंने पहले कभी लुआ का उपयोग नहीं किया था इसलिए मैं इसे काम करने की कोशिश करने के लिए मैनुअल का पालन कर रहा था, अहा। जानकारी के लिए धन्यवाद @manatwork, मैं उस बारे में नहीं जानता था।

— ʰᵈˑ

2

लुआ , 177 बाइट्स

print(("AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu"):gsub('%u',"\n%1: %1"):sub(2))

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

नई बाइलिंग के बिना, 180 बाइट्स:

io.write(("AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu"):gsub('%u',"\n%1: %1"):sub(2))

व्याख्या

str = "AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu"
str = str:gsub('%u',"\n%1: %1") -- returns "\nA: Alfa...". %u matches uppercase letters, %1 returns matched letter in this case.
str = str:sub(2) -- remove added newline in the beginning
print(str) -- native print command

यह अपरकेस अक्षरों से मेल खाने के लिए Lua के string.gsub प्रतिस्थापन समारोह का उपयोग करता है। तब पत्रों को अनुरोधित प्रारूप (स्वयं पत्र) के साथ बदल दिया जाता है। उसी दर्रे पर नई लाइनें भी जोड़ी जाती हैं।

अंत में उप-कार्य शुरुआत से ही नई रूपरेखा को ट्रिम कर देता है और साथ ही साथ gsub के दूसरे रिटर्न वैल्यू को छिपाने के लिए अच्छी तरह से काम करता है, जो प्रतिस्थापन की राशि होती।

— एल। कोइवुनेन
स्रोत

2

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

0..25|%{($a=[char]($_+65))+": $a"+(-split'lfa ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu')[$_]}

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

लूप्स से 0करने के लिए 25, प्रत्येक यात्रा के गठन $aइसी पूंजी की char। फिर स्ट्रिंग-संघातित : $a(यानी, कोलन-स्पेस-लेटर)। फिर उस स्ट्रिंग को स्ट्रिंग से कंसट्रेट किया जाता है, जो कि -splitस्पेस पर ध्वन्यात्मक स्ट्रिंग को बांधकर बनाई गई एक सरणी में अनुक्रमित करके बनाई जाती है । उन 26 तारों में से प्रत्येक को पाइप लाइन पर छोड़ दिया जाता है, और Write-Outputतत्वों के बीच एक नई रेखा सम्मिलित करते हुए, कार्यक्रम पूरा होने पर एक निहित होता है।

@Matt की बदौलत दो बाइट्स बचाए।

— AdmBorkBork
स्रोत

अच्छा लगा। प्रत्येक शब्द के पहले वर्ण को हटाने से भी मेरे साथ ऐसा नहीं हुआ। आप इसे करते हुए 2 बाइट्स काट सकते हैं:

0..25|%{($a=[char]($_+65))+": $a"+(-split'lfa ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu')[$_]}

— मैट

@ माट ओह यकीन है, यह समझ में आता है। धन्यवाद!

— AdmBorkBork

2

सी, 216 215 212 बाइट्स

i=64,l;f(){for(char*s="lfAravOharliEeltAchOoxtroTolFoteLndiAulieTilOimAikEovembeRscaRapAuebeComeOierrAangOniforMictoRhiskeYraYankeEulU";++i<91;printf("%c: %c%.*s%c\n",i,i,l,s,s[l]+32),s+=l+1)for(l=0;s[++l]>90;);}

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

एक विस्तृत, मानव पठनीय, अच्छी तरह से टिप्पणी की गई और कार्यक्रम के पूरी तरह से मान्य (कोई संकलक चेतावनी) संस्करण नीचे पाया जा सकता है:

#include <stdio.h>

int main() {
    // Uppercase characters designate the last character of a word
    char*s="lfAravOharliEeltAchOoxtroTolFoteLndiAulieTilOimAikEovembeRscaRapAuebeComeOierrAangOniforMictoRhiskeYraYankeEulU";

    int i = 64; // Consecutive character
    int l; // Word length

    // Loop `i` from A to Z; Shift `s` with word length
    // `s` always points to the beginning of a word
    for( ; ++i < 91; s += l + 1 ) {
        // Increment `l` until you reach the next capital letter
        for( l = 0; s[++l] > 90 ;);
        // Print the current character, the word without it's last letter
        // and the last letter lowercased
        printf( "%c: %c%.*s%c\n", i, i, l, s, s[l]+32 );
    }
}

— इते ग्रामदेव
स्रोत

1

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

— R

@ceilingcat न केवल char*sबल्कि printfवहाँ भी जा सकते थे। इस प्रकार एक और 3 बाइट्स को बचाने - एक अर्धविराम और 2 घुंघराले ब्रेसिज़ के रूप में हम अब उन्हें जरूरत नहीं है क्योंकि यह शरीर में केवल एक ही निर्देश है - दूसरा forलूप।

— इते ग्रामदेव

2

जावास्क्रिप्ट ईएस 6, 216 187 184 180 174 बाइट्स

"AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu".replace(/[A-Z]/g,`
$&: $&`).trim()

नील को एक बाइट दिया। बच निकले 5 बाइट्स ETHproductions की बदौलत।

console.log("AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu".replace(/[A-Z]/g,`
$&: $&`).trim());

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

जाप , 127 बाइट्स

`AlfaBŸvoC•r¦eDeltaE®oFoxÉ•GolfHÇUI˜iaJªietKiloL‹aMikeNovem¼rOs¯rPapaQue¼cRo´oSi€ŸTÂ
UnifŽmVÅ¡rW–skeyXŸyY„keeZªu`r"%A""
$&: $&

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

2 बाइट्स obarakon के लिए धन्यवाद बचा लिया।

— टॉम
स्रोत

मैं सोच रहा था कि आप उस अग्रणी नई पंक्ति से कैसे छुटकारा पा सकते हैं - यह वास्तव में बाइट से सस्ता होगा जो आपके पिछले दृष्टिकोण की तुलना में मैन्युअल रूप A: Aसे स्ट्रिंग के लिए प्रस्तुत करना है। लेकिन आप इसके बजाय एक शाब्दिक newline चरित्र का उपयोग करके अभी भी एक और बाइट बचा सकते हैं \n।

— नील

अच्छा जवाब। आप जाप में एक शाब्दिक न्यूलाइन का उपयोग कर सकते हैं। इसके अलावा, अपने दूसरे तर्क के लिए एक स्ट्रिंग को स्वीकार करें और $&मैच के साथ इसमें किसी भी एस को बदल दें , ताकि आप "\n$&: $&"फ़ंक्शन का उपयोग करने के बजाय दोनों लंगों के लिए कर सकें।

— ETHproductions

आप @"\n{X}: {X}"}Japt में बदल सकते हैं बस "\n$&: $&":-)

— ETHproductions

@ETHproductions मदद के लिए धन्यवाद!

— टॉम

अच्छा जवाब! आप इनपुट में " xएक -xझंडा डालकर और ड्रॉप करके एक जोड़े बाइट्स को बचा सकते हैं । ध्यान दें कि ध्वज कुल बाइट्स में 1 बाइट जोड़ता है।

— ऑलिवर

2

PHP, 175 171 164 162 बाइट्स

नोट: अब संपीड़ित फ़ाइल की आवश्यकता नहीं है, IBM-850 एन्कोडिंग का उपयोग करता है।

for($l=A;$c=LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu[$i++];)echo$c<a?"
$l: ".$l++:"",$c|~▀;

इस तरह से चलाएं:

php -nr 'for($l=A;$c=LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu[$i++];)echo$c<a?"
$l: ".$l++:"",$c|~▀;';echo

व्याख्या

प्रत्येक वर्ण को व्यक्तिगत रूप से प्रिंट करता है (एक स्थान के साथ या उससे कम)। यदि एक बड़े अक्षर का सामना किया जाता है, तो यह पहले "\ nA: A" फ़ॉर्म की एक स्ट्रिंग प्रिंट करता है।

बदलाव

एक और संपीड़न रणनीति का उपयोग करके 4 बाइट्स सहेजे गए
एक अलग सीमांकक ( $lविस्फोट परम के साथ गठबंधन करने के लिए ) का उपयोग करके 7 बाइट्स सहेजे गए , और एक प्रमुख रूपरेखा को रोकना नहीं
एक नई विधि के साथ 2 बाइट्स बचाए

— aross
स्रोत

1

जाप, 216 214 बाइट्स

`A: Alfa
B: Bvo
C: Cr¦e
D: Delta
E: E®o
F: FoxÉ
G: Golf
H: HÇU
I: Iia
J: Jªiet
K: Kilo
L: La
M: Mike
N: Novem¼r
O: Os¯r
P: Papa
Q: Que¼c
R: Ro´o
S: Si
T: TÂ
U: Unifm
V: VÅ¡r
W: Wskey
X: Xy
Y: Ykee
Z: Zªu

व्याख्या: इसे करने के लिए एक बहुत बेहतर तरीका है, लेकिन जब से मैं नया हूँ मुझे यह नहीं पता है। मैंने मूल रूप से स्ट्रिंग को Oc के साथ संकुचित किया है "और उस स्ट्रिंग को ओड का उपयोग करके विघटित किया जा सकता है"

अगर कोई मुझे लाइन ब्रेक से अलग कुछ का उपयोग करके बाइट्स बचाने में मदद करना चाहता है, तो मुझे खुशी होगी!

संपादित करें: सहेजे गए 2 बाइट्स का उपयोग करके 'ओड के बजाय'

— मार्टिज़न विसेर्स
स्रोत

ऑनलाइन प्रयोग करके देखें ! यह वांछित परिणाम नहीं दे करता है:/

— ʰᵈˑ

@ Enoughyes कि हो सकता है, मेरे पास इतना समय नहीं था कि मैं काम पर जाने से पहले सब कुछ देख सकूँ। मैं काम के बाद इसे फिर से (और बेहतर) कर सकता हूं।

— मार्टिज़न विसेर्स

1

@ ʰᵈˑ स्ट्रिंग में कुछ अनपेक्षित हैं जो मार्कडाउन में दिखाई नहीं देते हैं। इसे ऑनलाइन आज़माएं!

— ETHproductions

@ETHproductions आह इसके लिए धन्यवाद, मुझे नहीं पता था

— '

1

पायके, 89 बाइट्स

.d⻵㡺ᐒଆຳ뼙΋ÒΗ䊊繎ㅨڨǔᯍⰬᐓ❤ᄵ㤉ተ᤬䆰髨⨈性dc Fl5DhRJ":

— नीला
स्रोत

क्या ये पात्र विशिष्ट एकल बाइट वर्ण सेट में होते हैं?

— आदम

TIO एक खराब त्रुटि देता है और संदेश में 161 बाइट्स की रिपोर्ट करता है। या तो पक्के को वहां धकेलने की जरूरत है या यहां कॉपी और पेस्ट में कुछ गड़बड़ हो गई है। @ अगर यह 1-1 था, तो यह 41 बाइट्स होगा, यूटीएफ -8 88 होगा, लेकिन कुछ निश्चित रूप से थोड़ा दूर दिखता है।

— जोनाथन एलन

@JonathanAllan यह UTF-8 होना चाहिए। TIO इसे UTF-8 में नहीं चलाता है। मुझे लगता है कि बाइट-गिनती गलत हो सकती है क्योंकि इसे UTF-8

— Blue

1

Qbasic, 383 बाइट्स

प्रभावशाली नहीं है, लेकिन इसके लायक क्या है:

dim a(1to 26)as string
a(1)="lfa
a(2)="ravo
a(3)="harlie
a(4)="elta
a(5)="cho
a(6)="oxtrot
a(7)="olf
a(8)="otel
a(9)="ndia
a(10)="uliet
a(11)="ilo
a(12)="ima
a(13)="ike
a(14)="ovember
a(15)="scar
a(16)="apa
a(17)="uebec
a(18)="omeo
a(19)="ierra
a(20)="ango
a(21)="niform
a(22)="ictor
a(23)="hiskey
a(24)="ray
a(25)="ankee
a(26)="ulu
for i=1to 26
?chr$(i+64);": ";chr$(i+64);a(i)
next

— anonymous2
स्रोत

पुरानी बुनियादी यादें ... जिन्हें एक dataबयान में संग्रहीत नहीं किया जा सकता readहै for.. nextलूप के अंदर ?

— मैनटवर्क

@manatwork, यह एक अच्छा विचार है; मैंने इसके बारे में नहीं सोचा था!

— अनाम 2

सिर्फ ?"A: Alfa"और सिर्फ 360 बाइट्स नहीं होंगे?

— oerkelens

@oelelens, आप सही हो सकते हैं। मैंने भी संभावना पर विचार नहीं किया। :)

— अनाम

1

/// , 220 बाइट्स

/;/: /A;Alfa
B;Bravo
C;Charlie
D;Delta
E;Echo
F;Foxtrot
G;Golf
H;Hotel
I;India
J;Juliet
K;Kilo
L;Lima
M;Mike
N;November
O;Oscar
P;Papa
Q;Quebec
R;Romeo
S;Sierra
T;Tango
U;Uniform
V;Victor
W;Whiskey
X;Xray
Y;Yankee
Z;Zulu

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

-20 बाइट्स @ETHproductions के लिए धन्यवाद।

— कॉमरेड स्पार्कलपनी
स्रोत

यह मुश्किल नहीं है, और यह 20 बाइट बचाता है: इसे ऑनलाइन आज़माएं!

— 21

@ETHproductions मुझे मिलता है ... किसी कारण से मैं इसे खत्म कर रहा था। मैं जवाब अपडेट कर दूंगा।

— कॉमरेड स्पार्कलपनी

चार्ली, ऑस्कर, डेल्टा, इको

नियम:

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

जैली , 76 बाइट्स

कैसे?

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

05AB1E , 102 98 बाइट्स

रूबी, 169 अक्षर

जावा 7, 242 225 222 217 बाइट्स

ऑक्टेव, 215 210 209 बाइट्स

PHP, 202 227 196 187 बाइट्स

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

व्याख्या

PHP, 188 186 180 174 बाइट्स

x86 असेंबली, 512 बाइट्स

उत्पादन

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

सी (मिनगव, क्लैंग), 218 बाइट्स

सी, 259 236 बाइट्स

गामा, 168 वर्ण

बैश , 224 205 188 180 बाइट्स

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

PHP, 184 बाइट्स 179 बाइट्स 178

एसओजीएल , 91 बाइट्स

GNU sed , 165 बाइट्स

बैश , 184 बाइट्स

लुआ, 278 260 बाइट्स

लुआ , 177 बाइट्स

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

सी, 216 215 212 बाइट्स

जावास्क्रिप्ट ईएस 6, 216 187 184 180 174 बाइट्स

जाप , 127 बाइट्स

PHP, 175 171 164 162 बाइट्स

व्याख्या

बदलाव

जाप, 216 214 बाइट्स

पायके, 89 बाइट्स

Qbasic, 383 बाइट्स

/// , 220 बाइट्स