माचिस की तीली, माचिस की तीली मुझे मेल कर देना

21

( हालांकि, हम एक खोजने Findया पकड़ने नहीं किया जाएगा tryCatch, हालांकि)

यह कुछ दिलचस्प आर कार्यों को लागू करने की एक बहु-भाग श्रृंखला का हिस्सा है। भाग एक यहाँ पाया जा सकता है ।

काम:

आप R के matchफंक्शन को अधिक से अधिक बाइट्स में लागू कर सकते हैं ।

इनपुट:

  • x, पूर्णतः रिक्त सूची / पूर्णांक की सरणी
  • table, पूर्णतः रिक्त सूची / पूर्णांक की सरणी
  • nomatch, एक पूर्णांक मान
  • incomparables, पूर्णतः रिक्त सूची / पूर्णांक की सरणी

आउटपुट:

  • एक समान सरणी / Oसमान लंबाई वाले पूर्णांकों की सूची x, जहां प्रत्येक मान O[i]या तो प्रदर्शित होता है:
    • सूचकांक jकी पहली में मूल्य tableजहांtable[j]==x[i]
    • nomatchयह दर्शाता है कि में कोई मूल्य नहीं tableके बराबर x[i] या कि x[i]की सूची में है incomparables।

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

All in the form x, table, nomatch, incomparables -> output
outputs 

[], [1,2,3], 0, [5] -> []

[1, 2, 3], [], 0, [5] -> [0, 0, 0]

[9, 4, 3, 6, 3], [9, 8, 7, 6, 5, 4, 3, 2, 1], -1, [4] -> [1, -1, 7, 4, 7]

[8, 6, 7, 5, 3, 0, 9], [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9, 3, 2, 3, 8, 4, 6, 2, 6], 1000, [1] -> [12, 8, 14, 5, 1, 1000, 6]

आवश्यकतानुसार अधिक परीक्षण मामले उत्पन्न किए जा सकते हैं।

अतिरिक्त नियम:

  • आर में 1-आधारित सूचकांक हैं, लेकिन एक सुसंगत वैकल्पिक-आधारित सूचकांक स्वीकार्य हैं। इसलिए आप उन सूचकांकों का उपयोग कर सकते हैं जो 3 या 17 या जो कुछ भी शुरू करते हैं, लेकिन यह सुसंगत होना चाहिए, और आपको अपने उत्तर में यह इंगित करना होगा।
  • यदि आपने चुनी हुई भाषा में एक बिल्डिन है जो ऐसा करता है, तो कृपया अपना समाधान भी लागू करें।
  • स्पष्टीकरण की सराहना की है।

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

code-golf  array-manipulation 
— ग्यूसेप
स्रोत
क्या इसे नकारात्मक संख्याओं का समर्थन करना चाहिए? मुझे लगता है कि इसकी आवश्यकता नहीं है, क्योंकि केवल उदाहरण इसे मानता है और मुझे पूरा यकीन है कि इसके लिए एक मानक नियम है।
— wizzwizz4
@ wizzwizz4 नहीं, क्योंकि 4अंदर है incomparables, इसलिए इसका मिलान नहीं किया जा सकता। यदि आपकी भाषा नकारात्मक संख्याओं का समर्थन नहीं कर सकती है, तो गैर-ऋणात्मक संख्याओं की आवश्यकता ठीक है, लेकिन आपके प्रस्तुत करने में मान्य है।
— ग्यूसेप
1
शीर्ष लेख टिप्पणी के अलावा: हम भी नहीं बना रहे हैं make।
— वैल का कहना है कि मोनिका
1
@val यह वास्तव में छत पर फिडलर के लिए एक बहुत बुरा संदर्भ है ; इन सभी चुनौतियों ने विभिन्न शो-ट्यूट्स के बाद थीम्ड शीर्षक दिया क्योंकि यह पूरी तरह से फिट है, इसलिए मैंने सोचा कि यह एक अच्छा विषय बना देगा।
— ग्यूसेप

जवाबों:

8

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

-2 एग्री द आउटग्राफर को धन्यवाद

,⁷y⁵iⱮ⁶o

चार कमांड लाइन तर्कों को स्वीकार करने वाला एक पूर्ण कार्यक्रम, incomparables nomatch table xजो आर के matchफ़ंक्शन परिणामों की सूची के एक जेली प्रतिनिधित्व * को प्रिंट करता है।

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

कैसे?

जैसे incomparables nomatch table x= [1,4], 2, [2,4], [4,3,2,1,0]:

,⁷y⁵iⱮ⁶o - Main Link: list, incomparables; list, nomatch
 ⁷       - newline character                                '\n'
,        - pair (incompararables) with (right)              [[1,4],'\n']
   ⁵     - 5th argument (3rd input = table)                 [2,4]
  y      - translate (right) with lookup (left)             [2,'\n']             
      ⁶  - 6th argument (4th input = x)                     [4,3,2,1,0]
     Ɱ   - map with:
    i    -   first index of (right) in (left)               [0,0,1,0,0]
       o - logical OR                                       [2,2,1,2,2]

* एक खाली सूची को कुछ नहीं के रूप में दर्शाया गया है, एक सूची की सूची को केवल आइटम के रूप में दर्शाया गया है, जबकि अन्य सूचियों को संलग्न किया गया है []और इसके द्वारा सीमांकित किया गया है,

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

आर , 55 बाइट्स

इस स्थिति में, कोड matchअपनी पूर्ण कार्यक्षमता के साथ उपयोग नहीं करता है , यह सिर्फ एक indexफ़ंक्शन के रूप में उपयोग किया जाता है। पहला आर उत्तर, इसलिए शायद अविश्वसनीय रूप से अक्षम बाइट-वार!

नोट ( जानकारी के लिए Giuseppe के लिए धन्यवाद ) : %in% और setdiffदोनों आंतरिक रूप से कार्यान्वित किए जाते हैं match, इसलिए इस आश्चर्यजनक रूप से उपयोगी फ़ंक्शन से पूरी तरह से छुटकारा पाने के परिणामस्वरूप गड़बड़ हो जाएगी । इसलिए, इसके लिए कोई समय सीमा नहीं होने के साथ 150-प्रतिनिधि इनाम है ! (ध्यान दें कि setdiffअनुमति है, हालांकि)

function(x,t,n,i)ifelse(x%in%setdiff(t,i),match(x,t),n)

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

या ...

आर , 5 बाइट्स

match

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

— श्री Xcoder
स्रोत
मुझे यकीन नहीं है कि मैं बेहतर कर सकता था हालांकि मैं %in%और के उपयोग से बच रहा था match; यदि आप उन कार्यों (या भयानक होने की संभावना) के बिना एक अच्छा गोल्फरी जवाब ढूंढना चाहते हैं, तो मैं इसे इनाम दूंगा।
— Giuseppe
आह योग्य, मैंने अभी गोल्फर में उस बारे में टिप्पणी की है ...
— श्री एक्सकोडर
पूरी तरह से स्नार्की matchप्रस्तुत करने के लिए
— उत्कीर्ण
आप ifelseइस टिप का उपयोग करके इसे छोटा कर सकते हैं : codegolf.stackexchange.com/a/97826/59530
— JAD
2
इसके अलावा, आपका लंबा सबमिशन वास्तव में उपयोग होता है match: S
— JAD
4

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

lambda x,t,n,i:[v in{*t}-{*i}and-~t.index(v)or n for v in x]

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

— श्री Xcoder
स्रोत
इसकी क्या विशेषताएं 3.8 के लिए विशिष्ट हैं? मुझे ऐसा लगता है कि पायथन 3 के किसी भी तोड़फोड़ के लिए काम कर सकता है 3.
— थियो
खैर, यह 3.8 के लिए विशिष्ट नहीं है । मैंने अभी TIO पर ऑटो-जेनरेट किए गए टेम्पलेट को कॉपी-पेस्ट किया है इसलिए मैंने नोटिस नहीं किया कि मैंने 3.8 का उपयोग किया है। सिर के लिए धन्यवाद, समायोजित करेगा।
— श्री एक्सकोडर
1
R has 1-based indices, but a consistent alternative-based indices are acceptable.तो आप बाहर ले जा सकते हैं -~और सिर्फ -1 बाइट्स के लिए 0-इंडेक्सिंग का उपयोग करें।
— वैल्यू इंक।
1
@ValueInk 3 टेस्ट केस के लिए विफल रहता है (और सामान्य तौर पर जब एक मेलिंग तत्व एक सूची की शुरुआत में होता है), चूंकि पायथन में 0 गलत है।
— श्री एक्सकोडर
1
आह, निष्पक्ष शो। संयोग से, t.index(v)if v in{*t}-{*i}else nआपके वर्तमान v in{*t}-{*i}and-~t.index(v)or nसमाधान के रूप में सटीक एक ही बायटेकाउंट है, हहा
— वैल्यू इंक
3

पर्ल 6 , 45 बाइट्स

->\b,\c,\d{*>>.&{$_∉d&&~b.first($_,:k)||c}}

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

अनाम कोड ब्लॉक, जो इनपुट को ले जाता है, जैसे f(table, nomatch, incomparables)(x)0 अनुक्रमित मैचों को लौटाता है।

स्पष्टीकरण:

->\b,\c,\d{                               }    # Anonymous code block taking 3 inputs
           *           # Return an anonymous Whatever lambda
            >>.&{                        }  # Mapping input to
                 $_∉d                       # If the element is not an uncomparable
                     && b.first($_,:k)      # Return the first index in the table
                       ~                    # Stringified so Nils are false
                                      ||c   # Else the nomatch element
~~
— मजाक कर रहा है
स्रोत
+1 मैंने इस पर संक्षेप में काम किया लेकिन वह कर रहा था $_∉d&&b.antipairs.Map{$_}||cजो अच्छी तरह से काम कर रहा था, लेकिन 0. के गलत मूल्य के लिए। पहला ($ _: k) एक महान समाधान है जो लंबे एंटीपर्स से बचता है।
— user0721090601
2

चारकोल , 14 बाइट्स

ＩＥθ∨∧¬№ει⊕⌕ηιζ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। 1 अनुक्रमित। स्पष्टीकरण:

  θ             First input (x)
 Ｅ              Map over elements
       ε        Fourth input (incomparables)
      №         Count occurrences of
        ι       Current element
     ¬          Is zero
    ∧           Logical And
           η    Second input (table)
          ⌕     Find 0-based index of
            ι   Current element
         ⊕      Convert to 1-indexed
   ∨            Logical Or
             ζ  Third input (nomatch)
Ｉ               Cast to string
                Implicitly print on separate lines
— नील
स्रोत
2

सी (जीसीसी) , 125 बाइट्स

1 अनुक्रमित।

यह देखते हुए कि मैं पारित सरणियों में एक प्रहरी मूल्य का उपयोग नहीं कर सकता, मुझे प्रत्येक सरणी के लिए सरणी सीमा देने की आवश्यकता है।

f(x,c,t,d,n,i,e,j,f)int*x,*t,*i;{for(;f=0,c-->0;x[c]=--f?n:j){for(j=e;!f&j;x[c]-i[--j]||--f);for(;!f&j<d;x[c]-t[j++]||++f);}}

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

— ErikF
स्रोत
2

अटैची , 39 बाइट्स

${{[_,y][nil=_or x@_in z]}=>x&Index@_4}

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

बहुत सरल सत्यापन। ध्यान दें कि तर्क क्रम मैच से अलग है; विशेष रूप xसे, पहले के बजाय अंतिम तर्क है, और _4उपरोक्त स्निपेट में मेल खाती है ।

व्याख्या

${{[_,y][nil=_or x@_in z]}=>x&Index@_4}
${                                    }   named lambda, taking parameters x, y, z, and _4
                            x&Index@_4    short for Index[x, _4];
                                              calculates where each element in _4 occurs in x
                                              returns `nil` for no match
  {                      }=>              over each index:
   [_,y][               ]                     choose y (`nomatch`) if
         nil=_                                    the index is nil
              or x@_in z                          or the element is in `incomparables`
    _                                         otherwise, choose the index
— कोनोर ओ ब्रायन
स्रोत
2

05AB1E , 7 बाइट्स

õ:Ik®I:

0 अनुक्रमित। इनपुट क्रम में हैं:incomparables, table, x, nomatch।

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

स्पष्टीकरण:

õ:       # Replace all values of the (implicit) first incomparables-list in
         # the (implicit) second table-list with an empty string
         #  i.e. incomparables=[4] and table=[9,8,7,6,5,4,3,2,1] → [9,8,7,6,5,"",3,2,1]
  Ik     # Get the index of each value in the third x-list in this list (-1 if not found)
         #  i.e. x=[9,4,3,6,3] → [0,-1,6,3,6]
    ®I:  # Replace all -1 with the fourth input-integer
         #  i.e. nomatch=-99 → [0,-99,6,3,6]
         # (and output the mapped list implicitly as result)
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.