परिचय:

के लिए तीन अंतरिक्ष आयाम: सामान्य में हम आम तौर पर चार आयाम की बात x, yऔर z; और एक समय आयाम। लेकिन इस चुनौती के लिए, हम भी तीन में समय आयाम विभाजित कर देंगे: past, present, और future।

इनपुट:

दो इनपुट-सूचियाँ। एक पूर्णांक x,y,zनिर्देशांक युक्त , और एक पूर्णांक वाले वर्ष।

आउटपुट:

अपनी खुद की पसंद के किसी भी चार विशिष्ट और निरंतर आउटपुट में से एक। आउटपुट को इंगित करने के लिए एक space; आउटपुट को इंगित करने के लिए एक time; आउटपुट को इंगित करने के लिए एक both space and time; और एक आउटपुट को इंगित करने के लिए neither space nor time।

हम इंगित करेंगे कि हम सभी तीन अंतरिक्ष आयामों में गए हैं यदि पूर्णांक-ट्यूपल के अंतर सभी तीन आयामों के लिए 0 नहीं हैं।
यदि हम अतीत में कम से कम एक वर्ष, भविष्य में कम से कम एक वर्ष, और वर्तमान वर्ष के बराबर कम से कम एक वर्ष (वर्तमान में) के बराबर है, तो हम तीनों समय के आयामों में गए।

उदाहरण:

इनपुट:
निर्देशांक-सूची: [{5,7,2}, {5,3,8}, {-6,3,8}, {5,7,2}]
वर्ष-सूची:[2039, 2019, 2018, 2039, 2222]

आउटपुट:
लगातारspace

क्यों? निर्देशांक हैं । चूंकि वे सभी समान नहीं हैं, इसलिए हम अंतरिक्ष आयाम से गुजरे हैं। निर्देशांक हैं । चूंकि वे सभी समान नहीं हैं, इसलिए हम अंतरिक्ष आयाम के माध्यम से भी गए हैं । निर्देशांक हैं । चूंकि वे सभी समान नहीं हैं, इसलिए हम अंतरिक्ष आयाम के माध्यम से भी गए हैं । वर्तमान वर्ष है । इससे पहले कोई वर्ष नहीं हैं, इसलिए हम समय के आयाम पर नहीं गए। वर्ष-सूची में एक वर्तमान है, इसलिए हमने समय के आयाम का दौरा किया । ऊपर कई साल हैं ( ), इसलिए हमने समय के आयाम का भी दौरा किया ।
x[5,5,-6,5]x
y[7,3,3,7]y
z[2,8,8,2]z
2018past
2018present
2018[2039, 2019, 2039, 2222]future

चूंकि हमने सभी तीन spaceआयामों का दौरा किया है , लेकिन केवल तीन आयामों में से दो time, आउटपुट केवल (निरंतर) होगा space।

चुनौती नियम:

आप चार संभव राज्यों के लिए किसी भी चार अलग और निरंतर आउटपुट का उपयोग कर सकते हैं।
इनपुट किसी भी उचित प्रारूप में हो सकता है। निर्देशांक सूची टपल हो सकती है, आकार 3 की आंतरिक सूचियां / सरणियाँ, तार, वस्तुएं, आदि। वर्षों की सूची पूर्णांक की बजाय तारीख-वस्तुओं की एक सूची हो सकती है यदि यह आपकी बाइट-गणना से लाभान्वित होगी।
आप मान सकते हैं कि x,y,zनिर्देशांक पूर्णांक होंगे, इसलिए फ्लोटिंग पॉइंट डेसीमल को संभालने की कोई आवश्यकता नहीं है। का कोई भी x, yऔर / या zनिर्देशांक ऋणात्मक मानों, हालांकि हो सकता है।
आप पूर्व-आदेशित इनपुट-सूचियों को नहीं ले सकते। इनपुट-सूचियाँ परीक्षण मामलों में प्रदर्शित क्रम में होनी चाहिए।
आप मान सकते हैं कि सभी वर्ष मान सीमा में होंगे [0,9999]; और आप मान सकते हैं कि सभी निर्देशांक सीमा में हैं [-9999,9999]।
यदि आपकी भाषा में वर्तमान वर्ष को पुनः प्राप्त करने का कोई तरीका नहीं है, लेकिन आप अभी भी इस चुनौती को करना चाहते हैं, तो आप इसे अतिरिक्त इनपुट के रूप में ले सकते हैं और अपने उत्तर को (गैर-प्रतिस्पर्धात्मक) के रूप में चिह्नित कर सकते हैं ।

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
डिफ़ॉल्ट I / O नियमों के साथ आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
डिफ़ॉल्ट लूपोल्स वर्जित हैं।
यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

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

Coordinates-input: [{5,7,2}, {5,3,8}, {-6,3,8}, {5,7,2}]
Years-input:       [2039, 2019, 2018, 2039, 2222]
Output:            space

Coordinates-input: [{0,0,0}, {-4,-4,0}, {-4,2,0}]
Years-input:       [2016, 2019, 2018, 2000]
Output:            time

Coordinates-input: [{-2,-2,-2}, {-3,-3,-3}]
Years-input:       [2020, 1991, 2014, 2018]
Output:            both

Coordinates-input: [{5,4,2}, {3,4,0}, {1,4,2}, {9,4,4}]
Years-input:       [2020, 1991, 2014, 2017, 2019, 1850]
Output:            neither

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

हमें संभालने में सक्षम होने के लिए कितने साल चाहिए?

— झबरा

@ शैगी मैं इसे चुनौती विवरण में जोड़ूंगा। [0,9999]ठीक है (और [-9999,9999]निर्देशांक के लिए भी ठीक है।

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

डांग, मेरे विचारों में से एक है!

— झबरा

@ जिज्ञासा से बाहर, आप किस रेंज की उम्मीद कर रहे थे?

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

3

क्या हम वर्तमान वर्ष को इनपुट के रूप में ले सकते हैं? (कुछ भाषाओं में चालू वर्ष egBF नहीं मिल सकता है, दूसरों को केवल किसी अन्य भाषा में कोड का मूल्यांकन करके कर सकते हैं - जैसे जेली, दूसरों को, हो सकता है कई, भी इस golfier मिलेगा)

— जोनाथन एलन

2

05AB1E , 15 बाइट्स

आउटपुट एक सूची है [space, time]जहां 1 का मतलब है xऔर 0 के लिए खड़ा हैno x

ø€Ë_Psžg.SÙg3Q)

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

व्याख्या

    ø                 # zip space coordinates
     €Ë               # for each axis, check that all values are equal
       _              # logical negation
        P             # product (1 for space, 0 for no space)
         s            # put the time list on top of the stack
          žg.S        # compare each with the current year
              Ù       # remove duplicates
               g3Q    # check if the length is 3
                  )   # wrap the space and time values in a list

— Emigna
स्रोत

मुझ से स्पष्ट +1। मेरे द्वारा तैयार किए गए 16-बटर के समान, सिवाय इसके कि मैंने -.±इसके बजाय इस्तेमाल किया .S(इसलिए +1 बाइट ..) और ‚(जोड़ी) के बजाय)

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

@ केविनक्रूजसेन: मैं वास्तव में एक और तरीका चाहता हूं Ùg3Q, जो सबसे बड़ा बाइट-चोर जैसा लगता है, लेकिन मुझे यकीन नहीं है कि यह संभव है: /

— एमिग्ना

मुझे शक है कि यह कम tbh किया जा सकता है। मैं कुछ 4-बाइट विकल्पों के बारे में सोच सकता हूं, और êकुछ बिटवाइज़ ऑपरेशन या डेल्टास या कुछ के साथ कुछ करने की कोशिश कर रहा हूं, लेकिन मुझे कोई 3-बाइट विकल्प नहीं मिल रहा है।

— केविन क्रूजसेन 14

6

पायथन 2 , 111 109 बाइट्स

lambda S,T:(min(map(len,map(set,zip(*S))))>1,date.today().year in sorted(set(T))[1:-1])
from datetime import*

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

— TFeld
स्रोत

आप सॉर्ट करने से पहले टी को एक सेट क्यों बनाते हैं?

— काला उल्लू काई

4

@BlackOwlKai अन्यथा [1: -1] द्वारा निकाली गई दो प्रविष्टियाँ भूतकाल / भविष्य में नहीं हो सकती हैं

— पून लेवी

6

पर्ल 6 , 47 46 बाइट्स

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

{Set(@^b X<=>Date.today.year)>2,max [Z==] @^a}

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

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

व्याख्या

{                                            }  # Anonymous code block
     @^b X         # Map each element of the year list to:
          <=>      # Whether it is smaller, equal or larger than
             Date.today.year  # The current year
 Set(                       )    # Get the unique values
                             >2  # Is the length larger than 2?
                               ,
                                    [Z  ] @^a   # Reduce by zipping the lists together
                                max       # And return if any of them are
                                      ==  # All equal

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

3

जाप, 22 बाइट्स

अंतरिक्ष आयामों के लिए 2 डी-सरणी के रूप में इनपुट लेता है और वर्षों के लिए पूर्णांक का 1D-सरणी। 2अंतरिक्ष के लिए आउटपुट , केवल 1समय के 3लिए , दोनों के लिए और 0न ही के लिए।

yâ mÊeÉ Ñ+!Jõ kVmgKi¹Ê

कोशिश करो

                           :Implicit input of 2D-array U=space and array V=time
y                          :Transpose U
 â                         :Deduplicate columns
   m                       :Map
    Ê                      :  Lengths
     e                     :All truthy (not 0) when
      É                    :  1 is subtracted
        Ñ                  :Multiply by 2
           J               :-1
            õ              :Range [-1,1]
              k            :Remove all the elements present in
               Vm          :  Map V
                 g         :    Signs of difference with
                  Ki       :    The current year
                    ¹      :End removal
                     Ê     :Length
         +!                :Negate and add first result

— झबरा
स्रोत

2

जाप , 25 बाइट्स

मुझे 100% यकीन है कि यह सबसे अच्छा तरीका नहीं है, फिर भी ऐसा करने के लिए कुछ छोटे रास्ते की तलाश है: सी

बूलियंस का एक टपल देता है। पहला है यदि आपने अंतरिक्ष में यात्रा की है और दूसरा यदि आपने समय पर यात्रा की है

[Uyâ e_Ê¦1ÃV®-Ki)gÃâ Ê¥3]

[Uyâ e_Ê¦1ÃV®-Ki)gÃâ Ê¥3]   Full Program, U = Space, V = Time
                            -- U = [[-2,-2,-2], [-3,-3,-3]]
                            -- V = [2020, 1991, 2014, 2018]
[                       ]   Return array containing....
 Uyâ                        Transpose Space coords 
                            -- U = [[-2,-3], [-2,-3], [-2,-3]]
                            and map Z   
      _Ê¦1                  Z length greater than 1?
                            -- U = [true, true, true]
     e                      return true if all Z are true   
                            -- U = true
          V®                Map each time
            -Ki)            Subtract current year   
                            -- V = [2,-27,-4,0]
                gÃ          get sign (-1,0,1)
                            -- V = [1,-1,-1,0]
                   â        unique elements
                            -- V = [1,-1,0]
                     Ê¥3    return true if length == 3
                            -- V = true

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत

उह, मुझे लगता है कि आपके द्वारा लिंक किए गए टेस्टकेस पर यह विफल रहता है? ( yâस्थानांतरित करता है, अद्वितीय आइटम लेता है, और वापस स्थानांतरित करता है , इसलिए आप शायद Uy e_â Ê¦1Ãइसके बजाय करना चाहते हैं )

— ETHproductions

केवल अब इसे देखकर, ऐसा लगता है कि आपने इसे मेरे से पहले पोस्ट किया होगा (मेरे फोन पर तो यह ठीक से नहीं बता सकता है)। यदि हां, तो मुझे बताएं कि क्या आप चाहते हैं कि खदानों को समानता दी जाए और मैं इसे हटा दूंगा।

— झबरा

@ETHproductions, यह काम करने लगता है। मैं अपनी पहली कोशिश में âइस eविधि के भीतर था , यह yदेखने से पहले कि यह काम करेगा या नहीं, यह देखने के लिए।

— झबरा

@ शैग्गी वैसे मैं डर जाऊंगा, यह वास्तव में काम करता है ... लेकिन यह इस मामले में वापस क्यों नहीं स्थानांतरित करता है?

— ETHproductions

1

@ शिग्गी ओह प्रिय, कोड है कि जाँच करता है कि क्या यह वापस जाँच करने के लिए अगर qप्रतिचित्रित सरणी में हर के लिए , typeof q instanceof Array... क्या एक सुविधाजनक बग: पी लगता है कि मैं इसे अब ठीक नहीं कर सकते 1.4.6 जारी ...

— ETHproductions

2

जावास्क्रिप्ट (ईएस 6), 104 100 बाइट्स

(space)(time) $1$ $2$ $3$ $0$

कोड का 24% यह पता लगाने में खर्च किया जाता है कि हम किस वर्ष में हैं ... \ o /

s=>t=>2*s[0].every((x,i)=>s.some(b=>x-b[i]))|t.some(y=>(s|=(y/=(new Date).getFullYear())>1?4:y+1)>6)

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

टिप्पणी की गई

s => t =>              // s[] = space array; t[] = time array
  2 *                  // the space flag will be doubled
  s[0].every((x, i) => // for each coordinate x at position i in the first entry of s[]:
    s.some(b =>        //   for each entry b in s[]:
      x - b[i]         //     if we've found b such that b[i] != x, the coordinate is valid
    )                  //   end of some()
  )                    // end of every()
  |                    // bitwise OR with the time flag
  t.some(y =>          // for each year y in t[]:
    (s |=              //   update the bitmask s (initially an array, coerced to 0)
      ( y /=           //     divide y
        (new Date)     //     by the current year (this is safe as long as no time-travel
        .getFullYear() //     machine is available to run this it at year 0)
      ) > 1 ?          //   if the result is greater than 1:
        4              //     do s |= 4 (future)
      :                //   else:
        y + 1          //     do s |= y + 1; y + 1 = 2 if both years were equal (present)
                       //     otherwise: y + 1 is in [1, 2), which is rounded to 1 (past)
    ) > 6              //   set the time flag if s = 7
  )                    // end of some()

— Arnauld
स्रोत

फेलconsole.log(f([[5,4,2], [3,4,0], [1,4,2], [9,4,4]])([2020])) // neither

— l4m2

@ l4m2 हम्म। 1 बाइट की कीमत पर तय किया गया। मैं अपने सिर के ऊपर से 99-बाइट समाधान के बारे में नहीं सोच सकता।

— अरनुलद

1

आर , 106 , 105 बाइट्स

function(s,t)all((x<-apply(s,1,range))[1,]-x[2,])-2*all((-1:1)%in%sign(as.POSIXlt(Sys.Date())$ye+1900-t))

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

इनपुट:

s : matrix of space coordinates (3 x N)
t : vector time years

एक पूर्णांक मान के बराबर आउटपुट:

 1 : if traveled through space only
-2 : if traveled through time only
-1 : if traveled through space and time
 0 : if traveled neither through space nor time

— digEmAll
स्रोत

1

बैच, 353 बाइट्स

@echo off
set/as=t=0,y=%date:~-4%
for %%a in (%*) do call:c %~1 %%~a
if %s%==7 (if %t%==7 (echo both)else echo space)else if %t%==7 (echo time)else echo neither
exit/b
:c
if "%6"=="" goto g
if %1 neq %4 set/as^|=1
if %2 neq %5 set/as^|=2
if %3 neq %6 set/as^|=4
exit/b
:g
if %4 lss %y% (set/at^|=1)else if %4==%y% (set/at^|=2)else set/at^|=4

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

spacetime "5,7,2" "5,3,8" "-6,3,8" "5,7,2" 2000 2002

Explantion:

@echo off

अवांछित उत्पादन बंद करें।

set/as=t=0,y=%date:~-4%

दो बिटमास्क सेट करें और चालू वर्ष भी निकालें। (YYYY-MM-DD स्थानों %date:~,4%में एक ही बाइट गिनती के लिए उपयोग होता है ।)

for %%a in (%*) do call:c %~1 %%~a

सभी तर्कों पर लूप। ~कारणों में समन्वय मूल्यों अलग मानकों में विभाजित किया जाना है।

if %s%==7 (if %t%==7 (echo both)else echo space)else if %t%==7 (echo time)else echo neither
exit/b

जांचें कि क्या बिटमास्क पूरी तरह से सेट हैं और उचित परिणाम आउटपुट करते हैं।

:c
if "%6"=="" goto g

देखें कि क्या यह निर्देशांक या एक समन्वय और एक वर्ष की एक जोड़ी है।

if %1 neq %4 set/as^|=1
if %2 neq %5 set/as^|=2
if %3 neq %6 set/as^|=4
exit/b

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

:g
if %4 lss %y% (set/at^|=1)else if %4==%y% (set/at^|=2)else set/at^|=4

यदि यह एक वर्ष है तो संबंधित समय आयाम का दौरा किया गया था या नहीं इसके अनुसार समय बिटमास्क को अपडेट करें।

— नील
स्रोत

1

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

s->t->{int y=java.time.Year.now().getValue(),c=0,d=1,i=3;for(;i-->0;d*=c,c=0)for(var l:s)c=l[i]!=s[0][i]?1:c;for(int a:t)c|=a>y?4:a<y?1:2;return c/7*2+d;}

रिटर्न 1के लिए अंतरिक्ष , 2के लिए समय , 3के लिए दोनों , 0के लिए न । इसे यहाँ ऑनलाइन आज़माएँ ।

Ungolfed:

s -> t -> { // lambda taking two parameters in currying syntax
            // s is int[][], t is int[]; return type is int

    int y = java.time.Year.now().getValue(), // the current year
        c = 0, // auxiliary variable used for determining both space and time
        d = 1, // initally, assume we have moved in all three space dimensions
        i = 3; // for iterating over the three space dimensions

    for(; i -- > 0; d *= c, c = 0) // check all coordinates for each dimension, if we have not moved in one of them, d will be 0
        for(var l : s) // check the whole list:
            c = l[i] != s[0][i] ? 1 : c; // if one coordinate differs from the first, we have moved

    for(int a : t) // look at all the years; c is 0 again after the last loop
        c |= a > y ? 4 : a < y ? 1 : 2; // compare to the current year, setting a different bit respectively for past, present and future

    return c / 7 // if we have been to past, the present and the future ...
           * 2   // ... return 2 ...
           + d;  // ... combined with the space result, otherwise return just the space result
}

— OOBalance
स्रोत

अंतरिक्ष और समय के माध्यम से

परिचय:

इनपुट:

आउटपुट:

उदाहरण:

चुनौती नियम:

सामान्य नियम:

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

05AB1E , 15 बाइट्स

पायथन 2 , 111 109 बाइट्स

पर्ल 6 , 47 46 बाइट्स

व्याख्या

जाप, 22 बाइट्स

जाप , 25 बाइट्स

जावास्क्रिप्ट (ईएस 6), 104 100 बाइट्स

टिप्पणी की गई

आर , 106 , 105 बाइट्स

बैच, 353 बाइट्स

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