Introduction:

En général , nous parlons généralement de quatre dimensions: trois dimensions de l' espace pour x, yet z; et une dimension temporelle. Par souci de ce défi cependant, nous allons séparer la dimension du temps en trois ainsi: past, presentet future.

Contribution:

Deux listes d'entrées. Un contenant des x,y,zcoordonnées entières et un contenant des années entières.

Production:

L'une des quatre sorties distinctes et constantes de votre choix. Un pour indiquer la sortie space; un pour indiquer la sortie time; un pour indiquer la sortie both space and time; et un pour indiquer la sortie neither space nor time.

Nous indiquerons que nous sommes passés aux trois dimensions d'espace si les différences des tuples entiers ne sont pas égales à 0 pour les trois dimensions.
Nous indiquerons que nous sommes passés aux trois dimensions temporelles s'il y a au moins une année dans le passé, au moins une année dans le futur et au moins une année égale à l'année en cours (donc dans le présent).

Exemple:

Entrée:
Liste des coordonnées: [{5,7,2}, {5,3,8}, {-6,3,8}, {5,7,2}]
Liste des années:[2039, 2019, 2018, 2039, 2222]

Sortie:
constante pourspace

Pourquoi?
Les xcoordonnées sont [5,5,-6,5]. Puisqu'ils ne sont pas tous pareils, nous sommes passés par la xdimension spatiale.
Les ycoordonnées sont [7,3,3,7]. Puisqu'ils ne sont pas tous pareils, nous sommes également passés par la ydimension spatiale.
Les zcoordonnées sont [2,8,8,2]. Puisqu'ils ne sont pas tous pareils, nous sommes également passés par la zdimension spatiale.
L'année en cours est 2018. Il n'y a pas d'années avant cela, nous n'avons donc pas visité la pastdimension temporelle.
Il y a un 2018cadeau dans la liste des années, nous avons donc visité la presentdimension temporelle.
Il y a plusieurs années au-dessus 2018( [2039, 2019, 2039, 2222]), nous avons donc également visité la futuredimension temporelle.

Puisque nous avons visité les trois spacedimensions, mais seulement deux des trois timedimensions, la sortie ne sera que (la constante de) space.

Règles du défi:

• Vous pouvez utiliser quatre sorties distinctes et constantes pour les quatre états possibles.
• L'entrée peut être dans n'importe quel format raisonnable. La liste des coordonnées peut être des tuples, des listes / tableaux internes de taille 3, des chaînes, des objets, etc.
• Vous pouvez supposer que les x,y,zcoordonnées seront des entiers, donc pas besoin de gérer les décimales à virgule flottante. Tout du x, yet / ou les zcoordonnées peuvent être des valeurs négatives, cependant.
• Vous ne pouvez pas prendre les listes d'entrées pré-commandées. Les listes d'entrées doivent être dans l'ordre affiché dans les cas de test.
• Vous pouvez supposer que toutes les valeurs de l'année seront dans la plage [0,9999]; et vous pouvez supposer que toutes les coordonnées sont dans la plage [-9999,9999].
• Si votre langue n'a AUCUN moyen de récupérer l'année en cours, mais que vous souhaitez toujours relever ce défi, vous pouvez le prendre comme entrée supplémentaire et marquer votre réponse comme (non concurrente) .

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues non-golfeur de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse avec des règles d'E / S par défaut , vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code (par exemple TIO ).
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de test:

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 octets

La sortie est une liste [space, time]où 1 signifie xet 0 signifieno x

ø€Ë_Psžg.SÙg3Q)

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

Perl 6 , 47 46 octets

-1 octet grâce à nwellnhof

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

Essayez-le en ligne!

Bloc de code anonyme qui prend deux listes et renvoie un tuple de booléens, le premier élément étant de savoir si vous avez voyagé dans le temps, et le second si vous n'avez pas voyagé dans l'espace.

Explication

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

Prend en entrée un tableau 2D d'entiers pour les dimensions de l'espace et un tableau 1D d'entiers pour les années. Sorties 2pour l'espace uniquement, 1pour le temps uniquement, 3pour les deux et 0pour aucun.

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

Essayez-le

                           :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 octets

Je suis sûr à 100% que ce n'est pas la meilleure approche, toujours à la recherche d'un moyen plus court de le faire: c

Renvoie un tuple de booléens. Le premier est si vous avez voyagé dans l'espace et le second si vous avez voyagé dans le temps

[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

Essayez-le en ligne!

JavaScript (ES6), 104 100 octets

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

24% du code est dépensé pour déterminer en quelle année nous sommes ... \ 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)

Essayez-le en ligne!

Commenté

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 octets

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

Essayez-le en ligne!

Contribution :

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

Génère une valeur entière égale à:

 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

Lot, 353 octets

@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

Remarque: Étant donné que les virgules sont des séparateurs d'arguments dans Batch, afin de saisir les coordonnées spatiales, vous devez les citer, par exemple

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

Explantion:

@echo off

Désactivez la sortie indésirable.

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

Configurez deux masques de bit et extrayez également l'année en cours. (Dans les paramètres régionaux AAAA-MM-JJ, utilisez%date:~,4% le même nombre d'octets.)

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

Faites une boucle sur tous les arguments. Cela ~provoque la division des valeurs de coordonnées en paramètres séparés.

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

Vérifiez si les masques de bits sont entièrement définis et générez le résultat approprié.

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

Voyez s'il s'agit d'une paire de coordonnées ou d'une coordonnée et d'une année.

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

S'il s'agit d'une coordonnée, mettez à jour le masque de bits d'espace selon que la dimension spatiale pertinente a été visitée.

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

S'il s'agit d'une année, mettez à jour le masque de bits temporel selon que la dimension temporelle pertinente a été visitée.

Java 10, 154 octets

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

Retourne 1pour l' espace , 2pour le temps , 3pour les deux , 0pour aucun . Essayez-le en ligne ici .

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