आपका कार्य नीचे बताए गए तरीके का उपयोग करके, 103-चिकनी संख्या को अंग्रेजी शब्द में अनुवाद करना है ।

कैसे?

इनपुट नंबर के प्रमुख कारकों (पुनरावृत्ति के साथ) की सूची बनाएं।
सूची को क्रमबद्ध करें:
- यदि 2 प्रमुख कारकों में से एक नहीं है, तो सूची को आरोही क्रम में क्रमबद्ध करें।
- यदि 2 प्रमुख कारकों में से एक है, तो इसे सूची से हटा दें और शेष कारकों को अवरोही क्रम में क्रमबद्ध करें।

निम्न तालिका का उपयोग करते हुए, प्रत्येक कारक को एक पत्र में अनुवादित करें:

 3 = S   13 = L   29 = X   43 = O   61 = Z   79 = H  101 = K  
 5 = P   17 = Q   31 = N   47 = R   67 = T   83 = V  103 = Y  
 7 = M   19 = U   37 = C   53 = A   71 = E   89 = D  
11 = F   23 = I   41 = W   59 = G   73 = J   97 = B

_{नोट : यह तालिका अनुभवजन्य रूप से संभव शब्दों की संख्या को अधिकतम करने के लिए बनाई गई थी। जिज्ञासु के लिए, यहां 2,187 शब्दों की एक सूची दी गई है, जो उस तरह से एनकोड की जा सकती हैं (इसमें असभ्य भाषा शामिल हो सकती है)। यह निश्चित रूप से इष्टतम होने की गारंटी नहीं है, लेकिन यह इस चुनौती के लिए पर्याप्त है।}

उदाहरण

उदाहरण 1: 579085261 (आरोही क्रम)

मुख्य कारक हैं [37, 47, 53, 61, 103] ।
2 एक प्रमुख कारक नहीं है, इसलिए हम सूची को आरोही क्रम में क्रमबद्ध रखते हैं।
37 = C, 47 = R, आदि आउटपुट "CRAZY" है।

उदाहरण 2: 725582 (अवरोही क्रम)

मुख्य कारक हैं [2, 11, 13, 43, 59] ।
2 एक प्रमुख कारक है, इसलिए हम इसे हटा देते हैं और सूची को अवरोही क्रम में क्रमबद्ध करते हैं, जो देता है:
[५ ९, ४३, १३, ११] ।
59 = जी, 43 = हे, आदि आउटपुट "GOLF" है।

उदाहरण 3: 10757494 (बार-बार कारक के साथ)

मुख्य कारक हैं [2, 11, 71, 71, 97] ।
2 एक प्रमुख कारक है, इसलिए हम इसे हटा देते हैं और सूची को अवरोही क्रम में क्रमबद्ध करते हैं, जो देता है:
[97, 71, 71, 11] ।
97 = बी, 71 = ई, 11 = एफ। आउटपुट "बीईईएफ" है।

स्पष्टीकरण और नियम

इनपुट नंबर की गारंटी 103-चिकनी और विभाज्य 2 सबसे अधिक एक बार में है।
परिभाषा के अनुसार, एक चिकनी-संख्या एक सकारात्मक पूर्णांक है ।
इनपुट और आउटपुट को किसी भी उचित प्रारूप में संभाला जा सकता है। आउटपुट लोअरकेस या अपरकेस में हो सकता है। अनुगामी व्हाट्सएप स्वीकार्य है। प्रमुख व्हाट्सएप नहीं है।
यदि आपका प्रोग्राम / फ़ंक्शन बड़े इनपुट का समर्थन नहीं कर सकता है, तो कृपया इसे अपने उत्तर में निर्दिष्ट करें।
यह कोड गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा जवाब है।

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

34874          --> ARM
483254         --> BAR
353722         --> EAR
494302         --> EGG
39061          --> FAT
6479           --> FUN
60421          --> ICE
54166          --> JAM
48911474       --> BETA
2510942        --> BOOM
2303854        --> DOOM
844261         --> FIRE
1606801        --> MAZE
1110085        --> PAGE
5212974        --> BALLS
67892046       --> BEANS
885396199      --> CREEK
67401037       --> FUNKY
27762173       --> QUICK
1238440506     --> ARROWS
33045832681    --> CRAGGY
1362714005     --> PIRATE
137302698      --> TROLLS
358310128062   --> BEGGARS
40255151586    --> DETAILS
164633248153   --> FIXATED
621172442227   --> UNRATED
2467812606     --> VACUUMS
86385078330    --> GROWNUPS
26607531423091 --> UNWORTHY

— Arnauld
स्रोत

9

ओह्ह बकवास ... 05AB1E कैश का उपयोग करते समय मारा Òगया 579085261, ऐसा महसूस होता है कि <s> एमिग्ना </ s> अदनान पहले ही शुरू हो चुका है।

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

आप 2 के कई कारकों की अनुमति दे सकते हैं, फिर इसे बनाया है ताकि कारकों की संख्या में वृद्धि से सूचकांक बदल जाता है जिस पर उलटा शुरू होता है।

— mbomb007

@ mbomb007 हां, कई संभावित रूप हैं। मेरा प्रारंभिक विचार पत्रों के समूहों पर काम करके किसी भी शब्द को एनकोड करना था ।

— अर्नुलद

5

इस चुनौती पर परीक्षण के मामले उन लोगों को याद दिलाते हैं जो फेसबुक पर "आपका एक्स नाम खोजते हैं"। उस फ़िल्म का शीर्षक खोजें जिसमें आप हैं! एक कदम, अपना पसंदीदा प्राइम नंबर चुनें <=103... आपका परिणाम है PIRATE MAZE, या DOOM VACUUMS...

— mbomb007

2

@ Qwerp-Derp यह पहले बेतरतीब ढंग से फेरबदल किया गया था और ~ 106K शब्दों के एक शब्दकोश के खिलाफ परीक्षण किया गया था, 11 अक्षरों तक (फ़ाइल लंबे समय तक मेरे एचडी पर है - मुझे लगता है कि यह मूल रूप से TWL से निकाला गया था )। फिर मैंने 'एस' को पहले या अंतिम रूप से बहुवचन शब्दों को अधिकतम करने के लिए मजबूर किया और एक अच्छे संयोजन (पुनरावर्ती) पर व्यक्तिगत पत्र विनिमय के एक जोड़े की कोशिश की। अंत में, मैंने धैर्य खो दिया और चुनौती लिखी। :-) दरअसल, इस सब से पहले, मैंने लेटर काउंट्स को पोजिशन बाय वर्ड के भीतर खाते में लेने की कोशिश की, लेकिन यह सब बहुत अच्छा नहीं था।

— अरनुलद

13

जेली , 29 27 बाइट्स

ÆEµØA“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?xḊṚḢ}¡

1 बाइट को बंद करने के लिए @JonathanAllan को धन्यवाद!

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

पृष्ठभूमि

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’

एक संख्यात्मक शाब्दिक है। उद्धरणों के बीच वर्णों को जेली कोड पृष्ठ में उनके 1-आधारित सूचकांकों के साथ बदल दिया जाता है , और परिणामस्वरूप सरणी को आधार-250 संख्या के रूप में व्याख्या की जाती है। इससे पूर्णांक c: = 288824892868083015619552399 प्राप्त होता है ।

यह काम किस प्रकार करता है

ÆEµØA“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?xḊṚḢ}¡  Main link. Argument: n

ÆE                           Yield the exponents of n's prime factorization, with.
                             zeroes. This yields an array A.
  µ                          Begin a new monadic chain with argument A.
   ØA                        Set the return value to “ABC...XYZ”.
     “¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?        Select the c-th permutation of the alphabet, yielding
                             s := “SPMFLQUIXNCWORAGZTEJHVDBKY”.
                      Ḋ      Dequeue; yield A without its first element, stripping
                             the exponent of 2.
                     x       Repeat the k-th letter of s r times, where r is the
                             exponent of the k-th odd prime number.
                          ¡  Combine the two links to the left into a quicklink:
                        Ḣ}     - Apply head to the right argument (A), yielding the
                                 exponent of 2. Since n is at most divisible by the
                                 first power of 2, this yields 1 for even numbers
                                 and 0 for odd ones. Call the link to the left that
                                 many times on the previous return value.
                       Ṛ       - Reverse the string to the left.

— डेनिस
स्रोत

10

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

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA1;;⁶
×107ÆE¢×UḢ¡t⁶

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

व्याख्या

हेल्पर स्थिरांक1£ ( “SPMFLQUIXNCWORAGZTEJHVDBKY ”1 पूर्वनिर्मित के साथ उत्पादन )

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA1;;⁶
“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’          288824892868083015619552399 (compressed representation)
              œ?ØA      th permutation of the alphabet
                  1;    prepend 1
                    ;⁶  append a space

मुख्य कार्यक्रम

×107ÆE¢×UḢ¡t⁶
×107           Multiply {the input} by 107
    ÆE         Convert to a list of frequencies for each factor
      ¢×       {Vectorized} multiply by the return value of 1£
        UḢ¡    Delete the first value, reverse the list that many times
           t⁶  Delete trailing/leading space

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

जेली , 31 बाइट्स, जो @ लीकेनुन के उत्तर से प्रेरित है

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA⁷;
ÆfÆCị¢U⁸¡U

इसे ऑनलाइन आज़माएं! (बहुत तेजी से चलाने के लिए थोड़ा संशोधित)

क्या यह असंगत है कि क्या यह एक अनुगामी न्यूलाइन को प्रिंट करता है (लेकिन पीपीसीजी आमतौर पर एक अनुगामी न्यूलाइन के साथ या बिना उत्तर की अनुमति देता है, इसलिए मुझे लगता है कि यह भी काम करता है?)। है बहुत धीमी गति से (ओ ( n ) जहां n इनपुट है और उसके अंकों को वास्तव में छोटे नहीं हैं ...)

व्याख्या

हेल्पर स्थिरांक1£ (उत्पादन “¶SPMFLQUIXNCWORAGZTEJHVDBKY”, जहां ¶न्यूलाइन है)

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA⁷;
“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’          288824892868083015619552399 (compressed representation)
              œ?ØA      th permutation of the alphabet
                  ⁷;    prepend newline

मुख्य कार्यक्रम

ÆfÆCị¢U⁸¡U
Æf          Produce list of prime factors (repeating repeated factors)
  ÆC        Map the nth prime to n
    ị¢      Index into the output of 1£
      U     Reverse
        ¡   a number of times
       ⁸    equal to the input
         U  Reverse again

वर्णमाला के क्रमपरिवर्तन को संग्रहीत करने का यह एक बहुत अच्छा तरीका है ...

— लीक नून

आह आपने मेरे क्रमपरिवर्तन परमाणु का भी उपयोग किया है: डी

— जोनाथन एलन

9

05AB1E , 39 38 बाइट्स

ÒW<iR¨}26LØR•6Ê2"£´õþÕàçŸôëÂÛ*™•36BS:J

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

8

मुझे पता था कि यह तुम में से एक है। स्क्रैप का आधा हिस्सा कूड़े में समाप्त हो गया

— मैजिक ऑक्टोपस यूरॉन

6

@ कैसरसोकोम्प्यूटिंग कैश हिट कुछ समय के दबाव को बढ़ा सकती है

— अदनान

Øइस का हिस्सा था कि वैसे भी 20 बाइट्स द्वारा मुझे हराया: पी।

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

मुझे लगता है कि आप ÝØ26ÝØR • 1S¾? ± ÔìÍ = & canècS¦ÁÜ7d • 36BS: Já¹GR 37 के लिए कर सकते हैं।

— एमिग्ना

2

यह बहुत कुशल नहीं है;)

— एमिग्ना

8

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

n=input()
i=1
L=[]
exec'i+=1;c=0\nwhile n%i<1:c+=1;n/=i\nif c:L+=[i]*c\n'*n
T='SPMFLQUIXNCWORAGZTEJHVDBKY'
print''.join(T[[p for p in range(3,104)if all(p%k for k in range(2,p))].index(q)]for q in[L,L[:0:-1]][L[0]<3])

इसे ऑनलाइन आज़माएं - स्मृति से बाहर चले बिना केवल सबसे छोटा परीक्षण मामला चलाता है

Ungolfed:

यह संस्करण उपयोग नहीं करता है exec, इसलिए आप वास्तव में मेमोरी से बाहर चले बिना सभी परीक्षण मामलों का परीक्षण कर सकते हैं।

n=input()
i=1
L=[]
while~-n:
 i+=1;c=0
 while n%i<1:c+=1;n/=i
 if c:L+=[i]*c
if L[0]<3:L=L[:0:-1]
T='SPMFLQUIXNCWORAGZTEJHVDBKY'
print''.join(T[[p for p in range(3,104)if all(p%k for k in range(2,p))].index(q)]for q in L)

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

— mbomb007
स्रोत

8

रूबी , 139 138 134 125 120 115 + 7 = 146 145 141 132 127 122 बाइट्स

-rprime+7 बाइट्स के लिए ध्वज का उपयोग करता है ।

-1 बाइट @daniero से। -4 बाइट्स को याद करते हुए कि मैं सिर्फ अस्तित्व के लिए प्राइम डिवीजन की जांच करने के बजाय एक नियमित विभाजन जांच कर सकता हूं 2।

@ Mbomb007 के पाइथन समाधान से -9 बाइट्स मुझे मेल खाते को पुनः प्राप्त करने के लिए एक छोटे तरीके की याद दिलाते हैं।

-5 बाइट्स क्योंकि अनुगामी व्हाट्सएप अब अनुमति दी गई है।

-5 बाइट्स की खोज से Enumerable#find_index

->n{x=Prime.prime_division n;x.reverse!if n%2<1;x.map{|i,c|" SPMFLQUIXNCWORAGZTEJHVDBKY"[Prime.find_index i]*c}*''}

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामले)

व्याख्या

->n{                                   # Anonymous procedure with one argument n
    x=Prime.prime_division n;          # Get prime factorization of n, sorted
                                       # p0^e0 * p1^e1 ... -> [[p0,e0],[p1,e1],...]
    x.reverse!if n%2<1;                # Reverse if divisible by 2
    x.map{|i,c|                        # For each prime/exponent pair:
        " SPMFLQUIXNCWORAGZTEJHVDBKY"[ # Get corresponding character by obtaining:
            Prime.find_index i]        # Determine index of the current prime
                               *c      # Repeat the letter by the supplied exponent
                                 }*''} # Join all letter sequences together

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

अच्छा है। आप के बीच की जगह zipऔर"

— daniero

7

बैश + GNU उपयोगिताओं + bsd- खेल पैकेज, 170

बहुत गैर-इष्टतम लगता है, लेकिन यह काम करता है:

p='printf %03d\n'
a=(`factor $1`)
x=$[a[1]<3]
$p `primes 3 104`|paste - <(fold -1<<<SPMFLQUIXNCWORAGZTEJHVDBKY)|join -o1.2 - <($p ${a[@]:x+1})|(((x))&&tac||cat)|tr -d \\n

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

— डिजिटल आघात
स्रोत

6

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

ÆfÆCUṖ$¹e@?1’ị“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA¤

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

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

6

जाप , 51 50 बाइट्स

-Pध्वज के लिए कोड के 49 बाइट्स, +1 ।

%2?Uk :Uk Åw)£`yspmflquixncÙgz’jhvdbk`g#ho fj bX

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

यह छोटा हो सकता है यदि केवल जाप में कुछ और विशेषताएं हों ...

व्याख्या

`yspmflquixncÙgz’jhvdbk`बस वही स्ट्रिंग है जो हर कोई संपीड़ित का उपयोग कर रहा है जितना कि जाप इसे संपीड़ित कर सकता है (मूल से कम 3 बाइट्स!)। इस समय Japt का केवल बिल्ट-इन कम्प्रेशन टूल एक-बाइट चार के साथ लोअरकेस अक्षर के आम जोड़े को बदल देता है।

तो चलिए वास्तविक कोड की जांच करते हैं:

%2?Uk :Uk Å  w)
%2?Uk :Uk s1 w)
%2?             // If the input mod 2 is non-zero,
   Uk           //   take the prime factors of the input (U).
      :Uk       // Otherwise, take the prime factors of the input,
          s1 w  //   slice off the first one (2), and reverse.

फिर परिणाम की तरह £प्रत्येक आइटम को बदलने के लिए उपयोग किया जाता है X:

"string"g#h o fj bX
"string"g104o fj bX

         104o         // Create the range [0...104).
              fj      // Filter to only items Z where Z.j() is truthy (Z is prime).
                      // This results in the list of prime numbers from 2 to 103.
                 bX   // Take the index of X in this list.
"string"g             // Get the char in the compressed string at that index.
                      // For `y`, the index is 26, but since the string is only 26 chars
                      // long, Japt wraps around and grabs the first char in the string.

परिणाम इस बिंदु पर वर्णों की एक सरणी है, इसलिए -Pझंडा इसे एक स्ट्रिंग में जोड़ता है, और परिणाम को आउटपुट पर भेज दिया जाता है।

— ETHproductions
स्रोत

5

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

Æfḟ2ÆCṚ⁸Ḃ¤¡Ṛị“YSPMFLQUIXNCWORAGZTEJHVDBK

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

एक बार में सभी testcases की पुष्टि करें! (ज़रा - सा संशोधित)

— लीक नन
स्रोत

5

पायथ , 54 47 बाइट्स

7 बाइट्स isaacg के लिए धन्यवाद

s__W%Q2@L."AZ❤O❤❤❤❤❤❤Q❤9❤❤×❤❤"xL_MP#r_3_103-PQ2

( ❤एक वर्णनीय चरित्र का प्रतिनिधित्व करता है)

Pyth में कई प्राइम बिल्ट-इन नहीं हैं ...

Hexdump:

0000000: 73 5f 5f 57 25 51 32 40 4c 2e 22 41 5a 03 4f f3 s__W%Q2@L."AZ.O.
0000010: 14 af 15 ed f5 51 90 39 d5 18 d7 20 a8 22 78 4c .....Q.9... ."xL
0000020: 5f 4d 50 23 72 5f 33 5f 31 30 33 2d 50 51 32    _MP#r_3_103-PQ2

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

— लीक नन
स्रोत

pyth.herokuapp.com/…

— isaacg

@isaacg मैंने इसकी कोशिश की, और मुझे नहीं पता कि यह पिछले एक के लिए अजीब परिणाम क्यों पैदा करता है।

— लीक से

मुझे नहीं पता कि आपका क्या मतलब है: pyth.herokuapp.com/…

— isaacg

@isaacg यह बहुत अजीब है।

— लीक नून

5

जे , 59 बाइट्स

'SPMFLQUIXNCWORAGZTEJHVDBKY'{~(p:>:i.26)i.[:|.@}.^:(2={.)q:

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

काफी सरल...

'SPMFLQUIXNCWORAGZTEJHVDBKY'{~(p:>:i.26)i.[:|.@}.^:(2={.)q:
                              (p:>:i.26)                      first 26 primes after 2
                                        i.                    for which the indices is
                                                         q:   prime factors
                                            |.@}.             remove first and reverse
                                                 ^:           if
                                                   (2={.)     the first entry is 2
                            {~                                reverse index
'..........................'                                  hardcoded string

— कोनोर ओ ब्रायन
स्रोत

3

PHP, 173 बाइट्स

for($i=2;1<$n=&$argn;$n%$i?++$i:$r[]=$i.!$n/=$i)for($t=$i;$i>2&!$w[$i]&&$i%--$t;$t>2?:$w[$i]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++]);$r[0]>2?:rsort($r);foreach($r as$s)echo$w[$s];

ऑनलाइन संस्करण

विस्तारित

for($i=2;1<$n=&$argn; # loop till input is 1
$n%$i?++$i:$r[]=$i.!$n/=$i) #after loop add value to result if input is divisible and divide input
  for($t=$i;$i>2&!$w[$i]&&$i%--$t; # loop if number is gt 2 and not in letter array till number is divisible 
  $t>2?:$w[$i]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++]) # if is prime add to letter array
  ; # make nothing in the loop
$r[0]>2?:rsort($r); # reverse result array if 2 is in result array
foreach($r as$s) # loop result array
  echo$w[$s]; # Output

PHP, 178 बाइट्स

for($z=2;$p<26;$t>1?:$w[$z]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++])for($t=++$z;$z%--$t;);for($i=2;1<$n=&$argn;)$n%$i?++$i:$r[]=$i.!$n/=$i;$r[0]>2?:rsort($r);foreach($r as$s)echo$w[$s];

ऑनलाइन संस्करण

विस्तारित

for($z=2;$p<26;
$t>1?:$w[$z]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++]) # after loop if is prime add to letter array
  for($t=++$z;$z%--$t;); 
for($i=2;1<$n=&$argn;)  # loop till input is 1
  $n%$i?++$i:$r[]=$i.!$n/=$i; #add value to result if input is divisible and divide input
$r[0]>2?:rsort($r); # reverse result array if 2 is in result array
foreach($r as$s) # loop result array
  echo$w[$s]; # Output

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

1

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

lambda x:(lambda a,b,e,k,l,m,q,p:len.__name__[:a].join(dict(zip((lambda n:(lambda n,f,g:f(n,e,[],f,g))(n,lambda n,i,r,f,g:g(n,i+b,r,f,g)if i<n else r,lambda n,i,r,f,g:f(n,i,[r,r+[i]][all(i%x!=a for x in[e]+r)],f,g)))(l*e*(k*l+b)),(lambda n,o,t:(lambda n,f,g:f(n, len.__name__[:a],f,g))(n,lambda n,s,f,g:g(n,s,f,g)if n>o else s,lambda n,s,f,g:f(n//t,s+chr(n%t),f,g)))((((((k<<e)-b)<<m)+m)<<((k<<q)+(k<<b)))+(((((k<<e)-b)<<e)+b)<<((k<<q)-(b<<b)))+((((((b<<k)+b))<<l)+b)<<((((k<<e)-b)<<l)+(b<<b)))+(((((k<<e)-b)<<l)-k)<<((m<<m)+p))-(((p<<m)-b)<<((m<<m)-(b<<b)))+(((m<<k)+b)<<((((m<<e)-b)<<k)-(b<<b)))+(((((k<<e)-b)<<l)-m)<<((((b<<l)+b)<<k)+k))-(((((b<<l)-b)<<l)-p)<<((b<<p)+(b<<b)))-(((p<<k)-b)<<((((b<<l)-b)<<k)+k))-(((k<<q)-b)<<((p<<l)))+(((m<<m)+m)<<((((k<<e)+b)<<k)-b))-(((k<<m)+b)<<((k<<m)-b))-(((m<<m)+k)<<((((k<<e)-b)<<k)-(b<<b)))+(((((k<<e)+b)<<e)+b)<<((m<<l)-(b<<e)))-(((((k<<e)+b)<<e)+b)<<((((b<<l)+b)<<e)-b))+((((((b<<k)+b))<<k)+b)<<((p<<k)))+(((((k<<e)-b)<<k)-k)<<((k<<l)))+(((m<<l)+b)<<((m<<k)))+(((m<<e)-b)<<((b<<m)+(b<<b)))+((((((b<<k)+b))<<e)-b)<<((k<<k)+b))+(((m<<k)-b)<<((b<<l)+b))-((((k<<e)-b))<<((k<<e)))+(((m<<e)+b)<<e)-b,b,b<<l*e)))[i]for i in(lambda x: [x.remove(e), x[::-b]][b] if e in x else x)((lambda x:(lambda x,g,h:g(x,b,[],g,h))(x,lambda x,n,r,g,h:h(x,n+b,r,g,h)if x>b else r,lambda x,n,r,g,h:h(x//n,n,r+[n],g,h)if x%n==a else g(x,n,r,g,h)))(x))))(*[x for x in range(True<<len(len.__name__))])

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

बनाने में बहुत मज़ा आया, मैंने इस ब्लॉग पोस्ट पर "SPMFLQUIXNCWORAGZTEJHVDBKY" के ASCII संख्यात्मक प्रतिनिधित्व को कम करने के लिए एल्गोरिथ्म का उपयोग किया, जिसका उपयोग मैं बिट-शिफ्ट अभिव्यक्ति में करता हूं। मैंने आम तौर पर इस ब्लॉग से बहुत प्रेरणा ली, मैं इसे खुद से आज़माना चाहता था और ऐसा करना एक अच्छी चुनौती थी।

यहाँ थोड़ा अधिक पठनीय संस्करण है, जिसमें कुछ और समझदार चर नाम भी हैं

— Billyoyo
स्रोत

कम से कम एक जगह है जिसे हटाया जा सकता है।

— mbomb007

2

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यह एक कोड गोल्फ प्रतियोगिता है, इसलिए आपका उद्देश्य आपके कोड को यथासंभव छोटा करना होना चाहिए। हमारे सहायता केंद्र ने कहा है कि चुनौतियों के सभी समाधानों को [...] उपयोग में जीतने के मानदंडों के लिए एक गंभीर दावेदार होना चाहिए। [...] एक कोड गोल्फ प्रतियोगिता में प्रवेश के लिए गोल्फ की जरूरत है

— डेनिस

579085261 CRAZY है, 725582 GOLF है, 10757494 है ...?

कैसे?

उदाहरण

स्पष्टीकरण और नियम

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

जेली , 29 27 बाइट्स

पृष्ठभूमि

यह काम किस प्रकार करता है

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

व्याख्या

जेली , 31 बाइट्स, जो @ लीकेनुन के उत्तर से प्रेरित है

व्याख्या

05AB1E , 39 38 बाइट्स

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

Ungolfed:

रूबी , 139 138 134 125 120 115 + 7 = 146 145 141 132 127 122 बाइट्स

व्याख्या

बैश + GNU उपयोगिताओं + bsd- खेल पैकेज, 170

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

जाप , 51 50 बाइट्स

व्याख्या

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

पायथ , 54 47 बाइट्स

जे , 59 बाइट्स

PHP, 173 बाइट्स

PHP, 178 बाइट्स

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