18

किसी शब्द को देखते हुए, प्रत्येक अक्षर को अंग्रेजी वर्णमाला में संख्या के रूप में समझें (इसलिए a1 हो जाता है, b2 zहो जाता है , 26 हो जाता है और इसी तरह), और जाँच करें कि क्या उनमें से सभी, डुप्लिकेट सहित, जोड़ीदार कॉपीरेम हैं ।

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

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

man: True
day: True(अर्जन जोहान्सन को धन्यवाद)
led: False( l=12और d=4है gcd=4)
mana: True(हालांकि aकई बार होता है, 1 और 1 कोप्रिम्स होते हैं)
mom: False( gcd(13,13)=13))
of: False(धन्यवाद xnor; हालांकि 15∤6, gcd(15,6)=3)
a: True(यदि अक्षरों के जोड़े नहीं हैं, तो शब्द को कोप्राइम भी मानें)

यह एक कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है!

— bodqhrohro
स्रोत

1

हम उत्पादन कर सकते 0हैं अगर वे coprime हैं और 1यदि नहीं?

— dylnan

2

सुझाया गया टेस्ट केस जिसने एक छोटी सी बात का जवाब दिया होगा:day: True

— अर्जन जोहान्सन

1

मैं यह भी कहना चाहता हूं of: Falseकि एक गलत उदाहरण है जहां कोई भी मूल्य दूसरे का एक से अधिक नहीं है।

— xnor

@dylnan नहीं, यह contr- सहज है। वैसे भी, डेनिस का जवाब बेहतर है ;-)

— bodqhrohro

@LuisMendo किसी भी सच्चाई / झूठी, लेकिन केवल दो।

— bodqhrohro

12

वोल्फ्राम भाषा (गणितज्ञ) , 36 बाइट्स

CoprimeQ@@LetterNumber@Characters@#&

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

वोल्फ्राम भाषा (गणितज्ञ) , 33 बाइट्स

इस तीन बाइट्स छोटे संस्करण के लिए मिशा लावरोव को धन्यवाद ।

CoprimeQ @@ (ToCharacterCode @ # - 96) और

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

— जोनाथन फ्रेच
स्रोत

1

CoprimeQ@@(ToCharacterCode@#-96)&तीन बाइट्स कम है।

— मीशा लावरोव

8

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

ØaiⱮgþ`P$Ƒ

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

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

ØaiⱮgþ`P$Ƒ  Main link. Argument: s (string)

Øa          Yield "abc...xyz".
  iⱮ        Find the 1-based index of each c of s in "abc...xyz".
        $Ƒ  Call the monadic chain to the left.
            Yield 1 if the result is equal to the argument, 0 if not.
    gþ`       Take the GCDs of all pairs of indices, yielding a matrix.
       P      Take the columnwise product.
            For coprimes, the column corresponding to each index will contain the
            index itself (GCD with itself) and several 1's (GCD with other indices),
            so the product is equal to the index.

— डेनिस
स्रोत

7

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

((==).product<*>foldr1 lcm).map((-96+).fromEnum)

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

बहुत सीधा: स्ट्रिंग को संख्याओं की सूची में परिवर्तित करता है और फिर जाँचता है कि उत्पाद LCM के बराबर है या नहीं।

— Delfad0r
स्रोत

6

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

{Ism{PhxG

परीक्षण सूट

स्पष्टीकरण:

{Ism{PhxG   | Full code
{Ism{PhxGdQ | With implicit variables filled
------------+------------------------------------------
   m      Q | For each char d in the input:
    {P      |  list the unique prime factors of
      hx d  |  the 1-based index of d in
        G   |  the lowercase alphabet
  s         | Group all prime factors into one list
{I          | Output whether the list has no duplicates

_{_{क्या अजगर ने सिर्फ जेली को आउट किया?}}

— hakr14
स्रोत

6

पायथन 2 - 122 118 बाइट्स

-4 बाइट्स @JonathanAllan को धन्यवाद

यह ईमानदारी से भयानक है, लेकिन मैंने इसे पोस्ट नहीं करने के लिए बहुत लंबा रास्ता तय किया है।

from fractions import*
def f(n):r=reduce;n=[ord(i)-96for i in n];return r(lambda x,y:x*y/gcd(x,y),n)==r(int.__mul__,n)

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

— डॉन हजार
स्रोत

4

96 for~> 96for; lambda x,y:x*y~> int.__mul__।

— जोनाथन फ्रेच

5

05AB1E , 11 बाइट्स

Ç96-2.Æ€¿PΘ

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

व्याख्या

Ç96-         # convert to character codes and subtract 96
    2.Æ      # get all combinations of size 2
       €¿    # gcd of each pair
         P   # product of gcds
          Θ  # is true

— Emigna
स्रोत

क्या फाइनल Θवास्तव में आवश्यक है?

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

@ Mr.Xcoder: नहीं मुझे नहीं लगता। मैंने अभी यह मान लिया है कि हमें 2 डिस्टिक्ट वैल्यू का उपयोग करने की आवश्यकता है, लेकिन अब जब मैं देखता हूं कि इसके बारे में चुनौती में कुछ नहीं है। सत्य / मिथ्या तो ठीक होना चाहिए।

— एमिग्ना

@Emigna मैंने इसके लिए एक स्पष्टीकरण जोड़ा: आउटपुट मानों के केवल दो संस्करण होने चाहिए।

— bodqhrohro

@bodqhrohro: ठीक है। मैं इस नई आवश्यकता के अनुरूप पिछले संस्करण में वापस आ गया।

— एमिग्ना

5

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

ạ{-₉₆ḋd}ᵐc≠

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

व्याख्या

ạ{-₉₆ḋd}ᵐc≠
ạ              Split the input into its character codes
 {     }ᵐ      For each one
  -₉₆          Subtract 96 (a -> 1, b -> 2 etc.)
     ḋd        And find the unique (d) prime factors (ḋ)
         c     Combine them into one list
          ≠    And assert they are all different

— PunPun1000
स्रोत

4

पायथन 2 , 77 68 64 बाइट्स

lambda a:all(sum(ord(v)%96%i<1for v in a)<2for i in range(2,26))

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

मूल रूप से, (इनपुट में कुछ जोड़ी सह-अभाज्य नहीं है) यदि और केवल अगर (एक संख्या i> 1 है जो एक से अधिक इनपुट को विभाजित करता है)।

— चास ब्राउन
स्रोत

लगता है कि हमारे पास एक ही विचार था लेकिन आपने मुझे कुछ मिनटों के लिए हरा दिया :) क्या आप उन 2 बाइट्स का उपयोग करके allऔर <2हालांकि उन्हें नहीं बचा सकते हैं ?

— विंसेंट

4

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

तर्क के रूप में अजगर बाइट्स का उपयोग करना:

lambda s:all(sum(c%96%x<1for c in s)<2for x in range(2,24))

जाँच करने वाला अंतिम विभाजक २३ है, जो २६ से नीचे का सबसे बड़ा प्रधान है।

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

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

— विंसेंट
स्रोत

3

c%96%x<1for c in s2 बाइट्स बचाता है।

— डेनिस

4

पर्ल 6 , 34 32 बाइट्स

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

{[lcm](@_)==[*] @_}o{.ords X-96}

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

एक अनाम कोडब्लॉक जो एक स्ट्रिंग लेता है और ट्रू या गलत लौटाता है। यदि अक्षरों के सबसे आम कई अक्षर अक्षरों के उत्पाद के बराबर हैं, तो वे साझा नहीं करते हैं।

स्पष्टीकरण:

                     {.ords X-96}  # Convert the letters to a list of numbers
 {                 }o              # Pass result to the next codeblock
  [lcm](@_)           # The list reduced by the lcm
           ==         # Is equal to?
             [*] @_   # The list reduced by multiplication

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

अगर मैं गलत नहीं हूँ, यह काम करता है ? (21 बाइट्स)

— कॉनर ओ'ब्रायन

@ ConorO'Brien नहीं, आपने सिर्फ lol के aलिए मैप किया है0

— Jo King

@ जोकिंग ओह, ओके लोल

— कॉनर ओ'ब्रायन

यह रणनीति छोटी गाड़ी थी, टेस्ट केस day:।

— अर्जन जोहान्सन

1

32 बाइट्स

— nwellnhof

3

जे, 36 बाइट्स

[:(1 =[:*/-.@=@i.@##&,+./~)_96+a.&i.

Ungolfed

[: (1 = [: */ -.@=@i.@# #&, +./~) _96 + a.&i.

व्याख्या

[: (                            ) _96 + a.&i.  NB. apply fn in parens to result of right
                                  _96 + a.&i.  NB. index within J's ascii alphabet, minus 96.
                                               NB. gives index within english alphabet
   (1 =                         )              NB. does 1 equal...
   (    [: */                   )              NB. the product of...
   (                    #&,     )              NB. Flatten the left and right args, and then copy
   (                        +./~)              NB. right arg = a table of cross product GCDs
   (          -.@=@i.@#         )              NB. the complement of the identity matrix.
                                               NB. this removes the diagonal.

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

— जोनाह
स्रोत

[:(1=[:*/+./~#&,~#\~:/#\)_96+a.&i.के लिए 34 बाइट्स आप में `1 = ':) एक जगह थी

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

1

धन्यवाद @GalenIvanov

— योना

3

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

f=(s,v=23)=>n=v<2||f(s,v-1)&&Buffer(s).every(c=>c%32%v||n--)

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

के विचार का प्रयोग Bufferसे Shieru Asakoto के पद ।
अरनौल को धन्यवाद , 5 बाइट्स बचाए।

— TSH
स्रोत

पुनरावर्ती और उपयोग करके 62 बाइट्सevery(c=>c%32%v||n--,n=1) ।

— अरनुलद

@ अरनुलद धन्यवाद और मैंने इसमें से 2 और बाइट्स को गोल किया।

— tsh

3

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

ŒcO_96g/€ỊẠ

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

मेरे बूलियन को नोट करने के लिए डेनिस का धन्यवाद

ŒcO_96g/€ỊẠ
Œc           All pairs of characters without replacement
  O          Code point of each character
   _96       Subtract 96. a->1, b->2, etc.
        €    For each pair:
      g/       Get the greatest common denominator
         Ị   abs(z)<=1? If they are all 1 then this will give a list of 1s
          Ạ  "All". Gives 1 if they are coprime, 0 if not.

— dylnan
स्रोत

2

ỊẠबूलियन्स flips।

— डेनिस

3

MATL , 10 बाइट्स

96-YF&fdA&

आउटपुट 1 लिए , 0अन्यथा।

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

व्याख्या

'man'उदाहरण के लिए इनपुट पर विचार करें ।

96-  % Implicit input: string. Subtract 96 from (the codepoint of) each element
     % STACK: [13 1 14] 
YF   % Exponents of prime factoriation. Each number produces a row in the result
     % STACK: [0 0 0 0 0 1;
               0 0 0 0 0 0;
               1 0 0 1 0 0]
&f   % Two-output find: pushes row and column indices of nonzeros
     % STACK: [3; 3; 1], [1; 4; 6]
d    % Consecutive differences
     % STACK: [3; 3; 1], [3; 2]
A    % All: gives true if the array doesn't contain zeros
     % STACK: [3; 3; 1], 1
&    % Alternative in/out specification: the next function, which is implicit
     % display, will only take 1 input. So only the top of the stack is shown

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

3

मार्कोव एल्गोरिथ्म, ईमेन द्वारा व्याख्या की गई ( 474 484 463 बाइट्स, 76 78 76 नियम)

a->
d->b
f->bc
h->b
i->c
j->be
l->bc
n->bg
o->ce
p->b
q->q
r->bc
t->be
u->cg
v->bk
x->bc
y->e
z->bm
cb->bc
eb->be
gb->bg
kb->bk
mb->bm
qb->bq
sb->bs
wb->bw
ec->ce
gc->cg
kc->ck
mc->cm
qc->cq
sc->cs
wc->cw
ge->eg
ke->ek
me->em
qe->eq
se->es
we->ew
kg->gk
mg->gm
qg->gq
sg->gs
wg->gw
mk->km
qk->kq
sk->ks
wk->kw
qm->mq
sm->ms
wm->mw
sq->qs
wq->qw
ws->sw
bb->F
cc->F
ee->F
gg->F
kk->F
mm->F
qq->F
ss->F
ww->F
b->
c->
e->
g->
k->
m->
q->
s->
w->
FF->F
TF->F
!->.
->!T

पहले 17 नियम "समग्र पत्र" को उनके "प्रमुख पत्र" कारकों में गुणन की अनदेखी करते हुए कारक बनाते हैं। (जैसे, 2 की शक्ति और 5. की शक्ति के उत्पाद के रूप में 20 कारक tबन जाता है be)

अगले 36 नियम (जैसे cb->bc) परिणामी प्रमुख कारकों को क्रमबद्ध करते हैं।

अगले 9 नियम (जैसे bb->F) बार-बार होने वाले प्राइम फैक्टर को बदलते हैं F, फिर 9 और नियम (जैसे)b-> ) शेष एकल अक्षरों से छुटकारा दिलाते हैं।

इस बिंदु पर, हमारे पास या तो एक खाली स्ट्रिंग है, या एक या अधिक Fएस का एक स्ट्रिंग है , और अंतिम नियम शुरुआत में ->!Tजोड़ता है !T। तो फिर नियम FF->Fऔर TF->Fया तो परिणाम को आसान बनाने !Tया !F। इस बिंदु पर, !->.नियम लागू होता है, जिससे हमें छुटकारा पाने !और रुकने के लिए कहा जाता है: Tएक कोप्राइम शब्द के लिए वापसी , औरF अन्यथा।

(पूर्ववर्ती संस्करण में बग को इंगित करने के लिए bodqhrohro के लिए धन्यवाद जिसने इस कोड को इनपुट के लिए एक रिक्त स्ट्रिंग देने का कारण बना a।)

— मिशा लावरोव
स्रोत

1

देता है न Tहै और न ही Fपर atestcase।

— bodqhrohro

@bodqhrohro पकड़ने के लिए धन्यवाद! (अंत में, मेरी बाइट की गिनती कम हो गई, क्योंकि मुझे एहसास हुआ कि मैं हर नई पंक्ति को दो बाइट्स के रूप में गिन रहा हूं।)

— मिशा लावरोव

2

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

संख्यावाचक द्वारा -1 बाइट

f=lambda q,*s:s==()or all(math.gcd(ord(q)-96,ord(w)-96)<2for w in s)and f(*s)
import math

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

के रूप में उपयोग करें f(*'man')।

— bubbler
स्रोत

2

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


;
{`\w
#$&
}T`l`_l
M`;(##+)\1*;(#*;)*\1+;
^0

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

प्रारंभ और अंत में प्रत्येक अक्षर के बीच विभाजक डालें।

{`\w
#$&

प्रेप ए #प्रत्येक पत्र के लिए करना।

}T`l`_l

प्रत्येक अक्षर 1 को वर्णमाला में वापस ले जाएं, को हटा रहा है a । फिर उपरोक्त कार्यों को तब तक दोहराएं जब तक कि सभी अक्षर हटा नहीं दिए जाते। यह प्रत्येक अक्षर को 1-आधारित वर्णमाला सूचकांक में एकीकृत करता है।

M`;(##+)\1*;(#*;)*\1+;

परीक्षण करें कि क्या कोई भी दो मान एक सामान्य कारक को 1 से अधिक साझा करते हैं (यह एक सामान्य कारक के साथ एक से अधिक अक्षरों की जोड़ी पा सकते हैं, जैसे शब्द में yearling ।)

^0

जांचें कि कोई सामान्य कारक नहीं पाए गए।

— नील
स्रोत

2

आर + पर्कमा लाइब्रेरी, 75 बाइट्स

function(w){s=utf8ToInt(w)-96;all(apply(outer(s,s,pracma::gcd),1,prod)==s)}

मैं का उपयोग कर रहा हूँ gcd फ़ंक्शनpracma पुस्तकालय क्योंकि मेरे ज्ञान में आर के लिए एक अंतर्निहित नहीं है। मैं gcds के उत्पाद की संख्या से तुलना करने के दृष्टिकोण का उपयोग कर रहा हूँ।

65 बाइट्स (क्रेडिट: @ जे। डो)

function(w)prod(outer(s<-utf8ToInt(w)-96,s,pracma::gcd))==prod(s)

— जेएलडी
स्रोत

1

जाप , 14 बाइट्स

;à2 e_®nR+CÃrj

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

वर्णों के एक सरणी के रूप में इनपुट लेता है।

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

;à2 e_m_nR+C} rj
;                 Use alternative predefined variables (in this case, C = "a-z")
 à2               Get all pairs
    e_            Does all pairs satisfy that...
      m_            when the character pair is mapped over...
        nR+C}         conversion from "a-z" to [1..26]
              rj    then the two numbers are coprime?

— bubbler
स्रोत

1

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

->s{s.bytes.combination(2).all?{|a,b|2>(a-96).gcd(a-b)}}

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

— जीबी
स्रोत

1

जावा 10, 86 बाइट्स

a->{var r=1>0;for(int i=1,s=0;++i<24;r&=s<2,s=0)for(var c:a)s+=c%96%i<1?1:0;return r;}

@Vincent का पोर्ट पायथन 3 उत्तर ।

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

स्पष्टीकरण:

a->{                 // Method with character-array parameter and boolean return-type
  var r=1>0;         //  Result-boolean, starting at true
  for(int s=0,       //  Sum integer, starting at 0
      i=1;++i<24     //  Loop `i` in the range (1, 24)
      ;              //    After every iteration:
       r&=s<2,       //     If the sum is >= 2: change the result to false
       s=0)          //     And reset the sum to 0
     for(var c:a)    //   Inner loop over the input-characters
       s+=c%96%i<1?  //    If the current character modulo-96 is divisible by `i`
           1         //     Increase the sum by 1
          :          //    Else
           0;        //     Leave the sum the same
  return r;}         //  Return the result-boolean

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

1

जाप, 13 बाइट्स

एक चरित्र सरणी के रूप में इनपुट लेता है।

®c uHÃà2 e_rj

इसे आज़माएँ या सभी परीक्षण मामलों को सत्यापित करें

— झबरा
स्रोत

0

क्यू, 121 111 बाइट्स

{$[1=count x;1b;1b=distinct{r:{l:{$[0~y;:x;.z.s[y;x mod y]]}[y;]'[x];2>count l where l<>1}[x;]'[x]}[1+.Q.a?x]]}

— Thaufeki
स्रोत

0

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

a=>!/\b(11+)\1* (1+ )*\1+\b/.exec(Buffer(a).map(x=>w+=" ".padEnd(x-95,1),w="")&&w)

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

मूल दृष्टिकोण (87B)

a=>!(b=Buffer(a)).some((x,i)=>b.some((y,j)=>i-j&&(g=(p,q)=>q?g(q,p%q):p)(x-96,y-96)>1))

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

— शायरु असकोतो
स्रोत

0

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

è'B╕i4à!ùà╫æor4Z

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

व्याख्या

2S{M{$e96-mm{E:!m|A     #Full program, unpacked, implicit input
2S                      #Generate all combinations of size 2
  {       m             #Map for each element
   M                    #Split into size of 1 element
    {       m           #Map for each element
     $e                 #Convert to number
       96-              #Subtract 96
           {    m       #Map for each element
            E:!         #Explode array onto stack, are they coprime
                 |A     #Are all elements of array truthy

सत्य के लिए आउटपुट 1, असत्य के लिए 0।

संख्या भाग में परिवर्तित करने के लिए एक बेहतर तरीका है, लेकिन यह काम करता है।

— मल्टी
स्रोत

यहाँ के लेखक। एक कोशिश देने के लिए धन्यवाद! यहां आपके एल्गोरिथ्म का उपयोग करने वाला एक कार्यक्रम है जो 10 बाइट्स पर पैक करता है। 2SOF{96-F:!* यदि आप इसके बारे में अधिक जानना चाहते हैं तो मुझे बताएं। पहले एक स्वतंत्र है!

— पुनरावर्ती

@recursive स्टैक्स बनाने के लिए धन्यवाद! यह इस समय मेरी पसंद की गोल्फ भाषा है। मैं देख सकता हूं कि आपका उत्तर कैसे काम करता है और मुझे भविष्य में अपने उत्तरों को बेहतर बनाने के लिए काम करते रहना होगा।

— मल्टी

0

एपीएल (एनएआरएस), 16 चार्ट, 32 बाइट्स

{(×/p)=∧/p←⎕a⍳⍵}

यह प्रयोग विधि अन्य प्रयोग किया जाता है कि LCM () = × /, यह तेज है लेकिन अतिप्रवाह यदि इनपुट सरणी पर्याप्त लंबी है; अन्य वैकल्पिक समाधान थोड़ा धीमा:

{1=×/y∨y÷⍨×/y←⎕a⍳⍵} 
{1=≢,⍵:1⋄1=×/{(2⌷⍵)∨1⌷⍵}¨{x←97-⍨⎕AV⍳⍵⋄(,x∘.,x)∼⍦x,¨x}⍵}

यह नीचे दिए गए कार्यों की तुलना में 10 गुना तेज (या +) लगता है

∇r←h m;i;j;k;v
   r←i←1⋄k←≢v←97-⍨⎕AV⍳m
A: →F×⍳i>k⋄j←i+1⋄→C
B:   →E×⍳1≠(j⌷v)∨i⌷v⋄j←j+1
C:   →B×⍳j≤k
D: i←i+1⋄→A
E: r←0
F:
∇

मैं इसे अंतिम पसंद करता हूं क्योंकि यह आसान, तेज, विश्वसनीय है (कम ओवरफ़्लो possiblity के कारण), लिखने में आसान है, और यह कैसे होना है (भले ही यह कुछ बाइट्स अधिक हो ...)

— RosLuP
स्रोत

क्या शब्द कोप्राइम है?

वोल्फ्राम भाषा (गणितज्ञ) , 36 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 33 बाइट्स

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

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

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

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

पायथन 2 - 122 118 बाइट्स

05AB1E , 11 बाइट्स

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

व्याख्या

पायथन 2 , 77 68 64 बाइट्स

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

पर्ल 6 , 34 32 बाइट्स

स्पष्टीकरण:

जे, 36 बाइट्स

Ungolfed

व्याख्या

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

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

MATL , 10 बाइट्स

व्याख्या

मार्कोव एल्गोरिथ्म, ईमेन द्वारा व्याख्या की गई ( 474 484 463 बाइट्स, 76 78 76 नियम)

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

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

आर + पर्कमा लाइब्रेरी, 75 बाइट्स

65 बाइट्स (क्रेडिट: @ जे। डो)

जाप , 14 बाइट्स

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

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

जावा 10, 86 बाइट्स

जाप, 13 बाइट्स

क्यू, 121 111 बाइट्स

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

मूल दृष्टिकोण (87B)

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

एपीएल (एनएआरएस), 16 चार्ट, 32 बाइट्स