Takewhile को लागू करें


30

परिचय और क्रेडिट

आज एक फैंसी प्रस्ताव के बिना: कृपया लागू करें takewhile

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

विशिष्टता

इनपुट

इनपुट सकारात्मक पूर्णांकों की एक सूची (या आपकी भाषा की समतुल्य अवधारणा) होगी।

उत्पादन

आउटपुट सकारात्मक पूर्णांकों की एक सूची (या आपकी भाषा की समतुल्य अवधारणा) होनी चाहिए।

क्या करें?

आपका कार्य takewhile(भाषा बिल्ट-इन की अनुमति है) को लागू करने के लिए विधेय के साथ माना जाता है कि विचाराधीन संख्या सम है (takewhile पर ध्यान केंद्रित करने के लिए)।

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

संभावित कोने के मामले

इनपुट सूची की तुलना में आउटपुट सूची का क्रम नहीं बदला जा सकता है, उदाहरण के लिए [14,42,2]नहीं बन सकता है [42,14]

खाली सूची एक मान्य- और आउटपुट है।

किसी जीत?

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

मानक नियम निश्चित रूप से लागू होते हैं।

परीक्षण क्षेत्र

[14, 42, 2324, 97090, 4080622, 171480372] -> [14, 42, 2324, 97090, 4080622, 171480372]
[42, 14, 42, 2324] -> [42, 14, 42, 2324]
[7,14,42] -> []
[] -> []
[171480372, 13, 14, 42] -> [171480372]
[42, 14, 42, 43, 41, 4080622, 171480372] -> [42, 14, 42]

चरण-दर-चरण उदाहरण

Example Input: [42, 14, 42, 43, 41, 4080622, 171480372]

Consider first element: 42
42 is even (21*2)
Put 42 into output list, output list is now [42]

Consider second element: 14
14 is even (7*2)
Put 14 into output list, output list is now [42,14]

Consider third element: 42
42 is even (21*2)
Put 42 into output list, output list is now [42,14,42]

Consider fourth element: 43
43 is not even (2*21+1)
Drop 43 and return the current output list

return [42,14,42]

2
क्या यह ठीक है अगर मैं एक सूची के बजाय एक पुनरावृत्त लौटाऊं?
DJMcMayhem

2
@DrGreenEggsandIronMan मैं अनुमान लगा रहा हूं कि आपका कार्य इसके आउटपुट को इनपुट के रूप में लेने में सक्षम है, गारंटी देता है कि वे एक ही प्रारूप में हैं।
mbomb007

@DrGreenEggsandIronMan, मुझे नहीं लगता है कि आउटपुट फॉर्मेट में यहाँ एक सबलिस्ट लौटाया जाना चाहिए। (यदि आप अपने कोड में इसका फायदा उठाते हैं तो भी यह आपके ऊपर है)। Mbomb की कसौटी वर्तमान चुनौती के साथ सबसे उपयुक्त और संगत लगती है, इसलिए यह "आपका आउटपुट बहुत कम से कम एक वैध इनपुट होना चाहिए"।
SEJPM

जवाबों:


28

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

#~TakeWhile~EvenQ&

एक और शानदार बिल्ट-इन बिना गोल्फ भाषाओं द्वारा 3 के एक कारक द्वारा पीटा गया है ...


3
माथेमैटिका कितने अंतर्निहित है? ऐसा लगता है जैसे यह लगभग किसी भी चीज के लिए एक है।
19ign पर Emigna

35
@Emigna मैंने नहीं गिना है, लेकिन इंटरनेट का नियम # 110 है, "अगर यह मौजूद है, तो इसके लिए एक गणितीय गणित निर्मित है।"
मार्टिन एंडर

3
@MartinEnder बहुत बुरा है कि इंटरनेट का नियम # 110.5 है, "अगर इसमें किसी भी तरह से तार शामिल हैं , तो यह नियम # 110 के प्रयोजनों के लिए मौजूद नहीं माना जाता है।"
लीजनमोनमाल 978

@ LegionMammal978 स्ट्रिंग्स को अभिव्यक्ति के प्रमुख बनाने के लिए है :)
LLlAMnYP

26

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

fst.span even

spanइनपुट सूची को पहले तत्व से ठीक पहले सूचियों की एक जोड़ी में विभाजित करता है जहां विधेय (-> even) गलत है। fstजोड़ी का पहला तत्व लेता है।

वैकल्पिक संस्करण, 13 बाइट्स:

fst.break odd

breakके विपरीत है span, यानी यह सूची को पहले तत्व पर विभाजित करता है जहां विधेय सत्य है।

बेशक वहाँ भी है

takeWhile even

लेकिन वह 14 बाइट्स है।


23

MATL , 6 बाइट्स

toYs~)

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

व्याख्या

t    % Input array implicitly. Duplicate
o    % Parity of each entry. Gives 0 for even entries, 1 for odd
Ys   % Cumulative sum
~    % Logical negate. Gives true for the first run of even entries, and then false
)    % Use this as logical index into the original array. Implicitly display

22
क्या यह सामान्य है, कि कोड मुस्कुराहट के साथ "खिलौने" कहता है?
SEJPM

3
@SEJPM to~Y<)भी काम करता है, लेकिन मुझे यह बेहतर लगता है :-)
लुइस मेंडू

13

Hexagony , 19

2.}<@>%?<{>$"/\M!8;

पठनीय:

  2 . }
 < @ > %
? < { > $
 " / \ M
  ! 8 ;

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

यह शायद एक बाइट या दो द्वारा गॉकेटेड हो सकता है, लेकिन इसके लिए कुछ सही मायने में सरल लेआउट की आवश्यकता हो सकती है, जो कि ब्रूट बल के माध्यम से आसानी से मिल सकता है (भले ही इसे खोजने में लंबा समय लग सकता है)।

उच्च स्तरीय व्याख्या

कार्यक्रम ज्यादातर इस छद्मकोड का अनुसरण करता है:

while (read number is not zero) 
{
    if (number is even) 
        print number;
} 

कौन सा दुरुपयोग करता है कि कैसे एक बार STDIN खाली होने पर हेक्सागोनी एक संख्या को पढ़ने की कोशिश करता है (यह एक शून्य देता है)। इस दृष्टिकोण के साथ आने में मदद के लिए मार्टिन का बड़ा धन्यवाद।

पूर्ण व्याख्या

मैं अभी भी टिमो की शानदार गूढ़ आईडीई पाने के लिए मोनो के साथ फिदा नहीं हुआ हूं हूं, इसलिए मैं मार्टिन पर कुछ उपयोगी सुंदर चित्रों के साथ प्रदान करने के लिए झुक गया हूं!

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

अब सशर्त के बारे में थोड़ा सा। नियंत्रण प्रवाह के लिए हेक्सागोनी में केवल सशर्त हैं >,< और हेक्सागोन के मध्य किनारे। ये सभी एक निरंतर नियम का पालन करते हैं: यदि वर्तमान मेमोरी एज पर मान शून्य है या नकारात्मक नियंत्रण प्रवाह बाईं ओर चलता है और यदि सकारात्मक है तो नियंत्रण प्रवाह सही है। ब्रैकेट की तुलना में अधिक और कम आईपी साठ डिग्री के कोण पर पुनर्निर्देशित करता है, जबकि हेक्सागोन के किनारे आईपी को किस पंक्ति में नियंत्रित करते हैं।

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

Mod  \ / Input
      |
      2

कार्यक्रम की व्याख्या के दौरान हम प्रत्येक बिंदु पर जहां हम स्मृति में हैं, ध्यान से बताने नहीं जा रहे हैं, इसलिए यदि आप स्मृति में हैं तो आप भ्रमित हो जाते हैं।

उस रास्ते से सभी के साथ, वास्तविक स्पष्टीकरण शुरू हो सकता है। सबसे पहले, हम 2 के साथ मेमोरी में "2" किनारे को आबाद करते हैं, फिर हम एक नो-ऑप को निष्पादित करते हैं और मेमोरी पॉइंटर को दाईं ओर ले जाते हैं ( 2.})।

अगला, हम मुख्य कार्यक्रम लूप शुरू करते हैं। हमने STDIN से पहला नंबर पढ़ा और फिर हमने एक सशर्त ( ?<) मारा । यदि एसटीडीआईएन में कोई संख्या शेष नहीं है, तो यह वर्तमान मेमोरी एज में एक शून्य पढ़ता है, इसलिए हम बाईं ओर मुड़ते हैं @, जो प्रोग्राम को समाप्त करता है। अन्यथा, हम एक दर्पण को उछाल देते हैं, मेमोरी पॉइंटर को पीछे की ओर ले जाते हैं और बाईं ओर, हेक्सागोन के चारों ओर लपेटते हैं ताकि इनपुट को 2 से विभाजित करने के शेष की गणना करें और फिर एक और सशर्त ( /"%>) मारा ।

विषम पथ

यदि शेष एक था (यानी संख्या विषम थी), हम नीले रास्ते का अनुसरण करते हुए ऊपर की ओर मुड़ते हैं और फिर से नो-ऑप को निष्पादित करके शुरू करते हैं, फिर हम षट्भुज के निचले भाग में लपेटते हैं, वर्तमान किनारे को 10 से गुणा करते हैं और फिर जोड़ते हैं आठ, एक जोड़े दर्पण से उछाल, एक ही गुणा और इसके अलावा फिर से करें, वर्तमान किनारे पर 188 प्राप्त करना, षट्भुज के शीर्ष पर वापस चारों ओर लपेटना, नो-ऑप को फिर से निष्पादित करना, और अंत में कार्यक्रम को समाप्त करना ( .8/\8.@)। यह परिणामी परिणाम एक सुखद दुर्घटना थी, मैंने मूल रूप से बहुत सरल तर्क लिखा था, लेकिन ध्यान दिया कि मैं इसे नो-ऑप के पक्ष में हटा सकता था, जो मुझे लगा कि हेक्सागोनी की भावना में अधिक था।

यहां तक ​​कि पथ

यदि शेष शून्य था, तो हम इसके बजाय लाल पथ के ऊपर, बाएँ मुड़ते हैं। यह हमें मेमोरी पॉइंटर को बाईं ओर ले जाने का कारण बनता है, और फिर वहां मूल्य (इनपुट मान) को एक संख्या के रूप में प्रिंट करता है। जिस दर्पण से हमारा सामना होता है, वह उस दिशा के कारण नो-ऑप के रूप में कार्य करता है, जो हम चल रहे हैं ({/! )। फिर हम षट्भुज के किनारे से टकराते हैं, जो केवल एक परिणाम के साथ एक सशर्त कार्य करता है, क्योंकि पहले से इनपुट मान सकारात्मक होने के लिए पहले से ही परीक्षण किया गया था, इसलिए हम हमेशा सही की ओर बढ़ते हैं (यदि आप खुद को आईपी की दिशा में सामना करने की कल्पना करते हैं) । हम 10 से कई इनपुट करते हैं और दो जोड़ते हैं, केवल दिशा बदलने के लिए, चारों ओर लपेटते हैं और कैपिटल लेटर M, 77 के एससीआई मूल्य के साथ नए मूल्य को ओवरवेट करते हैं। फिर हम कुछ दर्पणों को मारते हैं, और बीच के किनारे से बाहर निकलते हैं एक trampoline के साथ षट्भुज (2<M\>$)। चूंकि 77 सकारात्मक है, हम सही हेक्सागोन के नीचे की ओर बढ़ते हैं और ट्रम्पोलिन के कारण पहला निर्देश छोड़ते हैं ( !)। हम तब वर्तमान मेमोरी एज को 10 से गुणा करते हैं और 8 जोड़ते हैं, 778 हो रहे हैं। हम फिर एएससीआईआई कैरेक्टर के रूप में इस वैल्यू मॉड 256 (10) को आउटपुट करते हैं, जो न्यूलाइन होता है। अंत में हम षट्भुज से बाहर निकलते हैं और पहले के आसपास वापस लपेटते हैं ?जो अगले इनपुट मूल्य के साथ 778 से आगे निकल जाता है ।


8
पठनीय हाँ सही
टेलान

10

पायथ, 13 9 7 बाइट्स

uPWs%R2

@FryAmTheEggman को 2 (काफी मुश्किल) बाइट्स का श्रेय!

स्पष्टीकरण:

u       Q    keep applying to input until invariant:
 PW          drop last element if...
   s%R2G     ...any one is odd, G is the argument originally given the value of input

इसका परीक्षण यहां करें


1
यह बिल्कुल सही चर परिचय विवरण नहीं है। दो Gएस पेश किए जाने चाहिए , एक शर्त के लिए s%R2Gऔर एक फ़ंक्शन के तर्क के रूप में P
isaacg

9

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

Ḃœp⁸Ḣ

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

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

Ḃœp⁸Ḣ  Main link. Argument: A (array)

Ḃ      Bit; yield 1 for odd integers, 0 for even ones.
   ⁸   Yield A.
 œp    Partition A, splitting at 1's in the bit array.
       This yields a 2D array of runs of even integers.
    Ḣ  Head; extract the first chunk.

8

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

def f(x):
 while"1'"in`map(bin,x)`:x.pop()

फ़ंक्शन जगह में अपने तर्क को संशोधित करता है

@Xnor के लिए धन्यवाद एक बहुत चालाक तरीके से बाइट बंद करने के लिए!

Ideone पर इसका परीक्षण करें ।


4
यह पागल है, लेकिन मुझे लगता है कि आप "1'"in`map(bin,x)` पायथन 2 के लिए एक विषम तत्व की जांच कर सकते हैं
xnor

ये तो बहुत खूब है। धन्यवाद!
डेनिस

8

एड, १३

/[13579]$/,$d

क्योंकि वास्तविक प्रोग्रामर मानक पाठ संपादक का उपयोग करते हैं ।

प्रत्येक लाइन पर एक पूर्णांक के रूप में इनपुट लेता है; एक ही प्रारूप में आउटपुट।

यह बस पहली विषम संख्या (एक विषम अंक में समाप्त होने वाली संख्या) पाता है और फ़ाइल के अंत तक उस रेखा से हटा देता है।


uhhhhh। तो यही वह कार्यक्रम है।
बिल्ली

7

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

#(take-while even? %)

Clojure थोड़े बहुत प्रतिस्पर्धा में है! (अंतर्निहित कार्य के लिए धन्यवाद) इसे ऑनलाइन देखें https://ideone.com/BEKmez


6

पायथन, 45 44 बाइट्स

f=lambda x:x and~x[0]%2*x and x[:1]+f(x[1:])

Ideone पर इसका परीक्षण करें ।


Aww आदमी .. और वहाँ मुझे लगता है कि मैं एक इनाम जीतने पर सोचा था कि कोई भी मौका जाता है
DJMcMayhem

1
22 जुलाई, 2015 से पहले पोस्ट किए गए प्रतिबंधों के साथ केवल शुद्ध कोड-गोल्फ प्रश्न पात्र हैं।
डेनिस

@DrGreenEggsandIronMan मेरा पूरा समय आपके मुकाबले छोटा रहा है। मैंने पहले अपना पोस्ट किया। : पी
mbomb007

2
डेनिस द्वारा बहिष्कृत, जिसने सोचा होगा :)
जूली



5

05AB1E, 8 7 बाइट्स

[DÉO_#¨

व्याख्या

[        # infinite loop start
 DÉO     # count odd numbers
    _    # push negative bool (turning 0->1, X->0)
     #   # if true (no odd numbers exist), break out of loop and implicitly print
      ¨  # else, remove last element from list

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

पिछले 8 बाइट समाधान

vyÈiyˆëq

व्याख्या

v         # for each y in input
 yÈi      # if y is even
    yˆ    # push y to global array
      ëq  # else terminate program
          # implicitly print global array

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


5

ब्रेनफ ***, 263 बाइट्स

मैंने यहां से थोड़ा स्निपेट लिया

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

मैं एक स्पष्टीकरण देता हूं, लेकिन यहां तक ​​कि मुझे कोई सुराग नहीं है कि यह कैसे काम करता है।

अंतरिक्ष से अलग संख्या (जैसे 2 432 1) के रूप में इनपुट की उम्मीद है


BF में Takewhile ._। +1
TuxCrafting

तुम शायद +और >कुछ तर्क का उपयोग कर की श्रृंखला गोल्फ कर सकते हैं ?
R

@ E @s areIʀᴋ काफी कुछ चेन पहले से ही गिली हैं (अन्यथा 32 '+' की पंक्तियों का एक बहुत कुछ होगा), और मैं शायद >एस में से कुछ को और अधिक कुशल बना सकता हूं, लेकिन मैं उन्हें अभी समझ में नहीं आया है
aoksquirrel

इसलिए आपको अपना कोड टिप्पणी करना चाहिए जैसा कि आप इसे नोटपैड में लिखते हैं। : पी
mbomb007


4

रैकेट, 22 बाइट्स

(λ(n)(takef n even?))

λचरित्र 2 बाइट्स के रूप में गिना जाता है।

मैंने रैकेट को पहले किसी भी कोड गोल्फिंग उत्तर में इस्तेमाल नहीं किया है जो मैंने देखा है, इसलिए मुझे इसे कम से कम एक बार करना था!


2
मैं रैकेट में गोल्फ करता था, रैकेट के लिए हुर्रे!
बिल्ली

4

भूलभुलैया , 14 बाइट्स

?:
"`#
"@%
\!;

इनपुट और आउटपुट लाइन-अलग-अलग सूचियाँ हैं (हालांकि सिद्धांत रूप में, इनपुट किसी भी गैर-अंक विभाजक का उपयोग कर सकता है)।

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

यह शायद मैंने लिखा है सबसे कॉम्पैक्ट भूलभुलैया कार्यक्रम है।

दिलचस्प है, takewhile(odd)बहुत सरल है:

?:#
" %
\!/

व्याख्या

सामान्य भूलभुलैया प्राइमर:

  • मेमोरी मॉडल एक स्टैक है (वास्तव में दो हैं, लेकिन हमें इस कार्यक्रम के लिए केवल एक की आवश्यकता होगी), जो मनमाना-सटीक पूर्णांक रखता है और शुरू में शून्य की अनंत संख्या रखता है।
  • कोई नियंत्रण प्रवाह निर्देश नहीं हैं। इसके बजाय, निर्देश सूचक (आईपी) के आंदोलन को कोड के लेआउट द्वारा निर्धारित किया जाता है (रिक्त स्थान "दीवारों" माना जाता है और आईपी द्वारा पता लगाया नहीं जा सकता है)। आम तौर पर , कोड एक भूलभुलैया जैसा दिखता है, जहां आईपी सीधे गलियारों का अनुसरण करता है और झुकता है, लेकिन जब भी यह एक जंक्शन पर पहुंचता है, तो यह एक सशर्त के रूप में कार्य करता है जहां आईपी की नई दिशा वर्तमान स्थिति के आधार पर निर्धारित की जाती है। एक दिशा चुनने के नियम इसके लिए उबलते हैं: यदि स्टैक का शीर्ष शून्य है, तो आईपी आगे बढ़ता रहता है; यदि शीर्ष सकारात्मक है, तो आईपी सही हो जाता है; यदि शीर्ष नकारात्मक है, तो IP बाईं ओर मुड़ जाता है। यदि इनमें से एक दिशा एक दीवार द्वारा अवरुद्ध है, तो आईपी इसके बजाय विपरीत दिशा लेता है। इसका मतलब है कि कार्यक्रम बिनास्पष्ट गलियारे आमतौर पर काम करने के लिए अविश्वसनीय रूप से कठिन होते हैं, क्योंकि हर एक आदेश एक जंक्शन के रूप में कार्य करेगा। तथ्य यह है कि इस मामले में काम किया थोड़ा चमत्कार है।
  • IP पढ़ने के क्रम में ( ?इस मामले में) पहले गैर-अंतरिक्ष चरित्र पर शुरू होता है , पूर्व की ओर बढ़ रहा है।

कार्यक्रम के माध्यम से मुख्य प्रवाह परिधि के चारों ओर एक लूप है:

>v
^>v
^@v
^<<

जैसा कि होता है, हम जानते हैं कि स्टैक के शीर्ष के बाद शून्य है !और "इसलिए कि आईपी को केंद्र की ओर न मुड़ने की गारंटी दी जाती है। `और %दूसरी ओर, सशर्त के रूप में उपयोग किया जाता है जहां आईपी केंद्र की ओर बढ़ सकता है जैसे कि @कार्यक्रम को समाप्त करता है, या यह परिधि के चारों ओर घूमता रह सकता है।

आइए कोड को लूप में देखें:

?   Read decimal integer N from STDIN, or 0 at EOF.
:   Duplicate. Since this is just a corner, the IP always turns south.
`   Negate the copy of the input (i.e. multiply by 1). At EOF, the result
    is still zero and the IP keeps moving south into the @. Otherwise, the
    top of the stack is now negative, and the IP turns east.
#   Push the stack depth (i.e. 2). Again, this is a corner, and the IP
    is forced to turn south.
%   Computer (-N % 2), which is identical to (N % 2) to determine the
    parity of the input. If input was odd, this gives 1, and the IP turns
    west into the @. Otherwise, the result is 0 and the IP keeps moving
    south, continuing the loop.
;   Discard the 0. This is a corner, so the IP is forced to turn west.
!   Print (and discard) N. The top of the stack is now one of the implicit
    zeros at the bottom, so the IP keeps moving west.
\   Print a linefeed. The IP is forced to turn north in the corner.
""  Two no-ops. The top of the stack is still zero, so the IP keeps moving north.

और फिर लूप शुरू हो जाता है।

यह सवाल उठाता takewhile(odd)है कि इतना सरल क्यों है। इसके दो कारण हैं:

  • चूंकि EOF को लौटाया जाता है 0(जो कि सम है), हमें अलग EOF चेक की आवश्यकता नहीं है। सूची वैसे भी उस बिंदु पर काट दी जाएगी।
  • अब हम समाप्त करने के लिए जब चाहते N % 2है 0(के रूप में करने का विरोध किया 1) है, जो सशर्त नियंत्रण के बजाय साधन प्रवाह हम केवल अन्य प्रतिलिपि विभाजित कर सकते हैं Nद्वारा N % 2यदि इनपुट अजीब है, कि अभी पत्ते: Nऔर हम भी से छुटकारा मिल गया है N % 2(ताकि हम डॉन ' t need ;), लेकिन यदि इनपुट सम है, तो बस प्रोग्राम को एक (साइलेंट) डिविजन-बाय-जीरो एरर से समाप्त करता है।

इसलिए, दूसरा कोड एक सरल लूप है जो किसी भी शाखा में बिल्कुल भी अनुमति नहीं देता है।


3

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

HH:? 2% 0, बी और ~ b.hH; []।

s.:Mc?,.:{:2%0}a

व्याख्या

s.                 Output is an ordered subset of Input
  :Mc?,            The concatenation of Output with a list M is Input
       .:{:2%0}a   All elements of Output are even

आज मैंने एक साफ-सुथरी चाल सीखी (जिसका उपयोग 19 बाइट्स उत्तर में किया गया था): किसी सूची की शुरुआत में एक तत्व को जोड़ने की ~b.hHतुलना में कम है :[H]rc.। पहले का मतलब है "आउटपुट शुरुआत में एक अतिरिक्त आइटम के साथ परिणाम है, और आउटपुट का पहला आइटम H" है , जबकि दूसरा सीधा है "आउटपुट का संघनन है [[H], Result]"।


3

जे, 10 बाइट्स

{.~2&|i.1:

व्याख्या

{.~2&|i.1:  Input: s
   2&|      Take each value in s mod 2
      i.1:  Find the index of the first 1
{.~         Take that many values from s and return

1{.2&|<;._2]दिलचस्प है (हालांकि अधिक लंबा)
लीक नून

के $बजाय का उपयोग करें{.
FrownyFrog

3

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

lambda l:l[:[x%2for x in l+[1]].index(1)]

lएक विषम संख्या की पहली घटना के सूचकांक तक ट्रंकट्स । सूचकांक में पाया जाता 1है कि मूल्यों में एक की तलाश है 2। कोई विषम संख्या नहीं पाए जाने के खिलाफ सुरक्षा के लिए, एक 1को अंत में रखा जाता है।


3

सी #, 50 बाइट्स

int[]f(int[]a)=>(a.TakeWhile(x=>x%2<1).ToArray());

आप सीधे एक मेमने का उपयोग कर सकते हैं। यह मान्य है जहाँ तक मुझे पता है। a=>a.TakeWhile(x=>x%2<1);
aloisdg का कहना है कि

3

सीजेएम , 11 बाइट्स

दो सुधार और एक बाइट के लिए @ डेनिस का धन्यवाद!

{1+_2f%1#<}

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

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

व्याख्या

{         }    e# define code block
 1+            e# attach 1 at the end of the array
   _           e# duplicate
    2f%        e# modulo 2 of each entry
       1#      e# find index of first occurrence of 1
         <     e# slice before

3

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

 ?\d*[13579]\b.*

अनुगामी लाइनफीड महत्वपूर्ण है। इनपुट और आउटपुट अंतरिक्ष-पृथक सूचियां हैं।

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

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

जैसा कि लीकी नून बताते हैं, बाइनरी में सूची लेने से, हम 6 बाइट्स बचा सकते हैं, लेकिन यह थोड़ा धोखा लगता है, इसलिए मैं शायद दशमलव संस्करण की गिनती जारी रखूंगा:

 ?\d*1\b.*


आप बाइनरी में सूची ले सकते हैं?
लीक नून

3

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 30 बाइट्स

a=>[for(x of a)if(!(a|=x&1))x]

2

वी , 13 बाइट्स

íä*[13579]¾.*

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

स्पष्टीकरण:

í              "search for, on every line
 ä*            "Any number of digits
   [13579]     "Followed by an odd digit
          ¾    "Then the end of a word,
           .*  "Followed by anything
               "(implicit) and replace it with nothing.

आसानी से, एक ही कोड सभी परीक्षण-मामलों को एक साथ सत्यापित करने के लिए काम करता है।



2

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

->a{a.take_while &:even?}

मुझे लगता है कि मैं हार गया ...


आप कर सकते हैं ->a{a.take_while &:even?}या कम से कम ->a{a.take_while(&:even?)}?
मार्टिन एंडर

@MartinEnder धन्यवाद। मैं ऐसा कुछ ढूंढ रहा था, लेकिन मुझे लगता है कि मैं रूबी गोल्फ सिंटैक्स में पारंगत नहीं हूं।
मेगाटॉम जूल 5'16

2

Pyke, 8 बाइट्स

0+2L%fhO

दुभाषिया तय, अन्य लिंक का उपयोग करें

मेरे स्प्लिट_ैट फ़ंक्शन को छोड़कर डेनिस विधि का उपयोग करता है जिसमें परिवर्तन शामिल है - शायद एक बग

या बगफिक्स के साथ, 7 बाइट्स

2L%1R@<

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

2L%     -   map(%2, input)
   1R@  -  ^.index(1)
      < - input[:^]

या 2 बगफिक्स के बाद, 6 बाइट्स

2L%fhO

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

स्पष्टीकरण:

2L%    -   map(%2, input)
   f   -  split_at(input, ^)
    hO - ^[0][:-1]

2

GolfScript, 11 बाइट्स

यह एक पूर्ण गोल्फस्क्रिप्ट प्रोग्राम है जो एक कड़े गोल्फस्क्रिप्ट सरणी शाब्दिक (उदाहरण के लिए [28 14 7 0]) को पढ़ता है और पहले विषम तत्व और सब कुछ हटा देने के बाद उसी सरणी को प्रिंट करता है:

~1\{~&.},p;

इसे ऑनलाइन आज़माएं। (यह भी: परीक्षण हार्नेस के साथ विस्तारित संस्करण। )

टिप्पणियों के साथ डी-गोल्फ संस्करण:

~     # evaluate input
1\    # push the number 1 onto the stack and move it under then input array
{     # start of loop body
  ~   #  bitwise negate the input number (making odd numbers even and vice versa)
  &   #  take bitwise AND of input and the saved number (0 or 1) on stack 
  .   #  duplicate result; filter loop will pop off the duplicate
},    # run loop above over input array, select elements for which it returns true
p     # stringify and print filtered array
;     # pop the number 0/1 off the stack

यह समाधान गोल्फस्क्रिप्ट पर आधारित है { }, फ़िल्टर ऑपरेटर , जो किसी सरणी के प्रत्येक तत्व पर कोड ब्लॉक की सामग्री को चलाता है, और उस सरणी के तत्वों का चयन करता है जिसके लिए ब्लॉक में कोड एक सही (यानी गैर-शून्य) मान लौटाता है ढेर के ऊपर।

इस प्रकार, उदाहरण के लिए, {1&},एक सरणी में सभी विषम संख्याओं का {~1&},चयन करेंगे , और सभी संख्याओं का चयन करेंगे। फिर, चुनौती यह है कि एक ऐसा फ़िल्टर बनाया जाए जो संख्याओं का भी चयन करे तब जब तक कि यह पहला विषम न मिल जाए , और उसके बाद कोई संख्या न चुने।

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


2

फोर्थ, 114 बाइट्स

फोर्थ में वास्तव में सूची नहीं है। मापदंडों को रिवर्स ऑर्डर में स्टैक पर धकेल दिया जाना चाहिए, जैसा कि फोर्थ में विशिष्ट है। परिणाम उसी क्रम में ढेर पर छोड़ दिया जाएगा। यह किसी कारण के लिए Ideone पर काम नहीं करता है, लेकिन यह उत्तर पर काम करता है। किसी प्रकार की अस्पष्टता को दूर करने के लिए नई लाइन की आवश्यकता है?

: D DEPTH ;
: f D IF 1 D 1 DO D 1- ROLL LOOP D 0 DO I PICK 2 MOD IF D I LEAVE THEN LOOP
DO I ROLL DROP LOOP THEN ;

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

टिप्पणियों के साथ असंगठित:

: f DEPTH IF                                ( if stack not empty )
        1 DEPTH 1 DO DEPTH 1- ROLL LOOP     ( put 1 on bottom of stack )
        DEPTH 0 DO                          ( loop over entire stack )
            I PICK 2 MOD IF                 ( if stack[i] is odd )
                DEPTH I LEAVE               ( put range and exit loop )
            THEN
        LOOP
        DO I ROLL                           ( roll eyes )
            DROP
        LOOP                                ( iterate that range and remove )
    THEN
;

यह कार्यक्रम (मेरा पिछला प्रयास) परिणाम को प्रिंट करता है जब तक कि यह एक विषम संख्या को हिट नहीं करता है। शेष सब (नहीं लिया गया) स्टैक पर छोड़ दिया जाएगा।

: f DEPTH IF BEGIN DUP 2 MOD DUP 1- IF SWAP . THEN UNTIL THEN ;

विफल रहता है यदि केवल पूर्णांक भी


5
इसे खत्म करने के बाद, मुझे एहसास हुआ कि मेरा नाश्ता ठंडा था। :(
mbomb007

अक्सर मैं टेबल पर गोल्फिंग कोड के बाद अपने रात के खाने को ठंडा पाता हूं। शायद फैक्टर आपको एक ही समय में अधिक उत्पादक और गोल्फ खिलाड़ी होने देगा? : D
बिल्ली

@ मैं ऑनलाइन आईडीई के साथ पीपीसीजी के लिए अपना कोड विकास करता हूं। लेकिन मैं फोर्थ का उपयोग करता हूं क्योंकि मैं पहले से ही जानता हूं, मेरे सिर में एक स्टैक का प्रबंधन करना मुश्किल है। मैंने मूल रूप से फोर्थ सीखा है क्योंकि एक Minecraft मॉड ने रेडस्टोन कंप्यूटरों को जोड़ा है जो कि फोर्थ का एक संस्करण है, जिसे MineOS नाम दिया गया है।
mbomb007

2

Befunge, 35 बाइट्स

यह कोड 0 और 65535 के बीच की संख्या को संभालता है

1&:v
v-1_@#:@#<
>\:&:2%|
 \+1p4\< ^

इनपुट प्रारूप :

number_of_values    values(separated by a space)

यहां एक संस्करण है जो प्रक्रिया के अंत में मूल्यों को प्रदर्शित करता है:

1&:v>::   v                >00g1+:4g.v
v-1_^#:>#<>$$\$1-:10p000p0-| -g01p00:<
>\:&:2%|                   @
 \+1p4\< ^

आप यहां कोड का परीक्षण कर सकते हैं , लेकिन आपको अनुगामी स्थानों के साथ एक अनुगामी रेखा जोड़ना होगा, क्योंकि यह व्याख्या निर्दिष्ट करती है:

«कोड टोरस केवल प्रारंभिक कार्यक्रम जितना बड़ा है। यदि कोड के अंत से परे डेटा डाला जाएगा तो अधिक लाइनें या अनुगामी स्थान डालें।

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


यह कैसे काम करता है: किस तरह दुभाषिया तीर का अनुसरण करता है और '#' को पार करते समय एक निर्देश छोड़ता है

ग्रे डॉट्स का परीक्षण किया जाता है, और लाल रेखा स्टैक से अनावश्यक वेरिएबल्स को हटा देती है

उपरोक्त व्याख्याकार में यहाँ का उपयोग करते हुए, सहेजे गए मानों को उनके अभ्यावेदन का उपयोग करके कोड में प्रदर्शित किया जाता है (मुझे प्रारूप नहीं पता है)। हां, Befunge काफी चिंतनशील भाषा है

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.