Einführung:

Im Allgemeinen sprechen wir in der Regel von vier Dimensionen: drei Raumdimensionen für x, yund z; und einmalige Dimension. Aber für die Zwecke dieser Herausforderung werden wir die Zeitdimension in drei geteilt auch: past, present, und future.

Eingang:

Zwei Eingabelisten. Eine mit ganzzahligen x,y,zKoordinaten und eine mit ganzzahligen Jahren.

Ausgabe:

Eine von vier unterschiedlichen und konstanten Ausgaben Ihrer Wahl. Eine, um die Ausgabe anzuzeigen space; eine, um die Ausgabe anzuzeigen time; eine, um die Ausgabe anzuzeigen both space and time; und eine, um die Ausgabe anzuzeigen neither space nor time.

Wir werden angeben, dass wir zu allen drei Raumdimensionen gegangen sind, wenn die Unterschiede der ganzzahligen Tupel nicht für alle drei Dimensionen 0 sind.
Wir werden angeben, dass wir zu allen drei Zeitdimensionen gegangen sind, wenn es in der Vergangenheit mindestens ein Jahr, in der Zukunft mindestens ein Jahr und mindestens ein Jahr gibt, das dem aktuellen Jahr entspricht (also in der Gegenwart).

Beispiel:

Eingabe:
Koordinatenliste: [{5,7,2}, {5,3,8}, {-6,3,8}, {5,7,2}]
Jahresliste:[2039, 2019, 2018, 2039, 2222]

Ausgabe:
Konstante fürspace

Warum?
Die xKoordinaten sind [5,5,-6,5]. Da sie nicht alle gleich sind, haben wir die xRaumdimension durchlaufen .
Die yKoordinaten sind [7,3,3,7]. Da sie nicht alle gleich sind, haben wir auch die yRaumdimension durchlaufen .
Die zKoordinaten sind [2,8,8,2]. Da sie nicht alle gleich sind, haben wir auch die zRaumdimension durchlaufen .
Das laufende Jahr ist 2018. Es gibt keine Jahre davor, also haben wir die pastZeitdimension nicht besucht .
Da die Jahresliste ein 2018Geschenk enthält, haben wir die presentZeitdimension besucht.
Es gibt mehrere Jahre über 2018( [2039, 2019, 2039, 2222]), daher haben wir auch die futureZeitdimension besucht.

Da wir alle drei spaceDimensionen besucht haben, aber nur zwei der drei timeDimensionen, ist die Ausgabe nur (die Konstante für) space.

Herausforderungsregeln:

• Sie können vier verschiedene und konstante Ausgänge für die vier möglichen Zustände verwenden.
• Die Eingabe kann in jedem vernünftigen Format erfolgen. Die Koordinatenliste kann Tupel, innere Listen / Arrays der Größe 3, Zeichenfolgen, Objekte usw. sein. Die Liste der Jahre kann auch eine Liste von Datumsobjekten anstelle von Ganzzahlen sein, wenn dies Ihrer Byteanzahl zugute kommt.
• Sie können davon ausgehen, dass die x,y,zKoordinaten Ganzzahlen sind, sodass keine Gleitkomma-Dezimalstellen verarbeitet werden müssen. Jede der x, yund / oder zKoordinaten können negative Werte sein, though.
• Sie können die vorbestellten Eingabelisten nicht übernehmen. Die Eingabelisten sollten in der Reihenfolge sein, die in den Testfällen angezeigt wird.
• Sie können davon ausgehen, dass alle Jahreswerte im Bereich liegen [0,9999]. und Sie können davon ausgehen, dass alle Koordinaten im Bereich liegen [-9999,9999].
• Wenn Ihre Sprache KEINE Möglichkeit hat, das aktuelle Jahr abzurufen, Sie diese Herausforderung dennoch ausführen möchten, können Sie sie als zusätzliche Eingabe verwenden und Ihre Antwort als (nicht konkurrierend) markieren .

Allgemeine Regeln:

• Dies ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich nicht von Code-Golf-Sprachen davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, eine möglichst kurze Antwort für "jede" Programmiersprache zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln . Sie können also STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf.
• Standardschlupflöcher sind verboten.
• Wenn möglich, fügen Sie bitte einen Link mit einem Test für Ihren Code (dh TIO ) hinzu.
• Es wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

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

05AB1E , 15 Bytes

Ausgabe ist eine Liste, [space, time]in der 1 für xund 0 für stehtno x

ø€Ë_Psžg.SÙg3Q)

Probieren Sie es online aus!

Erläuterung

    ø                 # 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

Python 2 , 111 109 Bytes

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

Probieren Sie es online aus!

Perl 6 , 47 46 Bytes

-1 Byte dank Nwellnhof

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

Probieren Sie es online aus!

Anonymer Codeblock, der zwei Listen verwendet und ein Tupel von Booleschen Werten zurückgibt, wobei das erste Element angibt, ob Sie in der Zeit gereist sind, und das zweite, ob Sie nicht im Raum gereist sind.

Erläuterung

{                                            }  # 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

Japt, 22 Bytes

Nimmt die Eingabe als 2D-Array von Ganzzahlen für die Raumdimensionen und als 1D-Array von Ganzzahlen für die Jahre auf. Ausgaben nur 2für Raum, nur 1für Zeit, 3für beide und 0für keine.

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

Versuch es

                           :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

Japt , 25 Bytes

Ich bin mir zu 100% sicher, dass dies nicht der beste Ansatz ist, und suche immer noch nach einem kürzeren Weg, dies zu tun: c

Gibt ein Tupel Boolescher Werte zurück. Das erste ist, wenn Sie im Weltraum gereist sind und das zweite, wenn Sie in der Zeit gereist sind

[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

Probieren Sie es online aus!

JavaScript (ES6), 104 100 Byte

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

24% des Codes werden ausgegeben, um herauszufinden, in welchem ​​Jahr wir ... \ 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)

Probieren Sie es online aus!

Kommentiert

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()

R , 106 , 105 Bytes

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))

Probieren Sie es online aus!

Eingabe:

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

Geben Sie einen ganzzahligen Wert aus, der gleich ist:

 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

Stapel, 353 Bytes

@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

Hinweis: Da Kommas in Batch Argumenttrennzeichen sind, müssen Sie zur Eingabe der Raumkoordinaten z

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

Explantation:

@echo off

Schalten Sie unerwünschte Ausgaben aus.

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

Richten Sie zwei Bitmasken ein und extrahieren Sie auch das aktuelle Jahr. (In JJJJ-MM-TT-Gebietsschemas wird %date:~,4%dieselbe Byteanzahl verwendet.)

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

Schleife über alle Argumente. Dies ~bewirkt, dass Koordinatenwerte in separate Parameter aufgeteilt werden.

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

Überprüfen Sie, ob die Bitmasken vollständig gesetzt sind, und geben Sie das entsprechende Ergebnis aus.

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

Überprüfen Sie, ob dies ein Koordinatenpaar oder eine Koordinate und ein Jahr ist.

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

Wenn es sich um eine Koordinate handelt, aktualisieren Sie die Raumbitmaske entsprechend der Frage, ob die relevante räumliche Dimension besucht wurde.

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

Wenn es ein Jahr ist, aktualisieren Sie die Zeitbitmaske entsprechend der Frage, ob die relevante Zeitdimension besucht wurde.

Java 10, 154 Bytes

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;}

Gibt 1für Raum , 2für Zeit , 3für beide , 0für keine zurück . Probieren Sie es hier online aus .

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
}