चुनौती:

संभव के रूप में कुछ बाइट्स का उपयोग करके स्क्रैबल में स्वीकार्य हर 2 अक्षर शब्द को प्रिंट करें । मैंने यहां एक पाठ फ़ाइल सूची बनाई है । नीचे भी देखें 101 शब्द हैं। कोई भी शब्द C या V. क्रिएटिव से शुरू नहीं होता है, भले ही नॉनटाइपिमल हो, समाधान को प्रोत्साहित किया जाता है।

AA
AB
AD
...
ZA

नियम:

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

शब्द सूची:

AA AB AD AE AG AH AI AL AM AN AR AS AT AW AX AY 
BA BE BI BO BY 
DE DO 
ED EF EH EL EM EN ER ES ET EX 
FA FE 
GO 
HA HE HI HM HO 
ID IF IN IS IT 
JO 
KA KI 
LA LI LO 
MA ME MI MM MO MU MY 
NA NE NO NU 
OD OE OF OH OI OM ON OP OR OS OW OX OY 
PA PE PI 
QI 
RE 
SH SI SO 
TA TI TO 
UH UM UN UP US UT 
WE WO 
XI XU 
YA YE YO 
ZA

code-golf kolmogorov-complexity scrabble

— qwr
स्रोत

8

क्या शब्दों को उसी क्रम में आउटपुट किया जाना है?

— Sp3000

2

@ Sp3000 मैं नहीं कहूंगा, अगर कुछ दिलचस्प सोचा जा सकता है

— qwr

2

कृपया स्पष्ट करें कि वास्तव में किसी तरह अलग होने के मायने क्या हैं । क्या इसके लिए व्हॉट्सएप होना जरूरी है? यदि हां, तो क्या गैर-ब्रेकिंग स्पेस की अनुमति होगी?

— डेनिस

5

ठीक है, एक अनुवाद

— मिकी माउस

3

एक शब्द नहीं है? मेरे लिए समाचार ...

— jmoreno

39

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

s="BI ODEXIF BAAX ASOHER LOXUMOPAGOR KI US AMY BOITONOSI MMEMINANEHI UPI AYAHOYOWOMUNUHAID PEFARED QIS BEN JOFETAE KAT ABYESHMALI UTI ZADOELAWE "
while s:" "in s[:2]or print(s[:2]);s=s[1:]

लगभग निश्चित रूप से सबसे छोटी विधि नहीं है, लेकिन मुझे लगा कि यह एक अच्छी शुरुआत होगी। प्रत्येक जोड़ी को यथासंभव ओवरलैप करके पथों में पैक करने का प्रयास करें (उदाहरण "ODEX..."= ["OD", "DE", "EX", ...])। रिक्त स्थान का उपयोग पथों को अलग करने के लिए किया जाता है, और इसमें एक स्थान के साथ किसी भी जोड़े को हटा दिया जाता है (अनुगामी स्थान एक एकल Eको अंत में मुद्रित होने से रोकने के लिए होता है)।

मैंने भी रेगेक्स गोल्फिंग की कोशिश की, लेकिन यह लंबा था।

— Sp3000
स्रोत

1

+1 अच्छा तरीका! मैंने रूबी के जवाब के लिए आपका स्ट्रिंग उधार लिया

— daniero

मैंने बैश और रेगेक्स का उपयोग करते हुए आपके विचार के आधार पर एक उत्तर भी बनाया

— सर्जियोएफसी

2

+1 के लिए AYAHOYOWOMUNUHAID!

— लेवल रिवर सेंट

28

CJam, 96 94 बाइट्स

0000000: 31 30 31 2c 22 5a 0a d0 fd 64 f6 07 a3 81 30 f2  101,"Z...d....0.
0000010: c2 a5 60 0c 59 0f 14 3c 01 dd d1 69 7d 66 47 6e  ..`.Y..<...i}fGn
0000020: db 54 e5 8f 85 97 de b9 79 11 35 34 21 cb 26 c3  .T......y.54!.&.
0000030: f0 36 41 2b b4 51 fb 98 48 fc cb 52 75 1f 1d b1  .6A+.Q..H..Ru...
0000040: 6b c3 0c d9 0f 22 32 36 30 62 33 36 62 66 7b 3c  k...."260b36bf{<
0000050: 31 62 32 35 6d 64 2d 35 35 7d 27 41 66 2b        1b25md-55}'Af+

ऊपर एक हेक्सडंप है, जिसके साथ उलटा हो सकता है xxd -r -c 16 -g 1।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

इस बात पर निर्भर करता है कि वास्तव में किसी तरह अलग होने के कारण , बाइट की गिनती को 93 या 92 तक कम किया जा सकता है :

अगर हम बदलने के -55साथ 59शब्दों गैर तोड़ने रिक्त स्थान (0xA0) से अलग कर दिया जाएगा।
यदि हम -55साथ बदलते हैं W, तो शब्द कम से कम संकेतों (0x40) से अलग हो जाएंगे।

विचार

हम अक्षर के प्रत्येक जोड़े को xy (ord (x) - 65) × 25 + (ord (y) - 65) के रूप में एन्कोड कर सकते हैं । ¹

परिणामस्वरूप पूर्णांकों को संग्रहीत करने के बजाय, हम सभी जोड़े के अंतरों को संग्रहीत करेंगे जो दो आसन्न शब्दों (वर्णानुक्रम में क्रमबद्ध) के अनुरूप हैं।

सबसे अधिक अंतर 35 है , इसलिए हम उन्हें एक बेस 36 पूर्णांक के अंक मानते हैं और उस पूर्णांक को बाइट स्ट्रिंग में परिवर्तित करते हैं।

कोड

101,   e# Push [0 ... 100].
"…"    e# Push the string that encodes the differences/increments.
260b   e# Convert from base 260 to integer.
36b    e# Convert from integer to base 36 (array).
f{     e# For each I in [0 ... 100]:
       e#   Push the base 36 array.
  <    e#   Keep it's first I elements.
  1b   e#   Compute their sum.
  25md e#   Push quotient and residue of the sum's division by 25.
  -55  e#   Push -55 = '\n' - 'A'.
}      e#
'Af+   e# Add 'A' to all resulting integers. This casts to Character.

¹ _{के बाद से दूसरा अक्षर एक कभी नहीं है जेड , का उपयोग करते हुए 25 के बजाय 26 पर्याप्त है।}

— डेनिस
स्रोत

14

PHP 224, 218, 210 206

foreach(explode(",","I19SR,9ZY8H,,CNK,5JRU0,H,CN4,G0H,H160,CN4,75,CU9,AMIHD,MTQP,HQOXK,7L,74,G,CXS,CU9,HTOG,,CNK,MHA8,CNL,1")as$a){$b++;for($c=0;$c<26;$c++)echo base_convert($a,36,10)&pow(2,$c)?chr(96+$b).chr(97+$c)." ":"";}

aa ab ad ae ag ah ai al am an ar as at aw ax ay ba be bi bo by de do ed ef eh el em en er es et ex fa fe go ha he hi hm ho id if in is it jo ka ki la li lo ma me mi mm mo mu my na ne no nu od oe of oh oi om on op or os ow ox oy pa pe pi qi re sh si so ta ti to uh um un up us ut we wo xi xu ya ye yo za

निश्चित तौर पर शानदार स्कोर नहीं, लेकिन मुझे चुनौती पसंद आई।

मैं विकल्पों की एक तालिका बनाता हूं, ध्वज को एक बिटवाइज़ सिस्टम बनाता हूं जो विकल्प मान्य हैं।

तब मैंने बेस -36 को स्ट्रिंग प्राप्त करने के लिए उन विकल्पों को इनकोड किया:

"I19SR,9ZY8H,,CNK,5JRU0,H,CN4,G0H,H160,CN4,75,CU9,AMIHD,MTQP,HQOXK,7L,74,G,CXS,CU9,HTOG,,CNK,MHA8,CNL,1"

ध्यान दें कि स्ट्रिंग स्ट्रिंग में 3 प्रविष्टि का कोई मूल्य नहीं है, क्योंकि C के पास कोई विकल्प नहीं है।

मूल्यों को प्रिंट करने के लिए, मैं सिर्फ वैध विकल्पों को चार्ट में परिवर्तित करता हूं।

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

तालिका को स्थानांतरित करके, अधिक खाली तत्व हैं और डेटा थोड़ा अधिक कॉम्पैक्ट रूप से एन्कोड करता है जो कुछ बाइट्स से मुंडा हुआ है। सरणी अब एक अलग क्रम में मुद्रित होती है:

foreach(explode(",","UB1YB,1,,CUP,CLMEJ,CUO,1,SG0H,5J9MR,,,H,MX01,MTXT,CYO5M,MTQ8,,CNL,MTXT,MHAP,50268,,CN5,CNL,FSZ,,")as$a){$b++;for($c=0;$c<26;$c++)echo base_convert($a,36,10)&pow(2,$c)?chr(97+$c).chr(96+$b)." ":"";}

aa ba fa ha ka la ma na pa ta ya za ab ad ed id od ae be de fe he me ne oe pe re we ye ef if of ag ah eh oh sh uh ai bi hi ki li mi oi pi qi si ti xi al el am em hm mm om um an en in on un bo do go ho jo lo mo no so to wo yo op up ar er or as es is os us at et it ut mu nu xu aw ow ax ex ox ay by my oy

विस्फोट के लिए और लूप संकेत के लिए इस्माइल का धन्यवाद।

foreach(explode(3,UB1YB3133CUP3CLMEJ3CUO313SG0H35J9MR333H3MX013MTXT3CYO5M3MTQ833CNL3MTXT3MHAP35026833CN53CNL3FSZ)as$d)for($e++,$f=0;$f<26;$f++)echo base_convert($d,36,10)&pow(2,$f)?chr(97+$f).chr(96+$e)." ":"";

Php5.6 के अपडेट के साथ, एक और 4 बाइट्स pow(,)को **बचाकर बदला जा सकता है ।

foreach(explode(3,UB1YB3133CUP3CLMEJ3CUO313SG0H35J9MR333H3MX013MTXT3CYO5M3MTQ833CNL3MTXT3MHAP35026833CN53CNL3FSZ)as$d)for($e++,$f=0;$f<26;$f++)echo base_convert($d,36,10)&2**$f?chr(97+$f).chr(96+$e)." ":"";

— जेम्स वेबस्टर
स्रोत

इसके बजाय द्वारा विस्फोट के ",", आप उपयोग कर सकते हैंexplode(0,UB1YB0100CUP[...])

— इस्माइल मिगुएल

एन्कोडिंग में 0s होने के बाद से यह नहीं टूटेगा?

— जेम्स वेबस्टर

हालाँकि .. वहाँ 3मैं एक का उपयोग नहीं कर सकता है! धन्यवाद

— जेम्स वेबस्टर

इसके अलावा, आप के $e++;for($f=0;$f<26;$f++)साथ बदल सकते for($e++,$f=0;$f<26;$f++)हैं, और अब आप उन pesky को हटा सकते हैं {}। और यदि आप चार्ट को लोअरकेस में बदलना चाहते हैं, तो उपयोग करें $e^' '।

— इस्माइल मिगुएल

अच्छी पकड़! मुझे वह नहीं मिला।

— जेम्स वेबस्टर

8

पर्ल, 167 164 157 बाइट्स

"AMAEDOXUHALAXISHENUNUPABEFAHIDEMYESOHOSITAAGOYAYAWOWETOINODOREX KIFEHMMER BYONELI BOEMUS PELOMI UMOFAD BATAR KANAS JOPI UTI ZAI BI QI"=~/$_/&&say for AA..ZZ

अक्षरों को एक स्ट्रिंग में जितना संभव हो सके एक साथ समूहित करने के लिए एक अलग स्क्रिप्ट लिखी जिसमें सभी मान्य 2 अक्षर शब्द शामिल हों। इसके बाद यह दो अक्षर के सभी शब्दों पर आधारित होता है और मान्य लोगों को प्रिंट करता है, प्रति पंक्ति एक। के साथ भागो perl -M5.10.1 script.pl।

— AKHolland
स्रोत

मुझे यह ऑनलाइन कंपाइलर में काम करने के लिए नहीं मिल सकता है।

— mbomb007

@ mbomb007 संस्करण के आधार पर, आपको उस संस्करण में जोड़े -M5.10.1गए sayकीवर्ड का उपयोग करने के लिए कमांड लाइन के ध्वज की आवश्यकता होती है , या use feature 'say';स्क्रिप्ट के मुख्य भाग में जोड़ें ।

— AKHolland

7

सी, 155 बाइट्स

गोल्फ संस्करण

i,v;main(){for(;++i-408;" >b  Ùc :oÒ¹ i ;¹ w so@)ia ¥g¨¸ ´k¦ase    Ù{§k {"[i/8]>>i%8&1||printf("%c%c%c ",i/8%2*v,i/16+65,!(i/8%2)*v))v="YUOIEMHA"[i%8];}

उत्पादन

YA HA AA BY BO BI BE BA AB DO DE OD ID ED AD YE OE HE AE FE FA OF IF EF GO AG UH OH EH AH OI HI AI JO KI KA LO LI LA EL AL MY MU MO MI ME MM MA UM OM EM HM AM NU NO NE NA UN ON IN EN AN YO HO PI PE PA UP OP QI RE OR ER AR SO SI SH US OS IS ES AS TO TI TA UT IT ET AT WO WE OW AW XU XI OX EX AX OY AY ZA

अनप्लग्ड संस्करण

गोल्फ संस्करण में 51-बाइट मैजिक स्ट्रिंग में ASCII 126 से परे कई पात्र हैं, जिन्हें लगभग निश्चित रूप से यूनिकोड समकक्षों में शामिल किया गया है। Ungolfed संस्करण हेक्स का उपयोग करता है, और एक शाब्दिक के बजाय एक स्थिर के रूप में। इसके अलावा, ungolfed संस्करण एक नई रेखा के साथ शब्दों को अलग करता है, जो एक्सेल में कॉपी और पेस्ट करना आसान बनाता है, सूची का आदेश देता है और आवश्यक के साथ तुलना करता है।

char a[]=
{0xFF,0x3E ,0x62,0x7F ,0xFF,0xFF ,0xEB,0x63 ,0xFF,0x3A ,0x6F,0xE3 ,0xFB,0x7F ,0xFF,0x69 ,0xFF,0x3B
,0xFB,0xFF ,0x77,0xFF ,0x73,0x6F ,0x40,0x29 ,0x69,0x61 ,0xFF,0xBE ,0x67,0xF9 ,0xF7,0xFF ,0xEF,0x6B
,0xB3,0x61 ,0x73,0x65 ,0xFF,0xFF ,0xFF,0xFF ,0xEB,0x7B ,0xF5,0x6B ,0xFF,0x7B ,0x7F};

//iterate through i = 16*letter + 8*order + vowel
i,v;main(){for(;i++-408;a[i/8]>>i%8&1||printf("%c%c%c\n",i/8%2*v,i/16+65,!(i/8%2)*v))v="YUOIEMHA"[i%8];}

व्याख्या

यदि हम 8 अक्षर AHMEIOUY को शामिल करने के लिए स्वर की परिभाषा का विस्तार करते हैं, तो हम मानते हैं कि सभी शब्दों में एक स्वर और एक अन्य अक्षर (जो स्वर नहीं भी हो सकता है या नहीं भी हो सकता है।) इसलिए, एक स्वर में समाप्त होने वाले सभी शब्दों के लिए, हम। 26 बाइट्स की तालिका की आवश्यकता है, प्रत्येक पहले अक्षर के लिए, स्वर के अनुरूप व्यक्तिगत बिट्स के साथ। हमें एक स्वर के साथ शुरू होने वाले शब्दों के लिए एक समान तालिका की आवश्यकता है, सिवाय इसके कि इस बार हमें केवल 25 बाइट्स की आवश्यकता है, क्योंकि जेड में कोई शब्द समाप्त नहीं होता है। अंतिम तालिका बनाने के लिए दो तालिकाओं को एक साथ जोड़ा गया है।

0..31 क्षेत्र में किसी भी ASCII कोड से बचने के लिए, दो सबसे कम सामान्य "स्वर" एम और एच को 6 वें और 7 वें बिट को सौंपा गया है, और एन्कोडिंग एक अमान्य शब्द के लिए 1 और एक वैध शब्द के लिए 0 मानता है। चूंकि कोई व्यंजन नहीं है जो एम और एच दोनों के साथ जोड़े, यह सुनिश्चित करना संभव है कि इनमें से कम से कम एक बिट 1 है।

गैर-ASCII वर्णों को सीमित करने की कोशिश करने के लिए 8 बिट को ए को सौंपा गया है, जो सबसे आम स्वर है (अभी भी उनमें से बहुत सारे हैं।)

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

एक स्वर से शुरू होने वाले शब्दों की हेक्स एन्कोडिंग

3E 7F FF 63 3A E3 7F 69 3B FF FF 6F 29 61 BE F9 FF 6B 61 65 FF FF 7B 6B 7B

AA AB    AD AE    AG AH AI       AL AM AN          AR AS AT       AW AX AY 
HA          HE          HI          HM    HO 

         ED    EF    EH          EL EM EN          ER ES ET          EX 
         ID    IF                      IN             IS IT 
         OD OE OF    OH OI          OM ON     OP   OR OS          OW OX OY 
                     UH             UM UN     UP       US UT 
YA          YE                            YO

एक स्वर के साथ समाप्त होने वाले शब्दों की हेक्स एन्कोडिंग

 A  H  M  E  I  O  U  Y
                         FF
BA       BE BI BO    BY  62
                         FF 
         DE    DO        EB
                         FF
FA       FE              6F
               GO        FB
                         FF
                         FF
               JO        FB
KA          KI           77
LA          LI LO        73
MA    MM ME MI MO MU MY  40
NA       NE    NO NU     69
                         FF
PA       PE PI           67
            QI           F7
         RE              EF
    SH      SI  SO       B3
TA          TI  TO       73
                         FF
                         FF
         WE     WO       EB
            XI     XU    F5
                         FF
ZA                       7F

— स्तर नदी सेंट
स्रोत

हो सकता है कि गोल्फ संस्करण का एक हेक्सडंप बनाते हैं ताकि

— मैनबलिंग को

7

जावा, 484 448 407 391 389 बाइट्स

मेरी पहली कोशिश

public static void main(String[]a){int[]x={57569742,35784706,0,2099200,5534148,35651584,2048,35792896,5247168,2048,33685504,33687552,35794978,35653664,7746958,35782656,131072,2097152,395264,33687552,551296,0,2099200,131104,35653632,33554432};for(Integer i=0;i<26;i++){for(int z=0;z<26;z++){if("".format("%26s",i.toString(x[i],2)).charAt(z)=='1'){System.out.format("%c%c ",'A'+i,'A'+z);}}}}

प्रारूपित:

public static void main(String[] a) {
    int[] x = { 57569742, 35784706, 0, 2099200, 5534148, 35651584, 2048, 35792896, 5247168, 2048, 33685504, 33687552, 35794978, 35653664,
            7746958, 35782656, 131072, 2097152, 395264, 33687552, 551296, 0, 2099200, 131104, 35653632, 33554432 };
    for (Integer i = 0; i < 26; i++) {
        for (int z = 0; z < 26; z++) {
            if ("".format("%26s", i.toString(x[i], 2)).charAt(z) == '1') {
                System.out.format("%c%c ", 'A' + i, 'A' + z);
            }
        }
    }
}

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

— griFlo
स्रोत

अच्छी नौकरी! कुछ सुझाव: java.lang.Exception को केवल अपवाद कहा जा सकता है। "आर्ग्स" सिर्फ "ए" हो सकता है। String.format () हो सकता है "" .format ()। मुख्य () घोषणा में थोड़ा अतिरिक्त अंतर भी है। हालांकि कुल मिलाकर अच्छा दृष्टिकोण, +1 मुझ से :)

— 16

मैं सिर्फ प्रिंट स्टेटमेंट के साथ खेल रहा हूं, लेकिन आपने मुझे हरा दिया है! आप \nकेवल एक स्थान के साथ बदलकर एक और बाइट बचा सकते हैं। उन्हें नई लाइनों से अलग होने की जरूरत नहीं है।

— जेम्स वेबस्टर

आप कुछ रिक्त स्थान भी छोड़ चुके हैं जिन्हें आप हटा सकते हैं।

— जेम्स वेबस्टर

संकेत के लिए @JamesWebster thx।

— griFlo

4

"".formatदेखने में दर्दनाक है, लेकिन प्रफुल्लित करने वाला है।

— कोडब्रेकर

6

रूबी, 166 बाइट्स

कॉम्पैक्ट स्ट्रिंग में शब्दों को कूटने के लिए Sp3000 की साफ-सुथरी विधि उधार लेना । यहां किकर दो अक्षरों वाले शब्दों में इसे डिकोड करने के लिए एक छोटा तरीका है: ओवरलैपिंग मैचों को निकालने के लिए स्ट्रिंग के स्कैन विधि में दिए गए रेगेक्स में एक लुकहेड का उपयोग करना, न कि कॉन्टैगिंग स्पेस:

puts "BI ODEXIF BAAX ASOHER LOXUMOPAGOR KI US AMY BOITONOSI MMEMINANEHI UPI AYAHOYOWOMUNUHAID PEFARED QIS BEN JOFETAE KAT ABYESHMALI UTI ZADOELAWE".scan /(?=(\w\w))/

रूबी, 179 बाइट्स

मेरा अपना दृष्टिकोण: के बीच सभी दो अक्षर का शब्द उत्पन्न AAऔर ZA, और एक आधार 36 एन्कोडेड bitmask का उपयोग कर वैध लोगों का चयन करें:

i=-1
puts ("AA".."ZA").select{|w|"djmsjr5pfw2omzrfgydo01w2cykswsrjaiwj9f2moklc7okcn4u2uxyjenr7o3ub90fk7ipdq16dyttg8qdxajdthd6i0dk8zlmn5cmdkczrg0xxk6lzie1i45mod7".to_i(36)[i+=1]>0}

— daniero
स्रोत

6

मतलाब, 177 बाइट्स

अक्षरों के सभी अनुमत युग्मों को परिभाषित करने वाली एक बाइनरी मैट्रिक्स उत्पन्न करें, इसे फिर से आकार दें और बेस -64 इसे एनकोड करें। बेस -64 एनकोडेड स्ट्रिंग ( 'CR+ ... % ') प्रोग्राम में डेटा के रूप में उपयोग किया जाता है। कार्यक्रम मैट्रिक्स को अनपैक करने के लिए ऑपरेशन को उलट देता है, और फिर अनुमत जोड़े को पढ़ता है:

x=de2bi('CR+"''        1$$ L*\"%$!! !   $!04P@<W(        0$   1"%$$100@RZP4  $$    0$ ! 1$$$$1 0  P (    $ 0 0$ ! # %  '-32)';[i,j]=find(reshape(x(1:650),26,[])');char([j i]+64)

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

2

अच्छा एक लुइस! गोल्फ वास्तव में मज़ेदार है ... = पी

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

1

अच्छा! कोई वर्णमाला नहीं है!

— ब्रेन गाइडर

1

सलाम। यह सबसे अधिक गुप्त मैटलैब कोड है जो मैंने उम्र में देखा है ...

— होकी

धन्यवाद दोस्तों! यह बेस -64 एनकोडिंग के कारण केवल गुप्त है। वह स्ट्रिंग वास्तव में अनुमत पत्र जोड़े के 26x25 बाइनरी मैट्रिक्स को पैक करता है

— लुइस मेंडो

6

मालबोल , 2118 बाइट्स

D'``_#>nI||38h6/vdtO*)_^mI7)"XWfB#z@Q=`<)\xwvuWm32ponmfN+ibJfe^$\[`Y}@VUySXQPUNSLpJINMLEiC+G@EDCB;_?>=}|492765.R210p(-,+*#G'&feB"baw=u]sxq7Xnsrkjoh.fNdchgf_%]\a`Y^W{>=YXWPOsSRQ3OHMLKJIBfF('C<`#"8=<;:3W1w5.R2+q/('&J$)"'~D$#"baw=utsxq7Xnsrkjoh.fNdchgf_%c\D`_X|\>=YXWPOsSRQ3OHMLKJIBfFEDC%$@9]=6|:32V6/.3210)M-m+$)"'&%|Bcb~w|u;yxwvuWm3kpinmfe+ihgfH%cb[ZY}]?UZYRWVOs65KPIHGkKJIH*)?c&BA@?8\6|:32V6/.3210)M-,lk)"F&feBzbxw=uzyrwpon4Ukpi/mfkdc)g`ed]#DZ_^]VzZ<;QPt7MLQPOHlFEJIHAe(>C<;_?>765:981Uv.32+*)Mnm%$)(!Efe{zy?}|{zyxqpo5mrkpoh.fNdihg`ed]#DZ_^]Vz=YRQuUTMqQ32NMLEDhHG@(>C<;_?>76;:3W76v43,+O/.nm+*)"Fgf${z@a}v{zyr8vo5Vrqj0nmfN+Lhg`_%cbDCY}@VUySRWPt76Lp3ONMLEDhHG@(>C<;_"8\6|:32V0v.Rs10/.'&+$H('&feB"!x>|^]srwvun4Ukpi/gfe+Lbaf_%cE[`Y}@?[TxRWPUNMLKo2NGFjD,BAeED&<A:^>=6|:32V6v.R21*/(L,+*#"!E}|{z@xw|{t:[qpotsrk1Rhmlkd*Kgfe^$bDZ_^]VzZ<;QuUTMqKJOHGkEJCBA@dD=<;:^>=6|:32V654t,+O).',+*#G'&feBzbx>|^]yr8vXnsrkjoh.fkdcbg`&^Fba`Y^WVzZ<XWPUTMqQ3INMFjD,BAe?>=B;_9>7<54X8765u-Q10)o'&J$)"!~%${A!x}v<]\xwpun4rTpoh.leMchgf_d]#DZ_^]VzZYR:Pt7SLKPOHlFEJIHAeED&<`@"87<5Y98165.3,P*/(-&+$H(!~}C#c!x}|u;\[wvun4lTjih.fN+Lbgfe^c\"CY}@VUyYXWPOsSRKJIHlLE-IBAeE'&<`@"87<5Y98165.3,Pq/.-,+*#G'&fe#"!x>|{zyr8Yotml2ponPlkdcb(fH%]\[`Y^W{zZ<XWPUTMq4JIHMLEi,BA@d>=B;:9]7};:3W7wv.3,+O)o'&J*)('g%${Ay~}v{zyrq7otmrqpoh.fejiha'eG]\[ZY}@VUy<;WVOsSRQPImM/KJIBAe(>=aA:^>=6|:32V65u-Qr0/.'K+$j"'~De#zy~wv<]yrqpo5srkjohg-kdib(feG]b[Z~^]\UTYRvP8TSRKJIHlLKD,BAe?>=B;_?>7<;:981U54t,+O)o'&Jkj('&}C#"bx>_{tyr8vuWVl2pihgle+ihgfH%cEDZ~XWVUy<XWPUTMqQP2NGLEiCBGF?>b%A@?87[;:zy1U54t210/.'K+$j"'~De#zy~wv<zyxwp6Wmlqpohg-kdib(feG]ba`Y^W{>=YXWPOs65KJIHl/KJIBA@dDCB;:9]=<;:zy1Uvu3,P0)o'&J$#(!~D|#"y?}v{zyr8vXnml2ponPledc)gfH%c\D`_^]VzZ<;QVOTSLpPIHGkKJCBG@dD=<;:^>=6|:32Vw543,+*N.nm+*)"F&feB"y~}|{ts9qvonsl2ponmfN+Lha`e^$\[Z_X|\UTYRQVOsM5KJOHGFjD,BA@d>=B;:9]=};4X81w5.R210)o'&J$j"'~%|{"y?w_u;y[wpun4Ukponmfe+Lha'eGc\[!B^WV[TxXQ9ONrRQ32NMLEDh+AeE'&<`#"8=<;:3W7wv.3,+O/.'m+*)(!EfeBcbx>_{tsxwvun4Ukpi/POkdcha'_d]#DZ_^]VzZ<RQPUNMqQ3ONGkE-IBAeED=BA:9]=<|43870/St,+O/.-ml*)(!Ef|Bcb~w|u;y[Zvun4rTpoh.fN+cKgf_%cE[!BXWV[ZSwWP8TSLpJIHMLEJIBf)d'=aA@">=<5Y98165.3,Pq)('K%*#"!EfeBcyxwvu;yxwvuWm3~

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

— क्रेज़सटेस्टो ज़्वेज़्स्की
स्रोत

5

बैश, 179 बाइट्स

echo U`sed -r 's/./& &/g'<<<HAABADEDOEFAEHELAGOFEMAHINAISHMENERESITALOHOMMONOPAMUMYAWETOSOWOYOXUNUPEXI`F `grep -o ..<<<ANARASATAXAYBEBIBOBYJOKAKILIMIOIDOIDORPIQITIUSUTYEZA`

आदम कत्ज टिप्पणी के लिए 7 बाइट्स का धन्यवाद

यह sedरेगेक्स रिप्लेसमेंट करने के लिए उपयोग करता है। पहला रेगेक्स इनपुट Sp3000 विचार पर आधारित है जबकि दूसरा रेगेक्स बिना रिक्त स्थान के आम इनपुट का उपयोग करता है।

स्पष्टीकरण:

echo              print to standard output the following
U                 boundary U character
sed -r [etc]      the result of replacing regex
    .             select a character
    & &           replace it for: matched char, space, matched char
    g             do it globaly for every character
    <<<HAAB[etc]  string input based on Sp3000 idea => HA AA AB ...
F                 boundary F character
sed -r [etc]      the result of replacing regex
    ..            every two characters
    <space>&      for space+matched character
    g             do it globally
    <<<ANAR       normal input => AN AR ...

— sergioFC
स्रोत

1

आप एक स्थान का उपयोग कर सात बाइट्स से कि हटना और फिर कर सकते हैं `grep -o ..के स्थान पर `sed -r 's/ / &/g', से एक चाल मेरा उत्तर नीचे।

— एडम काटज़

5

चेतावनी, यह उत्तर प्रोग्राम के अनुसार दिलचस्प नहीं है।

चूंकि सभी शब्द दो वर्ण लंबे होते हैं, हम उन सभी को एक साथ तोड़ सकते हैं और फिर एक साधारण नियमित अभिव्यक्ति का उपयोग करके उन्हें फिर से चीर सकते हैं।

कोई भी रेगेक्स-फ्रेंडली भाषा यह कर सकती है, दूसरों की तुलना में अधिक कुशलता से:

ग्रीप (बाश के माध्यम से), 215 बाइट्स

grep -o ..<<<AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATIT

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

alert("AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATITOUHUMUNUPUSUTWEWOXIXUYAYEYOZA".match(/../g))

पर्ल, 225 बाइट्स

 $_="AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATITOUHUMUNUPUSUTWEWOXIXUYAYEYOZA";s/../$&\n/g;print

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

import re
print re.sub(r'..','\g<0>\n',"AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATITOUHUMUNUPUSUTWEWOXIXUYAYEYOZA")

एक नोट के रूप में, कुछ उत्तर यहां दिए गए हैं echo, जो मैं एक आधार रेखा पर विचार करूंगा:

पोसिक्स शेल, 307 बाइट्स

echo AA AB AD AE AG AH AI AL AM AN AR AS AT AW AX AY BA BE BI BO BY DE DO ED EF EH EL EM EN ER ES ET EX FA FE GO HA HE HI HM HO ID IF IN IS IT JO KA KI LA LI LO MA ME MI MM MO MU MY NA NE NO NU OD OE OF OH OI OM ON OP OR OS OW OX OY PA PE PI QI RE SH SI SO TA TI TO UH UM UN UP US UT WE WO XI XU YA YE YO ZA

— एडम काटज़
स्रोत

3

व्यावहारिक होने के लिए +1। वास्तव में, बेस ईको प्रदान करना वह बिंदु है जिससे सभी को शुरू करना चाहिए।

— मेटेलिम

+1 आसान उत्तर पर, लेकिन आपको यह चिह्नित करना चाहिए कि गैर-प्रतिस्पर्धी, क्या आपको नहीं होना चाहिए?

— मैथ्यू रो

@MatthewRoh - अगर कोई लीडर-बोर्ड पार्सर होता, तो शायद वह कुछ भी पाने में असफल होता क्योंकि मैं जानबूझकर शीर्षासन नहीं करता था। मुझे चिंता नहीं है, खासकर जब से मैंने पोस्ट की हर भाषा के लिए छोटे जवाब हैं।

— एडम काट्ज

3

सी - 228 217 बाइट्स - जीसीसी

 _;main(){char *z,*i="AABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EOU IEO A A ";for(z=i;_++^26;)for(;*++z^32;putchar(_+64),putchar(*z),puts(""));}

अद्यतन करूँगा यदि मैं इसे छोटा कर सकता हूँ, बस gcc -w, / a.out के साथ पूरी तरह से आउटपुट संकलित करें। अगर किसी अनजाने में कोई दिलचस्पी है, तो मुझे बताएं।

मैं अपने सिर के ऊपर से इसे छोटा करने का कोई तरीका नहीं सोच सकता, (आप तकनीकी रूप से उद्धरणों को उद्धरण में हटा सकते हैं और आपको अभी भी एक सही उत्तर मिलेगा, उत्पादन सिर्फ कचरा जैसा दिखता है) तो कृपया मुझे बताएं वैसे भी इसे छोटा करना

— जेक
स्रोत

यहाँ कुछ सुझाव दिए गए हैं, यह मेरे लिए ठीक है (बस कॉपी और पेस्ट न करें, स्टैक एक्सचेंज आवेषणों को अजीब नियंत्रण वर्णों में टिप्पणी करता है)

_;main(){char*z="AABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EOU IEO A A ";for(;_++^26;)for(;*++z^32;printf("%c%c ",_+64,*z));}

मैंने आउटपुट परिसीमा को एक नई रेखा से एक स्थान पर बदल दिया है, लेकिन यदि आप एक नई पंक्ति पसंद करते हैं (एक अतिरिक्त बाइट) के लिए printf प्रारूप स्ट्रिंग बदल"%c%c\n"

— स्तर नदी सेंट

3

सी #, 348 बाइट्स

मुझे जाना था:

using System;class A{static void Main(){var a=new System.Collections.BitArray(Convert.FromBase64String("tnOciwgCCAAAAAggAFBxHIkAAAAACICIKABQQBgAAAIgIACAgCAAIqIgigCCADfWuIgAAAACAIAAAAAwCICAIAAAYRkAAAAAAggAgAAIIoAACA=="));int c, d;for(var i=0;i<652;i++){if(a[i]){c=Math.DivRem(i,26,out d);Console.Write("{0}{1} ",(char)('A' + c),(char)('@' + d));}}}}

Ungolfed:

using System;

class A
{
    static void Main()
    {
        var a = new System.Collections.BitArray(Convert.FromBase64String(
            "tnOciwgCCAAAAAggAFBxHIkAAAAACICIKABQQBgAAAIgIACAgCAAIqIgigCCADfWuIgAAAACAI" + 
            "AAAAAwCICAIAAAYRkAAAAAAggAgAAIIoAACA=="));
        int c, d; 
        for(var i = 0; i < 652; i++)
        {
            if(a[i])
            {
                c = Math.DivRem(i, 26, out d);
                Console.Write("{0}{1} ", (char)('A' + c), (char)('@' + d));
            }
        }
    }
}

— Jodrell
स्रोत

4

यह एक कोडगॉल्फ चुनौती है, इसलिए आपको अपनी बाइट-काउंट (अपने कोड की लंबाई) को पोस्ट करना चाहिए। इसके अलावा इसे थोड़ा छोटा करने की कोशिश करें, उदाहरण के लिए व्हॉट्सएप को हटाकर।

— जकुबे

@ जकुब, क्या यह बेहतर है?

— जोड्रेल

हां, ठीक लग रहा है

— जकुब

3

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

K"aeiou"=H+-G+K\zKL.[`Z25.Bib32jdSfTs.e.e?nZ`0+@Gk@HY""byMc"ljjns 1u  a 6jji0 o 2 100u 60hg0 2 k m 101v r 6hr7c s 4 8 g006 m hpg0  a 5 q g"d

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

संपीड़न विधि: चूंकि Zकिसी भी शब्द की दूसरी स्थिति में नहीं है, इसलिए bcdfghjklmnpqrstvwxyaeiouप्रत्येक पहले अक्षर के लिए दूसरे अक्षर के रूप में उन अक्षरों में से प्रत्येक की वैधता को एनकोड करने के लिए reordered वर्णमाला का उपयोग करें (पहले अक्षर वर्णमाला क्रम में हैं)।
यह प्रति अक्षर 25 बिट्स, या बिल्कुल 5 बेस -32 अंक है। चूंकि अधिकांश व्यंजन केवल दूसरे अक्षर के रूप में स्वर लेते हैं, इसलिए मैं उनके लिए ज्यादातर 1-अंकीय संख्या प्राप्त करने के लिए अंत में स्वर लगाता हूं। मुझे यकीन है कि यह समग्र रूप से आगे के विश्लेषण और वर्णमाला के पुन: व्यवस्थित करने से बेहतर हो सकता है, हालांकि तब पुन: प्रकाशित वर्णमाला की परिभाषा अधिक बाइट्स लेगी।

व्याख्या

K"aeiou"=H+-G+K\zK # Define the reordered alphabet
K"aeiou"           # K := "aeiou"
        =H         # H :=
           -G      #      G.removeAll(
             +K\z  #                   K + "z" 
          +      K #                           ) + K

L.[`Z25.Bib32      # Define a lambda function for decompression
L                  # y = lambda b:
         ib32      # convert b to int using Base 32
       .B          # convert to binary string
 .[`Z25            # pad to the left with "0" to the nearest multiple of 25 in length

                           c"..."d # split the compressed string on " "
                         yM        # Apply y (above lambda) to each element
                                   #   Intermediate result: List of binary strings
                                   #   with 1s for allowed combinations
      .e                           # map over ^ lambda b (current element), k (current index):
        .e              b          # map over b: lambda Z (cur. elem.), Y (cur. ind.):
               +@Gk@HY             # G[k] + H[Y] (G is the regular alphabet)
          ?nZ`0       ""           #     if Z != "0" else ""
     s                             # combine into one large list
   fT                              # remove all falsy values (empty strings)
  S                                # sort (if any order is possible, remove this)
jd                                 # join on spaces (if a normal list with the words is
                                   #   allowed, remove this)

— ar4093
स्रोत

2

PHP: ~~211~~ ~~209~~ 204

आपको चेतावनियों को बंद करना होगा, अन्यथा एक अंतर्निहित निर्माण के संबंध में प्रिंट होगा $b

for($a=65;$b<strlen($c="ABDEGHILMNRSTWXY!AEIOY!EO!DFHLMNRSTX!AE!O!AEIMO!DFNST!O!AI!AIO!AEIMOUY!AEOU!DEFHIMNPRSWXY!AEI!I!E!HIO!AIO!HMNPST!EO!IU!AEO!A");$b++)if($c[$b]!='!')echo chr($a).$c[$b].' ';else$a++;

बहुत मजेदार। शुरुआती प्रयास 250 रेंज में थे, लेकिन यह अभी तक मेरा सबसे पतला है।

— NickW
स्रोत

2

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

— Sp3000

अच्छी पकड़। मैंने तदनुसार अपना सबमिशन अपडेट किया है

— निक डब्ल्यूडब्ल्यू

मैं क्यों नहीं देख सकता .. लेकिन अब यह "AAAA A ..."

— जेम्स वेबस्टर

तुम !पर बाहर ले लिया है अगर .. आप की जरूरत है कि

— जेम्स वेबस्टर

सही। मैंने बस उस पर ध्यान दिया। मैं उपयोग कर रहा था! पहले सीमांकक और मैंने पहले क्या होगा इस पर विचार किए बिना एक त्वरित खोज-प्रतिस्थापित किया।

— निकोव

2

CJam (99 बाइट्स)

इसमें कुछ विशेष वर्ण शामिल हैं, इसलिए हेक्सडंप देना सबसे सुरक्षित है। (विशेष रूप से, 0xa0गैर-ब्रेकिंग स्पेस के अनुरूप मूल्य वाला चरित्र , मुझे ऑनलाइन डेमो सेट करने में काफी परेशानी का कारण बना)।

00000000  36 37 36 22 c4 b2 2d 51  3f 04 93 5c 64 6c 8d 6e  |676"..-Q?..\dl.n|
00000010  d7 f9 7d 97 29 aa 43 ef  04 41 12 e1 aa ce 12 4d  |..}.).C..A.....M|
00000020  05 f3 1c 2b 73 43 a0 f0  41 c0 a7 33 24 06 37 a3  |...+sC..A..3$.7.|
00000030  83 96 57 69 9b 91 c4 09  c3 93 e1 ed 05 3b 84 55  |..Wi.........;.U|
00000040  d9 26 fd 47 68 22 32 35  36 62 33 38 62 7b 31 24  |.&.Gh"256b38b{1$|
00000050  2b 7d 2f 5d 7b 32 36 62  28 3b 36 35 66 2b 3a 63  |+}/]{26b(;65f+:c|
00000060  4e 7d 2f                                          |N}/|
00000063

ऑनलाइन डेमो ।

आधार -26 में दृष्टिकोण अंतर-एन्कोडिंग है।

— पीटर टेलर
स्रोत

एक पूर्णांक के लिए एक चरित्र जोड़ना एक चरित्र पैदावार है, तो आप बदल सकते हैं 65f+:cके साथ 'Af+।

— डेनिस

सच। और mdएक शानदार सुधार है, लेकिन मुझे एहसास नहीं हुआ कि मेरा जवाब आपके कितना करीब है।

— पीटर टेलर

2

CJam, 100 98 बाइट्स

'A'@" ©Ô&ñ±ð¨9_AÚá¼thÁätÑû¨HÙH&J3p¼ÛèVçckùá%´}xà41"260bGb{_{+N2$2$}{;;)'@}?}%-3<

(स्थायी लिंक)

दो बाइट्स प्रीइंस्टीट्यूशनल वेरिएबल्स के माध्यम से सहेजे गए (धन्यवाद डेनिस!)

यह मेरी पहली सीजेएम प्रविष्टि है, इसलिए संभवतः कुछ और गोल्फिंग की संभावना है। हालाँकि, मैं 63 बाइट्स के नीचे वर्णों की सूची को संक्षिप्त करने का एक तरीका लेकर आया, जो उम्मीद करता है कि कोई और मददगार होगा।

संपीड़न विधि

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

मैं प्रत्येक शब्द के केवल अंतिम वर्ण को एनकोड करता हूं, और जब भी पहला चरित्र बढ़ाना चाहिए, एक विशेष आइटम शामिल करता है। पात्रों को पहले चरित्र के रूप में एन्कोड किया जाता है, फिर मतभेदों की सूची। चूंकि कोई डुप्लिकेट शब्द नहीं हैं, इसलिए अंतर कम से कम होना चाहिए 1। इस प्रकार मैं 0एक विभाजक आइटम के रूप में उपयोग कर सकता हूं । (ध्यान दें कि मुझे प्रत्येक अनुक्रम के पहले अक्षर को एक-अनुक्रमित के रूप में संग्रहीत करना होगा, अन्यथा 'रोलओवर फर्स्ट कैरेक्टर 0' और 'ए के साथ शुरू' के बीच भ्रम होगा 0।)

चूंकि इस मामले में अंतर 15 से अधिक नहीं है, इसलिए हम बेस -16 का उपयोग कर सकते हैं और प्रत्येक (8-बिट) बाइट में दो (4-बिट) आइटम पैक कर सकते हैं। (वास्तविक कोड में मैं गैर-वर्णों वाले मुद्दों से बचने के लिए बेस-256 के बजाय बेस-260 से परिवर्तित हो गया।)

— 2012rcampion
स्रोत

आप कुछ बाइट्स का उपयोग करके बचा सकते हैं Gऔर N, जो 16 और एक लाइनफीड को धक्का देते हैं।

— डेनिस

@ डेनिस धन्यवाद, महसूस नहीं किया गया था कि चर प्रचलित थे!

— २०१२ आर्कम्पियन

1

सभी 26 अपरकेस अक्षर प्रचलित रूपांतर चर हैं। आप पूरी सूची यहां देख सकते हैं ।

— डेनिस

आप के %-3<साथ /;;या यहां तक कि जगह से अधिक बाइट बचा सकते हैं /&। (दूसरा विकल्प एक त्रुटि संदेश उत्पन्न करेगा। मेटा पर सहमति यह है कि ऐसा करना ठीक है।)

— डेनिस

2

ब्रेनफक , 1371 बाइट्स

काफी गोल्फ, लेकिन मैंने इसमें बहुत अधिक प्रयास नहीं किया।

>+[+[<]>>+<+]>[-<<+<+>>>]-[-[-<]>>+<]>-[-<<<<+>>>>]<<<<<<..>>.<<.>+.>.<<.>++.>.<
<.>+.>.<<.>++.>.<<.>+.>.<<.>+.>.<<.>+++.>.<<.>+.>.<<.>+.>.<<.>++++.>.<<.>+.>.<<.
>+.>.<<.>+++.>.<<.>+.>.<<.>+.>.<------------------------<+.>.>.<<.>++++.>.<<.>++
++.>.<<.>++++++.>.<<.>++++++++++.>.<--------------------<++.>.>.<<.>++++++++++.>
.<-----------<+.>.>.<<.>++.>.<<.>++.>.<<.>++++.>.<<.>+.>.<<.>+.>.<<.>++++.>.<<.>
+.>.<<.>+.>.<<.>++++.>.<-----------------------<+.>.>.<<.>++++.>.<<+.>++++++++++
.>.<--------------<+.>.>.<<.>++++.>.<<.>++++.>.<<.>++++.>.<<.>++.>.<-----------<
+.>.>.<<.>++.>.<<.>++++++++.>.<<.>+++++.>.<<.>+.>.<-----<+.>.>.<--------------<+
.>.>.<<.>++++++++.>.<--------<+.>.>.<<.>++++++++.>.<<.>+.>.<---------<+.>.>.<<.>
++++.>.<<.>++++.>.<<.>++++.>.<<.>++.>.<<.>++++++.>.<<.>++++.>.<-----------------
-------<+.>.>.<<.>++++.>.<<.>++++++++++.>.<<.>++++++.>.<-----------------<+.>.>.
<<.>+.>.<<.>+.>.<<.>++.>.<<.>+.>.<<.>++++.>.<<.>+.>.<<.>++.>.<<.>++.>.<<.>+.>.<<
.>++++.>.<<.>+.>.<<.>+.>.<------------------------<+.>.>.<<.>++++.>.<<.>++++.>.<
<+.>.>.<----<+.>.>.<<+.>+++.>.<<.>+.>.<<.>++++++.>.<--------------<+.>.>.<<.>+++
+++++.>.<<.>++++++.>.<-------<+.>.>.<<.>+++++.>.<<.>+.>.<<.>++.>.<<.>+++.>.<<.>+
.>.<---------------<++.>.>.<<.>++++++++++.>.<------<+.>.>.<<.>++++++++++++.>.<--
------------------<+.>.>.<<.>++++.>.<<.>++++++++++.>.<--------------<+.>.>.

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

— क्रेज़सटेस्टो ज़्वेज़्स्की
स्रोत

अच्छी तरह से एक बात के लिए, आप

— किंग्स

@JoKing कोई वास्तविक तरीका नहीं है जिससे मैं किसी को पछाड़ सकता हूं, मुझे नहीं लगता कि इस बड़े पैमाने पर बाइट के एक जोड़े को शेविंग करने में बहुत समझदारी है।

— Krzysztof Szewczyk

2

Zsh, 175 बाइट्स

यह समाधान 125-वर्ण स्ट्रिंग का उपयोग करता है, जहां निचला अक्षर सीमांकक के रूप में कार्य करता है और पूंजी अक्षरों के निम्नलिखित अनुक्रम का पहला अक्षर है।

हम के पत्रों पर पुनरावृति करते हैं $L। यदि वर्तमान पत्र $Xको एससीआई तुलना द्वारा कम किया जाता है, तो सेट $Wकरें $X। अन्यथा, शब्द को वर्तमान शब्द बनाने के लिए $Wसंक्षिप्त करें $X।

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

L=aABDEGHILMNRSTWXYbAEIOYdEOeDFHLMNRSTXfAEgOhAEIMOiDFNSTjOkAIlAIOmAEIMOUYnAEOUoDEFHIMNPRSWXYpAEIqIrEsHIOtAIOuHMNPSTwEOxIUyAEOzA
for X in ${(s::)L};{((#X>90))&&W=$X||<<<$W$X:l}

_{संपादित करें: :lलगातार आवश्यकता के अनुसार लोअरकेस को सेट करने के लिए जोड़ा जाता है,}
_{Edit2: -4 बाइट्स $Xचर का उपयोग करके और यदि [[..]]स्थिति को सरल बनाया जाता है तो}
_{Edit3: -4 बाइट्स को हटाकर उद्धरण ( ")}
_{Edit5: -5 बाइट्स को L} _{एडिट 4 के}_नीचे_{से अधिक के बजाय सरणी रूपांतरण का उपयोग करके}_{वैकल्पिक रूप से उपयोग किया जाता है: 182 बाइट्स}_{, पहले 33 अक्षरों में प्रतिवर्ती स्ट्रिंग्स का शोषण करते हुए,}_{केवल 107 अक्षर हैं}
_$L

L=aBHLMNTYdEOeFHMNRhOiSTmOUnOUoSWYaADEGIRSWXbEIOYeLSTXfAgOhIMiDFNjOkAIlIOmIMYoEFIPRXpAEIqIsHtOuHPSTwExIUyEzA
for ((;i++<$#L;))X=$L[i]&&((#X>90))&&W=$X:u||<<<$W$X`((i<34))&&<<<\ $X$W`

— roblogic
स्रोत

2

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

âG→æ£ilæα¿:√▒▓uøD¶[│█æä║¢v┼T↨σªΩ■&*φòb¡CÆ?ì▀┬6ù═╦±qBF!╘π╓╙'♣*ù&↕!£ä3±r⌡W-╓D╬☺╝ï╜²á5Æ÷§═ôφF;

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

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

मीटर ऑपरेटर के उपयोग के विचार के लिए पुनरावर्ती के लिए धन्यवाद

— user89655
स्रोत

अच्छी तरह से किया। कुछ छोटे अनुकूलन हैं जिन्हें मैं देख सकता हूं। के Mबजाय का उपयोग करें 1/और mस्पष्ट foreach और प्रिंट के बजाय एक आशुलिपि मानचित्र का उपयोग करें { ... PF। यह एक पैक 89.

— पुनरावर्ती

1

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

s='';i=int("AQHU9HU1X0313T1J9OMYMZZSRFWLCYT3POSE06UGHXDZN6H5SQSZIFCE6VEB",36)
for c in range(26):
 b=i%6;i//=6;k=(1<<b)-1;j=i%(1<<k);i>>=k
 for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':
  if j&1:s+=chr(c+65)+d+' '
  j>>=1
print s

प्रत्येक संभव पहले अक्षर के लिए कौन से दूसरे अक्षर मौजूद हैं, यह बताने के लिए चर लंबाई के बिट मास्क का उपयोग करता है। बिट मास्क 0,1,3,7,15 या 31 बिट लंबा हो सकता है। बिट्स को अक्षरों के साथ मैप किया जाता है for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':, पहले के बिट्स को अधिक सामान्य अक्षरों के लिए उपयोग किया जाता है ताकि बिट मास्क ज्यादातर मामलों में छोटा हो सके (आमतौर पर 3 या 7 बिट्स क्योंकि ज्यादातर व्यंजन केवल 5 स्वर या वाईएम या एच में से एक के बाद होते हैं)। दुर्भाग्य से कोड को डिकोड करने के लिए अधिक सरल तरीकों की तुलना में बचत को नकार दिया जाता है (मूल सूची केवल 303 बाइट्स है)।

— Samgak
स्रोत

1

मुझे पता चला कि मेरे समाधान में प्रत्येक संभव दूसरे अक्षर के लिए जो पहला अक्षर मौजूद है, उसे एनकोड करना बेहतर है । आप में कोशिश करने के लायक हो सकता है।

— जेम्स वेबस्टर

1

हास्केल, 192 बाइट्स

putStr$(\(a:b)->((a:).(:" "))=<<b)=<<words"AABDEGHILMNRSTWXY BAEIOY DEO EDFHLMNRSTX FAE GO HAEIMO IDFNST JO KAI LAIO MAEIMOUY NAEOU ODEFHIMNPRSWXY PAEI QI RE SHIO TAIO UHMNPST WEO XIU YAEO ZA"

स्ट्रिंग में प्रत्येक स्थान से अलग शब्द के लिए पहले अक्षर को अन्य सभी अक्षरों के सामने रखें और एक स्थान जोड़ें, जैसे SHIO-> SH SI SO।

— nimi
स्रोत

1

जावा, 334 बाइट्स

public class C{public static void main(String[]a){for(int i=0;i<26;i++){for(int j=0;j<26;j++){if(java.util.BitSet.valueOf(java.util.Base64.getDecoder().decode("2znORQQBBAAAAAQQAKg4jkQAAAAABEBEFAAoIAwAAAEQEABAQBAAEVEQRQBBgBtrXEQAAAABAEAAAAAYBEBAEACAsAwAAAAAAQQAQAAEEUAABA==")).get(i*26+j)){System.out.format("%c%c\n",'a'+i,'a'+j);}}}}}

प्रारूपित:

public class Code {
    public static void main(String[] a) {
        for (int i = 0; i < 26; i++) {
            for (int j = 0; j < 26; j++) {
                if (java.util.BitSet.valueOf(
                        java.util.Base64.getDecoder()
                            .decode("2znORQQBBAAAAAQQAKg4jkQAAAAABEBEFAAoIAwAAAEQEABAQBAAEVEQRQBBgBtrXEQAAAABAEAAAAAYBEBAEACAsAwAAAAAAQQAQAAEEUAABA=="))
                        .get(i * 26 + j)) {
                    System.out.format("%c%c\n", 'a' + i, 'a' + j);
                }
            }
        }
    }
}

अलग-अलग, मैंने शब्द सूची को 26x26 = 676 बिटसेट में एन्कोड किया, इसे बाइट सरणी में परिवर्तित किया, और फिर अंत में बेस 64 में बदल दिया। इस प्रोग्राम में स्ट्रिंग को हार्ड-कोड किया गया है, और रिवर्स प्रक्रिया का उपयोग बिटसेट को पुन: उत्पन्न करने के लिए किया जाता है, और अंत में शब्दों की सूची का प्रिंट आउट लें

— केविन के
स्रोत

1

जावा, 356 बाइट्स

शब्दों को प्राप्त करने के लिए यादृच्छिक संख्या जनरेटर का उपयोग करता है:

import java.util.Random;class X{public static void main(String[]a){int j,n,m=9,x;for(String u:"rgzza 2u2hh r2rxs qs5f fwiag 26i33y 2xqmje 5h94v 16ld2a 17buv 4zvdi 1elb3y 2t108q 5wne9 1mrbfe 1ih89 fh9ts r0gh".split(" ")){x=Integer.parseInt(u,36);Random r=new Random(x/2);j=m-=x%2;while(j-->0){n=r.nextInt(676);System.out.format(" %c%c",65+n/26,65+n%26);}}}}

Ungolfed:

import java.util.Random;
class X{
    public static void main(String[]a){
        int j,n,m=9,x;
        for(String u:"rgzza 2u2hh r2rxs qs5f fwiag 26i33y 2xqmje 5h94v 16ld2a 17buv 4zvdi 1elb3y 2t108q 5wne9 1mrbfe 1ih89 fh9ts r0gh".split(" ")){
            x=Integer.parseInt(u,36);
            Random r=new Random(x/2);
            j=m-=x%2;
            while(j-->0){
                n=r.nextInt(676);
                System.out.format(" %c%c",65+n/26,65+n%26);
            }
        }
    }
}

आप इसे यहाँ आज़मा सकते हैं: http://ideone.com/Qni32q

— अरनॉड
स्रोत

1

पर्ल, 248 बाइट्स

@v=split(//,"AEIOU");@s=split(' ',"ADEGIRSWX LSTX DFN EFIPRX HPST BHLMNTY DFHMNR ST DHMNSWY MN ZFKP WYPB KQXLHPMB LGJTB X");for(0..14){foreach $c(split(//,@s[$_])){$_<10?print @v[$_%5].$c." ":a;$_>4?print $c.@v[$_%5]." ":a;}}print "MM MY BY HM SH";

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

— VoiceOfFolly
स्रोत

मैं पर्ल को नहीं जानता, लेकिन मुझे लगता है कि आप रिक्त स्थान द्वारा आउटपुट को अलग कर रहे हैं। ऐसा लगता है "MM "."MY "."BY "."HM "."SH "कि इसे छोटा किया जा सकता है "MM MY BY HM SH"।

— लेवल रिवर सेंट

@steveverrill धन्यवाद! मैं बाकी कोड में इतना फंस गया कि मैंने अनदेखा कर दिया कि यह कितना बेमानी है।

— वॉइसऑफफुली

1

जावास्क्रिप्ट (ईएस 6), 214

शायद यह करने का सबसे छोटा तरीका नहीं है, लेकिन निश्चित रूप से दिलचस्प है।

_=>(i=0,[...'ABDEFGHILMNOPRSTUWXY'].map(z=>[...`ABFHKLMNPTYZ
A
AEIO
ABDFHMNOPRWY
EIO
A
AEOSU
ABHKLMOPQSTX
AE
AEHMOU
AEIOU
BDGHJLMNSTWY
OU
AEO
AEIOU
AEIU
MNX
AO
AEO
ABMO`.split`
`[i++]].map(g=>g+z).join` `).join`
`)

पहली तार में प्रत्येक अक्षर के माध्यम से लूप्स, दूसरी पंक्ति में प्रत्येक अक्षर पर जोड़ते हुए। यह उनके अंतिम पत्र के क्रम में शब्दों को लौटाता है, जैसे:

AA BA FA HA KA LA MA NA PA TA YA ZA
AB
AD ED ID OD
AE BE DE FE HE ME NE OE PE RE WE YE
EF IF OF
AG
AH EH OH SH UH
AI BI HI KI LI MI OI PI QI SI TI XI
AL EL
AM EM HM MM OM UM
AN EN IN ON UN
BO DO GO HO JO LO MO NO SO TO WO YO
OP UP
AR ER OR
AS ES IS OS US
AT ET IT UT
MU NU XU
AW OW
AX EX OX
AY BY MY OY

सुझावों का स्वागत है!

— ETHproductions
स्रोत

1

जावा, 255 254 बाइट्स

इसमें से एक और बाइट को निचोड़ने का एक तरीका मिला।

class C{public static void main(String[]a){char c='A';for(char l:"ABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EO IU AEO A".toCharArray())if(l<'A')c++;else System.out.print(" "+c+l);}}

या (हालांकि बहुत स्पष्ट नहीं):

class C {
    public static void main(String[] a) {
        char c = 'A';
        for (char l : "ABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EO IU AEO A"
                .toCharArray())
            if (l < 'A')
                c++;
            else
                System.out.print(" " + c + l);
    }
}

— Aofl
स्रोत

तुम दोनों घटनाओं बदलकर दो बाइट्स बचा सकता है 'A'में 65।

— प्रोग्रामफ़ॉक्स

1

हास्केल, 333 308 298 बाइट्स

सिर्फ मनोरंजन के लिए!

मूल्यांकन sसभी शब्दों को एक अजीब क्रम में मुद्रित करेगा - मैंने इस तथ्य का उपयोग किया कि अधिकांश संयोजन स्वर-व्यंजन या इसके विपरीत हैं, शायद कस्टम वर्ण "क्लासेस" के साथ और भी अधिक अनुकूलित कर सकते हैं, एन्कोडेड मैट्रिक्स (यहां, wऔर k) को छोटा कर सकते हैं ।

क्या किसी को मेरे मोनडिक की तुलना में उद्धरण और कोष्ठक के बिना तार प्रिंट करने का एक छोटा तरीका पता है? टाइप क्लासेस और भी लंबी हैं, जहाँ तक मैं बता सकता हूँ।

इसके अलावा, वहाँ भी pकाम करने का एक छोटा तरीका हो सकता है ...

v="AEIOU"
c="BCDFGHJKLMNPQRSTVWXYZ"
w=[976693,321324,50188,945708,52768]
k=[15,0,10,3,8,15,8,5,13,31,27,7,4,2,12,13,0,10,20,11,1]
z a b x=[[c:[e]|(e,f)<-b#p d,f]|(c,d)<-a#x]
(#)=zip
p 0=[]
p n=((n`mod`2)>0):p(n`div`2)
s=mapM_ putStrLn$concat$z v c w++z c v k++[words"AA AE AI BY HM MM MY OE OI SH"]

— लीफ विलर्ट्स
स्रोत

के sequence_रूप में ही नहीं है void$sequence? फिर आप भी छोड़ सकते हैं import।

— निमि

यह अजीब तरह से पैक किया गया है, लेकिन हाँ। धन्यवाद!

— लेइफ़ विलर्ट्स

voidआयात नहीं किया गया है। वैसे भी, इस / याद रखना चाहिए।

— लेइफ़ विलर्ट्स

1

आह, और sequence_$map putStrLnहै mapM_ putStrLn। बदलें (, )चारों ओर concat$...एक और के साथ $।

— नीमी

1

05AB1E , 143 बाइट्स (गैर-प्रतिस्पर्धात्मक)

•ZÐFý8ù6„=4ÅœÿWì±7Ë5Œ¾`ó/îAnµ%Ñ¥Ëø±/ÀéNzÖ„Ñ§IJ¶D—ÙVEStvÖò…¸¾6F³#EXŠm¯CÄµ±ÓoÊ°}^€Ftåß€ðŒ=«j;F-Â1;xX3i&QZÒ'Ü”>lwìlOs>íÙVÇI)~î‰Hç²?Öd0È^ÝQ°•36B2ô»

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

— जादू ऑक्टोपस Urn
स्रोत

@ Sp3000 के पायथन 3 उत्तर को पोर्ट करके 95 बाइट्स ।

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

1

@KevinCruijssen 91 (और मुझे यकीन है कि यह विधि कम हो सकती है, लेकिन मैंने हास्य के लिए शब्दकोश शब्दों को हाथ से चुना है)।

— ग्रैमी

1

PHP, 170 बाइट्स

सबसे छोटा तरीका जो मुझे अब तक मिल सकता है ...

for(;$c=ABFHKLMNPTYZ1A2AEIO1ABDFHMNOPRWY1EIO1A1AEOSU1ABHKJMOPQSTX3AE1AEHMOU1AEIOU1BDGHJLMNSTWY1OU11AEO1AEIOU1AEIU1MNX2AO1AEO1ABMO[$i++];)$c<1?print$c.chr($k+65)._:$k+=$c;

टूट - फूट

for(;$c=CHARACTERS[$i++];)  // loop $c through map
    $c<1                            // if $c is a letter (integer value < 1)
        ?print$c.chr($k+65)._           // print first letter, second letter, delimiter
        :$k+=$c                         // else increase second letter
    ;

नोट मुद्रण योग्य एससीआई के साथ सबसे कम बिट-मैपिंग संस्करण की लागत 6 बिट्स = बेस 64, 174 बाइट्स (97 डेटा, 77 डिकोडिंग) का उपयोग करके 7 बिट्स (बेस 128) का उपयोग करके 190 बाइट्स (113 बाइट्स डेटा + 77 बाइट्स डिकोडिंग) होती है; संभवतः भागने के लिए कुछ और।

for(;$p<676;)                   // loop through combinations
    ord("MAPPING"[$p/6])-32>>$p%6&1     // test bit
        ?                                       // if set, do nothing
        :print chr($p/26+65).chr($p++%26+65)._; // if not, print combination+delimiter

बेस 224 (ascii 32..255 का उपयोग करके) 87 बाइट्स डेटा (+ भागने) लेता है; लेकिन मुझे लगता है कि डिकोडिंग में 10 बाइट्स अतिरिक्त खर्च होंगे।
मानचित्र से C और V को बाहर करने से डेटा पर 16/14/13 बाइट बचती हैं, लेकिन डिकोडिंग में बहुत खर्च होता है।

— टाइटस
स्रोत

सभी 2 अक्षर स्क्रैबल शब्द प्रिंट करें

चुनौती:

नियम:

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

CJam, 96 94 बाइट्स

विचार

कोड

PHP 224, 218, 210 206

पर्ल, 167 164 157 बाइट्स

सी, 155 बाइट्स

जावा, 484 448 407 391 389 बाइट्स

रूबी, 166 बाइट्स

रूबी, 179 बाइट्स

मतलाब, 177 बाइट्स

मालबोल , 2118 बाइट्स

बैश, 179 बाइट्स

ग्रीप (बाश के माध्यम से), 215 बाइट्स

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

पर्ल, 225 बाइट्स

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

पोसिक्स शेल, 307 बाइट्स

सी - 228 217 बाइट्स - जीसीसी

सी #, 348 बाइट्स

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

व्याख्या

CJam (99 बाइट्स)

CJam, 100 98 बाइट्स

संपीड़न विधि

ब्रेनफक , 1371 बाइट्स

Zsh, 175 बाइट्स

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

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

हास्केल, 192 बाइट्स

जावा, 334 बाइट्स

जावा, 356 बाइट्स

पर्ल, 248 बाइट्स

जावास्क्रिप्ट (ईएस 6), 214

जावा, 255 254 बाइट्स

हास्केल, 333 308 298 बाइट्स

05AB1E , 143 बाइट्स (गैर-प्रतिस्पर्धात्मक)

PHP, 170 बाइट्स