Introducción:

En general solemos hablar de cuatro dimensiones: tres dimensiones espaciales para x, yy z; y una dimensión de tiempo. Por el bien de este reto, sin embargo, vamos a dividir la dimensión temporal en tres así: past, present, y future.

Entrada:

Dos listas de entrada. Uno que contiene x,y,zcoordenadas enteras y otro que contiene años enteros

Salida:

Una de las cuatro salidas distintas y constantes de su elección. Uno para indicar la salida space; uno para indicar la salida time; uno para indicar la salida both space and time; y uno para indicar la salida neither space nor time.

Indicaremos que fuimos a las tres dimensiones espaciales si las diferencias de las tuplas enteras no son 0 para las tres dimensiones.
Indicaremos que fuimos a las tres dimensiones de tiempo si hay al menos un año en el pasado, al menos un año en el futuro y al menos un año igual al año actual (por lo tanto, en el presente).

Ejemplo:

Entrada:
Lista de coordenadas: [{5,7,2}, {5,3,8}, {-6,3,8}, {5,7,2}]
Lista de años:[2039, 2019, 2018, 2039, 2222]

Salida:
constante paraspace

¿Por qué?
Las xcoordenadas son [5,5,-6,5]. Como no son todos iguales, hemos pasado por la xdimensión espacial.
Las ycoordenadas son [7,3,3,7]. Como no son todos iguales, también hemos pasado por la ydimensión espacial.
Las zcoordenadas son [2,8,8,2]. Como no son todos iguales, también hemos pasado por la zdimensión espacial.
El año actual es 2018. No hay años antes de esto, por lo que no visitamos la pastdimensión del tiempo.
Hay un 2018regalo en la lista de años, así que visitamos la presentdimensión del tiempo.
Hay varios años arriba 2018( [2039, 2019, 2039, 2222]), por lo que también visitamos la futuredimensión del tiempo.

Como hemos visitado las tres spacedimensiones, pero solo dos de las tres timedimensiones, la salida solo será (la constante para) space.

Reglas de desafío:

• Puede usar cuatro salidas distintas y constantes para los cuatro estados posibles.
• La entrada puede estar en cualquier formato razonable. La lista de coordenadas puede ser tuplas, listas internas / matrices de tamaño 3, cadenas, objetos, etc. La lista de años puede ser una lista de objetos de fecha en lugar de números enteros también si beneficiaría su recuento de bytes.
• Puede suponer que las x,y,zcoordenadas serán enteras, por lo que no es necesario manejar decimales de coma flotante. Cualquiera de los x, y, y / o zcoordenadas pueden ser valores negativos, sin embargo.
• No puede tomar las listas de entrada pre ordenadas. Las listas de entrada deben estar en el orden que se muestra en los casos de prueba.
• Puede asumir que todos los valores del año estarán en el rango [0,9999]; y puede asumir que todas las coordenadas están en el rango [-9999,9999].
• Si su idioma no tiene NINGUNA forma de recuperar el año en curso, pero aún así le gustaría hacer este desafío, puede tomarlo como entrada adicional y marcar su respuesta como (no competitiva) .

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

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

La salida es una lista [space, time]donde 1 representa xy 0 representano x

ø€Ë_Psžg.SÙg3Q)

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Perl 6 , 47 46 bytes

-1 byte gracias a nwellnhof

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

Pruébalo en línea!

Bloque de código anónimo que toma dos listas y devuelve una tupla de booleanos, siendo el primer elemento si viajó en el tiempo y el segundo si no viajó en el espacio.

Explicación

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

Toma datos como una matriz 2D de enteros para las dimensiones del espacio y una matriz 1D de enteros para los años. Salidas 2solo para espacio, solo 1para tiempo, 3para ambos y 0para ninguno.

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

Intentalo

                           :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

Estoy 100% seguro de que este no es el mejor enfoque, todavía estoy buscando una forma más corta de hacer esto: c

Devuelve una tupla de booleanos. La primera es si viajaste en el espacio y la segunda si viajaste en el tiempo

[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

Pruébalo en línea!

JavaScript (ES6), 104100 bytes

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

El 24% del código se gasta para determinar en qué año estamos ... \ 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)

Pruébalo en línea!

Comentado

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

Pruébalo en línea!

Entrada:

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

Salida de un valor entero igual a:

 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

Lote, 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

Nota: Dado que las comas son separadores de argumentos en Batch, para ingresar las coordenadas de espacio, debe citar y, por ejemplo,

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

Explantación

@echo off

Apague la salida no deseada.

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

Configure dos máscaras de bits y también extraiga el año actual. (En YYYY-MM-DD, las configuraciones regionales se usan %date:~,4%para el mismo recuento de bytes).

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

Recorre todos los argumentos. Las ~causas valores de las coordenadas se dividan en los diferentes parámetros.

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

Compruebe si las máscaras de bits están completamente configuradas y generan el resultado apropiado.

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

Vea si se trata de un par de coordenadas o una coordenada y un año.

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

Si se trata de una coordenada, actualice la máscara de bits de espacio según se haya visitado la dimensión espacial relevante.

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

Si es un año, actualice la máscara de bits de tiempo según se haya visitado la dimensión de tiempo relevante.

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

Devuelve 1por espacio , 2por tiempo , 3por ambos , 0por ninguno . Pruébelo en línea aquí .

Sin golf:

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
}