소개:

세 개의 공간 차원을 위해 : 일반적으로 우리는 보통 4 차원의 이야기 x, y그리고 z; 그리고 한 번의 차원. 그러나이 도전을 위해, 우리는뿐만 아니라 세에 시간 차원을 나눌 수 있습니다 : past, present,와 future.

입력:

두 개의 입력 목록. 하나는 정수 x,y,z좌표를 포함 하고 다른 하나는 정수 연도를 포함합니다.

산출:

네 가지 독특하고 지속적인 네 가지 출력 중 하나. 하나는 출력을 나타냅니다 space. 출력을 나타내는 하나 time; 출력을 나타내는 하나 both space and time; 하나는 출력을 나타냅니다 neither space nor time.

정수 튜플의 차이가 세 차원 모두에 대해 0이 아닌 경우 세 가지 공간 차원으로 갔다는 것을 나타냅니다.
과거에 1 년 이상, 미래에 1 년 이상, 현재 연도와 같은 1 년 이상 (현재와 같이)이있는 경우 3 개 시간 차원으로 모두 이동했음을 나타냅니다.

예:

입력 :
좌표 목록 : [{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

3 space차원을 모두 방문 했지만 3 차원 중 2 개만 방문 했으므로 time출력은 (상수) 만 space됩니다.

도전 규칙 :

• 네 가지 가능한 상태에 대해 네 개의 고유하고 일정한 출력을 사용할 수 있습니다.
• 적절한 형식으로 입력 할 수 있습니다. 좌표 목록은 튜플, 크기 3의 내부 목록 / 배열, 문자열, 객체 등일 수 있습니다. 연도 목록은 바이트 수에 도움이되는 경우 정수 대신 날짜-객체 목록 일 수 있습니다.
• x,y,z좌표가 정수 라고 가정 할 수 있으므로 부동 소수점 10 진수를 처리 할 필요가 없습니다. 임의의 x, y및 / 또는 z좌표 비록 음수 일 수있다.
• 입력 목록을 사전 주문할 수 없습니다. 입력 목록은 테스트 사례에 표시된 순서대로 있어야합니다.
• 모든 연도 값이 범위 내에 있다고 가정 할 수 있습니다 [0,9999]. 모든 좌표가 범위 내에 있다고 가정 할 수 있습니다 [-9999,9999].
• 귀하의 언어에 현재 연도를 검색 할 수있는 방법이 없지만 여전히이 과제를 원한다면 추가 입력으로 받아 답변을 (비경쟁) 으로 표시하십시오 .

일반 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙 은 기본 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

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

파이썬 (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*

온라인으로 사용해보십시오!

펄 6 , 47 46 바이트

nwellnhof 덕분에 -1 바이트

{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

apt, 22 바이트

공간 치수에 대한 정수의 2D 배열 및 수년간 정수의 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

apt , 25 바이트

나는 이것이 최선의 접근 방법이 아니라고 100 % 확신하지만 여전히이 작업을 수행하는 더 짧은 방법을 찾고 있습니다 .c

부울의 튜플을 반환합니다. 첫 번째는 우주를 여행 한 경우이고 두 번째는 시간을 여행 한 경우입니다

[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

온라인으로 사용해보십시오!

자바 스크립트 (ES6) 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()

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

배치, 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

외식 :

@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대한 도 . 여기에서 온라인으로 사용해보십시오 .

언 골프 드 :

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
}