31

एक प्रोग्राम या समारोह है कि वर्णों की स्ट्रिंग में लेता लिखें -=o.जहां -=oकी और .हमेशा वैकल्पिक, चरित्र के चरित्र है। स्ट्रिंग में एक से अधिक एक विषम लंबाई होगी और हमेशा एक में शुरू और अंत होगा -=o।

मूल रूप से, इनपुट इमोटिकॉन चेहरों की एक पंक्ति की तरह दिखेगा जो नींद की विभिन्न अवस्थाओं में आँखें साझा करते हैं, जैसे

o.=.=.-.-.o.o

आपका लक्ष्य उस चेहरे को प्रिंट करना या वापस करना है जो या तो सबसे नींद वाला है या सबसे जागृत (यह आपके ऊपर है जिसे आप चुनते हैं)। यदि नींद लेने वाले / सबसे जागने वाले कई विकल्प हैं, तो उनमें से कोई भी आउटपुट हो सकता है।

नौ अलग-अलग चेहरे और नींद के पांच स्तर हैं:

-.- is 100% sleepy
-.= is 75% sleepy
-.o is 50% sleepy
=.- is 75% sleepy
=.= is 50% sleepy
=.o is 25% sleepy
o.- is 50% sleepy
o.= is 25% sleepy
o.o is 0% sleepy

मामले में यह स्पष्ट नहीं है, तंद्रा प्रतिशत बताए द्वारा गणना की जाती है 1करने के लिए -पूरी तरह से सो के लिए, 0.5करने के लिए =आधा सो के लिए, और 0करने के लिए oजाग लिए। फिर दो नेत्र मूल्यों को दो से विभाजित करने का योग प्रतिशत है।

बाइट्स में सबसे छोटा कोड जीतता है।

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

sleepiest

-.- GIVES -.-
=.- GIVES =.-
o.o GIVES o.o
o.-.= GIVES -.=
=.-.= GIVES =.- OR -.=
o.-.= GIVES -.=
-.-.= GIVES -.-
o.o.- GIVES o.-
=.=.=.o GIVES =.=
-.=.=.= GIVES -.=
=.o.-.= GIVES -.=
o.-.o.=.= GIVES o.- OR -.o OR =.=
-.o.-.=.= GIVES -.=
o.o.o.o.o GIVES o.o
-.-.-.-.- GIVES -.-
o.=.=.-.-.o.o GIVES -.-
-.=.-.o.o.=.o.-.o.=.-.o.=.o.- GIVES -.= OR =.-

सर्वाधिक जागृत

-.- GIVES -.-
=.- GIVES =.-
o.o GIVES o.o
o.-.= GIVES o.-
=.-.= GIVES =.- OR -.=
o.-.= GIVES o.-
-.-.= GIVES -.=
o.o.- GIVES o.o
=.=.=.o GIVES =.o
-.=.=.= GIVES =.=
=.o.-.= GIVES =.o
o.-.o.=.= GIVES o.=
-.o.-.=.= GIVES -.o OR o.- OR =.=
o.o.o.o.o GIVES o.o
-.-.-.-.- GIVES -.-
o.=.=.-.-.o.o GIVES o.o
-.=.-.o.o.=.o.-.o.=.-.o.=.o.- GIVES o.o

code-golf string

— केल्विन के शौक
स्रोत

31

मुझे लग रहा है-.-

— कृति लिथोस

28

पायथ, 12 10 बाइट्स

hoSN%2.:z3

यह नींद के इमोटिकॉन को प्रिंट करता है। पायथ कंपाइलर में एक बार में सभी परीक्षण मामलों की जाँच करें ।

सॉर्टिंग का उपयोग करने के विचार के लिए क्रेडिट @ Sp3000 पर जाता है ।

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

hoSN%2.:z3
              (implicit) Save the in z.
      .:z3    Compute all substrings of length 3.
    %2        Keep every seconds substring. This discards non-emoticons.
 o            Sort the emoticons by the following key:
  SN            Sort the characters of the emoticon.
                This works since '-' < '=' < 'o'.
h             Retrieve the first, minimal element.

— डेनिस
स्रोत

18

ये क्या जादू है?!

— 5

@ डेनिस मैं पर्थ में नया हूं इसलिए यह गलत हो सकता है: क्यों नहीं hS%2.:z3?

— हेलिक्स क्वार

5

@helix क्योंकि हम =.-स्लीपियर होना चाहते हैं -.o, लेकिन वे दूसरे तरीके से हल कर रहे हैं। मैंने वही गलती की थी।

— xnor

9

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

f=lambda s:s and max((s+' ')[:3],f(s[2:]),key=sorted)

यह एक ऐसा फंक्शन है जो सबसे ज्यादा जागता है।

मेरे मूल एल्गोरिथ्म को छोटा करने के लिए कई सामरिक चाल प्रदान करने के लिए बहुत धन्यवाद xnor।

— xsot
स्रोत

खैर, मुझे लगता है कि मूर्खता का अहसास नहीं होता कि प्रतीकों को जागृत किया जाता है। मुझे लगता है कि आप maxइसके माध्यम से पुनरावृत्ति करने के बजाए पुनरावृत्ति कर सकते हैं :f=lambda s:s[3:]and max(s[:3],f(s[2:]))or s

— xnor

वास्तव में, मुझे लगता है कि यह काम नहीं करता है =.-.o, क्योंकि =.-बनाम -.oसॉर्ट नियम का अपवाद है।

— xnor

वास्तव में, मुझे सिर्फ यह महसूस हुआ कि मैंने सेशन को गलत बताया है। मैंने सोचा था कि जैसे ही वे तालिका में दिखाई देते हैं चेहरों को क्रमबद्ध किया जाता है। इस धारणा के कारण मेरा प्रस्तुतिकरण "= .o.-" के लिए विफल हो जाता है। मुझे लगता है कि मेरे पास एक सुधार है।

— xsot

@xsot मेरा मानना है ,key=sortedकि एक समाधान होगा, लेकिन यह 11 वर्ण है तो आपका शायद छोटा है।

— xnor

हाँ, यह तय है कि मेरे मन में था

— xsot

6

CJam, 12 बाइट्स

q3ew2%{$}$0=

यह नींद के इमोटिकॉन को प्रिंट करता है। CJam दुभाषिया में इस फिडेल या इस परीक्षण सूट की कोशिश करें ।

सॉर्टिंग का उपयोग करने के विचार के लिए क्रेडिट @ Sp3000 पर जाता है ।

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

q            e# Read all input from STDIN.
 3ew         e# Push all overlapping slices of length 3.
    2%       e# Keep every seconds slice. This discards non-emoticons.
      {$}$   e# Sort the slices by their sorted characters.
             e# This works since '-' < '=' < 'o'.
          0= e# Retrieve the first, minimal slice.

— डेनिस
स्रोत

4

दिल्लोग एपीएल, 35 28 बाइट्स

{⊃{⍵[⍒{+/'.??o='⍳⍵}¨⍵]}3,/⍵}

यह एक राक्षसी कार्य है जो दाईं ओर स्ट्रिंग लेता है और स्लीपस्ट फेस को आउटपुट करता है।

    {⊃{⍵[⍒{+/'.??o='⍳⍵}¨⍵]}3,/⍵}'o.=.=.-.-.o.o'
-.-

— lirtosiast
स्रोत

{(⊃⍒3+/'.??o='⍳⍵)⊃3,/⍵}

— user46915

और इनपुट बाधाओं को देखते हुए, ??यह भी अनावश्यक है।

— user46915

4

प्रोलॉग, 205 189 बाइट्स

कोड

r([X|T],[N|B],M):-N=M,write(X);r(T,B,M).
p(X):-findall(S,sub_atom(X,_,3,_,S),L),findall(E,(nth1(I,L,E),I mod 2=\=0),R),maplist(atom_codes,R,Q),maplist(sum_list,Q,S),min_list(S,M),r(R,S,M).

व्याख्या

r([X|T],[N|B],M):-N=M,write(X);r(T,B,M).
p(X):-findall(S,sub_atom(X,_,3,_,S),L),              % L = all sublists of length 3
      findall(E,(nth1(I,L,E),I mod 2=\=0),R),        % R = every other element of L
      maplist(atom_codes,R,Q),                       % Q = list of decimal ascii codes 
                                                           created from R

      maplist(sum_list,Q,S),                         % S = list of sums of R's lists
      min_list(S,M),                                 % M = minimum sum
      r(R,S,M).                                      % Prints first element in R with sum M

उदाहरण

>p('-.=.-.o.o.=.o.-.o.=.-.o.=.o.-').
-.=

संपादित करें: OR के साथ r-clauses को एकीकृत करके 16 बाइट्स सहेजे गए।

— Emigna
स्रोत

1

क्लोजर, 82 बाइट्स

(fn[x](println(apply str(apply min-key #(reduce +(map int %))(partition 3 2 x)))))

बोनस: निम्नलिखित छोटा कार्य एक ही चेहरे को प्रिंट करता है, लेकिन अधिक शैली के साथ!

(fn[x](println(apply min-key #(reduce +(map int %))(partition 3 2 x))))

यहाँ परीक्षण करें।

— galdre
स्रोत

1

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

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

f=->(s){s.split(?.).each_cons(2).min_by{|e|e.sort}.join(?.)}

इस तरह कहा जाता है:

f.call("o.=.=.-.-.o.o")
# => "-.-"

आंतरिक प्रकार की आंखों के कारण अजीब आंख के आदेश पर काम करता है:

f.call("=.-.o")
# => "=.-"

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

1

मिन्कोलांग 0.12 , 119 बाइट्स

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

>2@fv$oI2:[9[i$z3[iciz1+q=]++3=tt"^"3zpt]$x$x]IX3140w
o.o1F
o.=1$
=.o1+
=.=12
o.-1:
-.o11
=.-1+
-.=13
-.-1[
/c0i<
\qO].

यहाँ कोशिश करो!

व्याख्या

लेकिन वास्तव में, ऊपर दिए गए लिंक पर क्लिक करें और क्लिक करें Slow! वैसे भी ...

>2@fv

इस पर काबू पा लिया गया fv, जो बाद में महत्वपूर्ण होगा।

$o                                                  Read in whole input as characters 
  I2:                                               Half the stack length
     [                                              Open for loop (for each face)
      9[                                            Open another for loop - 9 repeats
        i$z                                         Stores loop counter in register
           3[                                       Open another for loop - 3 repeats
             ic                                     Copy char 1/2/3
               iz1+q                                Retrieve char from lookup table
                    =                               1 if equal, 0 otherwise
                     ]                              Close for loop
                      ++                            Add twice
                        3=                          1 if equal to 3, 0 otherwise
                          tt      t                 Ternary - executes first part when 0,
                                                    second part otherwise
                            "^"3zp                  Put a ^ next to the face that matched
                                   ]                Close lookup for loop
                                    $x$x            Dump first two characters
                                        ]           Close for loop
                                         IX         Dump the whole stack
                                           31       Push a 3, then a 1
                                             40w    Wormhole to (4,0) in the code

जो कुछ भी हुआ वह उन सभी ^चेहरों के साथ था जो मेल खाते थे। तो अब कोडबॉक्स कुछ इस तरह दिख सकता है:

>2@fv$oI2:[9[i$z3[iciz1+q=]++3=tt"^"3zpt]$x$x]IX3140w
o.o1F
o.=1$
=.o1+
=.=^2   <-- caret
o.-^:   <-- caret
-.o11
=.-1+
-.=^3   <-- caret
-.-1[
/c0i<
\qO].

टिप्पणियों के बिना, बिल्कुल। अब, 40wवर्महोल ने निर्देश सूचक को भेजा v, जो तुरंत उस पर पुनर्निर्देशित करता है F। अब, F"गोसुब" कमांड है। यह एक गोटो की तरह है, लेकिन आप इसे वापस उसी स्थान पर ले जा सकते हैं जहां आपने इसे बुलाया था। समय Fआने पर, स्टैक होता है [3,1], इसलिए यह 1दूसरी पंक्ति में (शायद) कूदता है । जैसे-जैसे कार्यक्रम काउंटर नीचे की ओर बढ़ रहा था, वैसे ही यह जारी है, 1रास्ते में स्टैक पर धकेल रहा है । यही है ... जब तक यह एक हिट नहीं करता है ^, तो यह किस बिंदु पर पुनर्निर्देशित होता है, जहां यह प्रत्येक को 1फिर से धक्का देता है । निर्देश सूचक तब हिट fकरता है, जो अपनी स्थिति और दिशा को पुनर्स्थापित करता है (जब Fपहले सामना किया गया था)। सुविधा के लिए, मैं निम्नलिखित कोड लूंगा और इसका लेआउट बदलूंगा। (</\ आवश्यकतानुसार निर्देश सूचक को पुनर्निर्देशित करें।)

$+                 Sum up the whole stack
  2:               Divide by 2 (because each 1 was pushed twice)
    1+             Add 1 (shift down one row)
      3[           Open for loop - 3 repeats
        i          Push loop counter
         0c        Copy top of stack
           q       Retrieve face character
            O      Output as character
             ].    Close for loop and stop when it's done.

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

— एलेंडिया स्ट्राटन
स्रोत

1

सी, 70 बाइट्स

char*f(char*s){char*p=s[3]?f(s+2):s;return*s+s[2]>*p+p[2]?s[3]=0,s:p;}

फ़ंक्शन सबसे जागृत चेहरा लौटाता है। यह जगह में इनपुट स्ट्रिंग को संशोधित करता है, ताकि अशक्त-समाप्त स्ट्रिंग वापस आ सके।

— हान
स्रोत

1

पायथन 2/3, 54 56 बाइट्स

lambda x:".".join(max(zip(x[::2],x[2::2]),key=sorted))

बस xsot के पुनरावर्ती उत्तर के लिए एक वैकल्पिक शुल्क लेना चाहता था।

यह आंखों के आस-पास के जोड़े का सबसे अच्छा (या सबसे बुरा?) ले लेता है और उन्हें एक साथ जोड़ देता है।

अधिकतम नींद को वापस लाने के लिए अधिकतम के साथ बदलें (जैसा कि यह सबसे जागृत है)

निम्नलिखित परीक्षण का उपयोग करके काम करने लगता है:

for line in """-.- GIVES -.-
    =.- GIVES =.-
    o.o GIVES o.o
    o.-.= GIVES o.-
    =.-.= GIVES =.- OR -.=
    o.-.= GIVES o.-
    -.-.= GIVES -.=
    o.o.- GIVES o.o
    =.=.=.o GIVES =.o
    -.=.=.= GIVES =.=
    =.o.-.= GIVES =.o
    o.-.o.=.= GIVES o.=
    -.o.-.=.= GIVES -.o OR o.- OR =.=
    o.o.o.o.o GIVES o.o
    -.-.-.-.- GIVES -.-
    o.=.=.-.-.o.o GIVES o.o
    -.=.-.o.o.=.o.-.o.=.-.o.=.o.- GIVES o.o""".splitlines():
    inp, _, opts = line.partition(" GIVES ")
    optst = opts.split(" OR ")
    act = f(inp)
    print(inp, "expected", opts, "got", act, "equal?", act in optst)

जो निम्नलिखित परिणाम देता है:

-.- expected -.- got -.- equal? True
=.- expected =.- got =.- equal? True
o.o expected o.o got o.o equal? True
o.-.= expected o.- got o.- equal? True
=.-.= expected =.- OR -.= got =.- equal? True
o.-.= expected o.- got o.- equal? True
-.-.= expected -.= got -.= equal? True
o.o.- expected o.o got o.o equal? True
=.=.=.o expected =.o got =.o equal? True
-.=.=.= expected =.= got =.= equal? True
=.o.-.= expected =.o got =.o equal? True
o.-.o.=.= expected o.= got o.= equal? True
-.o.-.=.= expected -.o OR o.- OR =.= got =.= equal? True
o.o.o.o.o expected o.o got o.o equal? True
-.-.-.-.- expected -.- got -.- equal? True
o.=.=.-.-.o.o expected o.o got o.o equal? True
-.=.-.o.o.=.o.-.o.=.-.o.=.o.- expected o.o got o.o equal? True

— TLW
स्रोत

दो त्वरित प्रश्न: 1) पायथन 2/3 के रूप में लेबल कर रहा है जब दोनों की सिफारिश के साथ कुछ काम करता है? 2) क्या f=इस चुनौती के लिए कोड आकार के हिस्से के रूप में आवश्यक है? अगर मैं ऐसा नहीं करता हूं तो यह लंबोदर पैदा करेगा और फिर तुरंत इसे फिर से फेंक देगा ...

— TLW

1

1) "अजगर 2/3" या बस "अजगर" ठीक मुझे लगता है कि 2) यदि आप नहीं है, तो है की जरूरत हैf= , तो वर्तमान में आम सहमति है कि अनाम प्रक्रियाएं डिफ़ॉल्ट रूप से ठीक हैं लगता है तो आप छोड़ सकते हैं f=इस मामले में ( पुनरावृत्ति के बाद से xsot की जरूरत है)

— Sp3000

1

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

s₃ᶠġ₂hᵐoᵒh

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

डेनिस के पाइथ उत्तर से अनुवादित।

— असंबंधित स्ट्रिंग
स्रोत

0

गणितज्ञ, 61 बाइट्स

"."
Sort[Partition[#~StringSplit~%,2,1]][[1]]~StringRiffle~%&

नींद के लिए एक जाता है।

— LegionMammal978
स्रोत

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

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

0

एफ # 60

fun s->Seq.max[for n in 0..2..String.length s-2->s.[n..n+2]]

रिटर्न सबसे जाग चेहरा (परिवर्तन maxद्वारा minsleepest के लिए)

— Sehnsucht
स्रोत

0

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

%h=qw[- 2 = 1];sub r{$b=0;$b+=$h{$_}for split'',pop;$b}($_)=<>;@a='o.o';while(/.../g){push@a,$& if(r$&)>r$a[-1];--pos}say$a[-1]

(मुझे यकीन है कि यह अधिक संक्षेप में उल्लेखनीय है।) यह कैसे काम करता है:

स्ट्रिंग से प्रत्येक तीन-वर्ण स्ट्रिंग को पकड़ो, एक से ओवरलैप के साथ (यह वही है जो --posकरता है)।
उस तीन-वर्ण स्ट्रिंग को एक सरणी में जोड़ें यदि इसका मान सरणी के अंतिम तत्व से अधिक है; यहाँ, "मूल्य" नींद में इसके पात्रों के मूल्यों का योग है।
सरणी के अंतिम तत्व को प्रिंट करें।

— msh210
स्रोत

0

ईएस 6, 81 72 बाइट्स

a=>"-.-,-.=,=.-,-.o,=.=,o.-,=.o,o.=,o.o".split`,`.find(b=>a.includes(b))

संभवतः Chrome 45 या फ़ायरफ़ॉक्स 41 की आवश्यकता है।

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

— नील
स्रोत

1

अच्छा है, लेकिन "=.-"इसके साथ स्विच किया जाना चाहिए "-.o"; उसी के साथ "=.o"और "o.-"। इसके अलावा, आप कुछ बाइट्स को एक स्ट्रिंग में सब कुछ डालकर, कॉमा द्वारा अलग करके और उपयोग करके सहेज सकते हैं .split`,` ।

— ETHproductions

विभाजन का उपयोग कर 9

— चार्ट

@ETHproductions क्षमा करें मैंने ध्यान नहीं दिया कि चेहरों की मूल सूची तंद्रा के क्रम में ही नहीं थी।

— नील

0

> <> , 55 बाइट्स

यहाँ कोशिश करो!

<v~i:i&0"."0
 >i:@+:&:@)?v&~i0(?v
 ^?)0i:r~r&~<;ooo$r<

आउटपुट सबसे जागृत चेहरा है।

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

— torcado
स्रोत

0

पर्ल 5 `-MList::Util=max -p` , 68 बाइट्स

s|..(?=(.))|$t=max$t,ord($&)%15%4+ord($1)%15%4 .$&.$1|eg;$_=$t;s/.//

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

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

— Xcali
स्रोत

इन सब में सबसे ज्यादा नींद किसे आती है?

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

पायथ, 12 10 बाइट्स

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

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

CJam, 12 बाइट्स

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

दिल्लोग एपीएल, 35 28 बाइट्स

प्रोलॉग, 205 189 बाइट्स

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

मिन्कोलांग 0.12 , 119 बाइट्स

व्याख्या

सी, 70 बाइट्स

पायथन 2/3, 54 56 बाइट्स

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

गणितज्ञ, 61 बाइट्स

एफ # 60

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

ईएस 6, 81 72 बाइट्स

> <> , 55 बाइट्स

पर्ल 5 -MList::Util=max -p , 68 बाइट्स

पर्ल 5 `-MList::Util=max -p` , 68 बाइट्स