두 목록의 교차점을 설정


10

목표는 두 정수 목록의 교집합을 계산하는 것입니다. 교집합은 두 입력 목록에서 한 번 이상 발견 된 순서가없는 고유 한 정수 그룹으로 정의됩니다.

입력

입력은 원하는 형식 (함수 매개 변수, stdio 등) 일 수 있으며 두 개의 정수 목록으로 구성됩니다. 음수가 아닌 정수를 포함 할 수있는 것 (즉, 정렬되지 않았거나 중복을 포함하거나 길이가 다를 수 있으며 비어있을 수도 있음) 외에 각 목록에 대해 아무 것도 가정하지 않습니다. 각 정수는 사용자 언어의 고유 부호있는 정수 유형에 적합하고 10 진수 이상의 길이 일 수 있으며 부호가있는 것으로 가정합니다.

입력 예 :

1 4 3 9 8 8 3 7 0
10 1 4 4 8 -1

산출

출력은 두 목록이 원하는 형식 (반환 값, stdio 등)으로 설정된 교차점을 나타내는 정수와 같은 목록과 같습니다. 출력이 정렬 될 필요는 없지만 항상 정렬되는 구현을 제공 할 수 있습니다. 출력은 순서가없는 유효한 세트를 구성해야합니다 (예 : 중복 값을 포함하지 않아야 함).

테스트 사례 예 (출력 순서는 중요하지 않음) :

처음 두 줄은 입력 목록이고 세 번째 줄은 출력입니다. (empty)빈 목록을 나타냅니다.

(empty)
(empty)
(empty)

1000
(empty)
(empty)

3 1 2 4 3 1 1 1 1 3
3 1 -1 0 8 3 3 1
1 3

1 2 1
3 3 4
(empty)

채점

이것은 코드 골프입니다. 바이트 단위의 최단 답변이 이깁니다.

표준 루프 홀은 금지되어 있습니다. 세트 형 작업용으로 설계되지 않은 내장 기능을 사용할 수 있습니다.

금지 된 내장 기능 :

  • 복제본 생성 / 제거 설정
  • 차이 / 교차점 / 연합 설정
  • 일반화 된 멤버쉽 테스트 (예 : inPython 의 키워드 indexOf와 유사한 기능, 비슷한 함수 등) 파이썬이 in키워드를 재사용 하여이 구문을 생성 한다는 사실에도 불구하고 "foreach item in list"구문의 사용은 허용됩니다 (다른 제한을 위반하지 않는다고 가정) .
  • 이러한 금지 된 내장 기능은 "바이러스 성"입니다. 즉, 이러한 하위 기능을 포함하는 더 큰 내장 기능이있는 경우 이와 유사하게 금지됩니다 (예 : 목록의 구성원 별 필터링).

위의 목록에없는 내장 기능 (예 : 정렬, 정수 동등성 테스트, 인덱스 별 목록 추가 / 제거, 필터링 등)이 허용됩니다.

예를 들어, 다음 두 가지 예제 스 니펫 (Python과 유사한 코드)을 사용하십시오.

# prohibited: filters by testing if each value in tmpList is a member of listA
result = tmpList.filter(listA)

# ok: filtering by a lambda which manually iterates over listA and checks for equality
def my_in_func(val, slist):
    for a in slist:
        if(val == a):
            return True
    return False
result = filter(lambda v: my_in_func(val, listA), tmpList)

이러한 세트와 같은 기능을 직접 구현할 수 있으며 점수에 반영됩니다.

솔루션은 합리적인 시간 내에 완료해야합니다 (예 : 두 개의 목록 (길이가 각각 1000) 인 모든 하드웨어에서 1 분 미만).


5
그건 그렇고, 혼란과 오해는 Y가없는 X 에서 일반적 이므로 챌린지를 작성할 때 피해야 할 것 중 하나입니다 .
Dennis

2
@Dennis 그래, 나는이 문제가 실제로 그중 하나가되었다고 생각한다.
helloworld922

런 길이 인코딩을 수행하는 내장이 허용됩니까?
isaacg

그렇게하는 게 좋겠습니다.
helloworld922

1
출력에 중복이있을 수 있습니까?
Adám

답변:



4

MATL , 18 바이트

YY_iti!=Xa)hStdfQ)

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

이것은 두 단계로 작동합니다. 먼저 교차점을 계산합니다. 이는 한 배열의 모든 요소를 ​​다른 배열의 모든 요소와 비교하고 두 번째에있는 첫 번째 요소를 유지하는 것을 기반으로합니다.

그런 다음 중복이 제거됩니다. 이를 위해 이전 단계의 배열이 정렬되고 이전과 다른 경우 항목이 유지됩니다. -inf첫 번째 (즉, 가장 낮은) 값이 손실되지 않도록 값 앞에 추가됩니다.

YY_                 % push -infinity
   it               % take first input. Duplicate
     i!             % take second input. Transpose
        =           % test all combinations of elements of the two inputs for equality
        Xa          % row vector that contains true for elements of first array that 
                    % are present in the second, possibly duplicated
          )         % index into first array to keep only those elements. Now we need
                    % to remove duplicates
           h        % append -infinity
            S       % sort
             tdf    % duplicate. Find entries that differ from the preceding
                Q)  % add 1 and index into array to keep only non-duplicates

4

젤리, 13 바이트

=S¥Ðf
ṂrṀ{ç³ç

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

작동 원리

ṂrṀ{ç³ç  Main link. Arguments: A (list 1), B (list 2)

Ṃ        Yield m, the minimum of A.
  Ṁ{     Yield M, the maxmimum of A.
 r       Create an inclusive range from m to M.
    f³   Apply the helper link with right argument A.
      f  Apply the helper link with right argument B.


=S¥Ðf    Helper link. Arguments: n (integer in range), L (list, A or B)

=        Test all elements of L for equality with n.
 S       Add the results.
  ¥      Combine the two previous links into a dyadic chain.
   Ðf    Filter by the result of the sums.

@isaacg 수정되었습니다.
Dennis

3

golflua , 68 자

\f(a,b)k={}~@_,v p(a)~@_,w p(b)?w==v k[w]=w$$$~@_,v p(k)I.w(v," ")$$

이것은

> f({1,2,3,4},{3,4,5})
3 4
> f({3,1,2,4,3,1,1,1,1,3},{3,1,-1,0,8,3,3,1})
3 1

정기적 인 루아에서는

function foo(a,b)
   local k={}
   for i,v in pairs(a)
      for j,w in pairs(b)
         if v==w then
            k[v] = v
         end
      end
   end
   for i,v in pairs(k)
      print(v," ")
   end
end

따라서 기본적으로 두 테이블의 각 요소를 반복하고 동등한 값만 저장합니다. 값을 키 ( k[w]=w) 로 사용 함으로써 모든 중복을 제거합니다. 그런 다음 인덱스 및 값을 반복하여 새 테이블을 출력합니다.pairs


3

자바 스크립트 (ES6), 66 바이트

(a,b)=>a.filter((e,i)=>b.some(f=>e==f)&a.slice(0,i).every(f=>e-f))

을 사용하지 않으면 indexOf허용된다고 확신하지 못합니다.


3

Pyth, 12 11 바이트

eMrSsq#RQE8

데모

설명:

eMrSsq#RQE8
               Implicit: Q is one of the lists.
     q#RQE     For every element in the first list, filter the second list on
               equality with that element.
    s          Concatenate. We now have the intersection, with duplicates.
  rS      8    Sort and run length encode, giving counts and elements.
eM             Take just the elements.

정렬 및 rle은 1 바이트를 절약합니다.
Jakube

@Jakube 나는 rle이 중복을 제거하는 내장이라고 말합니다.
isaacg

이전에 정렬하고 나중에 rle의 수를 제거하면 중복이 제거됩니다. 회색 영역에는 약간 있지만 사전을 사용하고 있다고 생각합니다. 기본적으로 각 요소에 대한 추가 데이터를 저장하는 세트입니다.
Jakube

@Jakube OP는 괜찮다고 말합니다. 감사!
isaacg

2

bash + GNU coreutils, 184 바이트

[ -z "$1" ] && exit
p='{if(a[$0]++==0)print $0}'
while read A; do
while read B; do
[ $A = $B ] && echo $A
done < <(grep -oP '\d*'<<<$1|awk "$p")
done < <(grep -oP '\d*'<<<$2|awk "$p")

기도:

./codegolf.sh '12 4 654 12 3 56' '4 4 56 33 3 3 3'

산출:

4
56
3

교차점이 비어 있으면 출력이 없습니다. 이 스크립트는 첫 번째 세트가 비어 있으면 정렬하지 않고 상태 점검을 수행합니다. 설명:

[ -z "$1" ] && exit  # Exit if first set is empty
p='{if(a[$0]++==0)print $0}' # The AWK program we will use
while read A; do   # read the list with two
while read B; do   # encapsulated loops
[ $A = $B ] && echo $A   # if they match, then print
done < <(grep -oP '\d*'<<<$1|awk "$p")
done < <(grep -oP '\d*'<<<$2|awk "$p")
# the process substitution greps the numbers and pipes them to awk. Our awk program makes them unique without sorting; it uses associative arrays with index names same as lines (our numbers here).

알아 두어야 할 보너스 : grep -o .숫자 대신 임의의 문자열 로 이를 수행하도록 변경할 수 있습니다 .


2

펄 6, 26 37 바이트

{%(@^a.grep(any(@^b)):p.invert).keys}

용법

> my &f = {%(@^a.grep(any(@^b)):p.invert).keys}
-> @a, @b { #`(Block|559823336) ... }
> f([3,1,2,4,3,1,1,1,1,3], [3,1,-1,0,8,3,3,1])
(1 3)

건방진 비경쟁 답변

> [3,1,2,4,3,1,1,1,1,3]  [3,1,-1,0,8,3,3,1]
set(3, 1)

또는 당신이 지루한 ol f기능 에서 그것을 좋아한다면

> my &f = &infix:<∩>
sub infix:<∩> (|p is raw) { #`(Sub+{<anon|130874592>}+{Precedence}|102325600) ... }
> f([3,1,2,4,3,1,1,1,1,3], [3,1,-1,0,8,3,3,1])
set(3, 1)

.unique를 사용하지 않도록 답변을 업데이트했습니다
Hotkeys

1
invert값을 대신 사용하면 실제로 필요하지 않습니다 . 24 바이트
Jo King

2

레티 나 , 63 바이트

마지막 두 줄은 중복을 제거합니다. 입력은 공백으로 구분 된 두 개의 목록이며 쉼표로 구분됩니다. 출력은 공백으로 구분됩니다.

+`( -?\d+)\b(.*,.*)\1\b
$1_$2
-?\d+\b|_|,

+`(-?\d+)(.*)\1
$1$2

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

출력에 중복이 허용되면 내 프로그램은 42 바이트입니다.


2

Jq 1.5 , 99 바이트

def f(a;b):(a+b|min)as$m|[range($m;a+b|max)|[]]|.[a[]-$m][0]=1|.[b[]-$m][1]=1|.[[[1,1]]]|map(.+$m);

넓히는

def f(a;b):
     (a+b|min) as $m         # find smallest value in either array
   | [range($m;a+b|max)|[]]  # create array of [] for indices [min,max]
   | .[ a[]-$m ][0]=1        # store 1 in [0] at corresponding indices of a
   | .[ b[]-$m ][1]=1        # store 1 in [1] at corresponding indices of b
   | .[[[1,1]]]              # find all the indices where we stored a 1 for a and b
   | map(.+$m)               # convert back from indices to values
;

이것은 {}객체 사용을 피하고 jq에는 비트 연산이 없으므로 배열로 객체를 에뮬레이트합니다.

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


2

공리, 411 바이트

b(x,v)==(l:=1;h:=#v;repeat(l>h=>break;m:=(l+h)quo 2;x<v.m=>(h:=m-1);x>v.m=>(l:=m+1);return m);0);g(a,b)==(if #a>#b then(v:=a;w:=b)else(v:=b;w:=a);c:=sort(v);for x in w repeat(if binSearch(x,c)~=0 then return 1);0)
f(a:List INT,b:List INT):List INT==(r:List INT:=[];#a*#b=0=>r;x:=sort(a);y:=sort(b);i:=1;repeat(i>#x=>break;v:=x.i;binSearch(v,y)=0=>(i:=i+1);r:=concat(r,v);while i<=#x and x.i=v repeat i:=i+1);r)

풀고 테스트

--suppose v.1<=v.2<=....<=v.#v as the default function sort() produce
--   binary serch of x in v, return the index i with v.i==x
--   return 0 if that index not exist
--traslated in Axiom from C  book
--Il Linguaggio C, II Edizione 
--Brian W.Kerninghan, Dennis M.Ritchie
binSearch(x,v)==
    l:=1;h:=#v
    repeat
       l>h=>break
       m:=(l+h)quo 2
       x<v.m=>(h:=m-1) 
       x>v.m=>(l:=m+1)
       return m
    0

--N*log(N)+n*log(n)+N*n*log(n) so it is N*n*log(n) or n*N*log(N)
ListIntersection(a:List INT,b:List INT):List INT==
    r:List INT:=[];#a*#b=0=>r
    x:=sort(a);y:=sort(b)
    i:=1
    repeat
        i>#x=>break
        v:=x.i
        binSearch(v,y)=0=>(i:=i+1)
        r:=concat(r,v)
        while i<=#x and x.i=v repeat i:=i+1
    r

(5) -> f([],[])
   (5)  []
                                                       Type: List Integer
(6) -> f([1000],[])
   (6)  []
                                                       Type: List Integer
(7) -> f([3,1,2,4,3,1,1,1,1,3],[3,1,-1,0,8,3,3,1])
   (7)  [1,3]
                                                       Type: List Integer
(8) -> f([1,2,1],[3,3,4])
   (8)  []
                                                       Type: List Integer

2

공리, 257 바이트

W(x,y)==>while x repeat y;f(a,b)==(r:List INT:=[];#a*#b=0=>r;x:=sort(a);y:=sort(b);i:=1;j:=1;repeat(j>#y=>break;W(i<=#x and x.i<y.j,i:=i+1);i>#x=>break;W(j<=#y and y.j<x.i,j:=j+1);j>#y=>break;v:=y.j;if x.i=v then(r:=concat(r,v);W(j<=#y and y.j=v,j:=j+1)));r)

이것은 binsearch를 사용하지 않고 ... 그러나 나는 큰 O를 모른다 ... Unglofed and results :

--N*log(N)+n*log(n)+???
ListIntersection(a:List INT,b:List INT):List INT==
    r:List INT:=[];#a*#b=0=>r
    x:=sort(a);y:=sort(b)
    i:=1;j:=1
    repeat
        j>#y=>break
        while i<=#x and x.i<y.j repeat i:=i+1
        i>#x=>break
        while j<=#y and y.j<x.i repeat j:=j+1
        j>#y=>break
        v:=y.j;if x.i=v then 
                        r:=concat(r,v)
                        while j<=#y and y.j=v repeat j:=j+1
    r

(3) -> f([3,1,2,4,3,1,1,1,1,3],[3,1,-1,0,8,3,3,1])
   (3)  [1,3]
                                                       Type: List Integer
(4) -> f([],[])
   (4)  []
                                                       Type: List Integer
(5) -> f([1,2,1],[3,3,4])
   (5)  []
                                                       Type: List Integer

많은 테스트를 실행하지 않았으므로 버그가 생길 수 있습니다 ...


2

젤리 , 12 바이트

pEÐfḢ€ĠḢ€$ị$

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


Tio 3,1,2,4,3,1,1,1,1,3 입력 및 3 입력에서 [3] 대신 출력 [1,2,3]을 반환
RosLuP

@RosLuP [3]대신 시도3
HyperNeutrino

2리스트의 교차 결과가 (다른 경우와 같이) 반환되면 [] 결과가 무효로 설정되면 [1], 2리스트에 공통으로 1이 있으면 [1]
RosLuP

@RosLuP 나는 그것을 도울 수 없다. 그것이 Jelly가 출력하는 방식이다. []단일 목록의 경우 및 비어 있음 Wiki 페이지 (원자)로 이동하여 Python Stringify 내장 기능을 추가 할 수 있지만 답변이 길고 엄격한 I / O가 멍청 해집니다.
HyperNeutrino

[] 방식으로 입력 List 만 허용하고 (예 [1], [1,2,3] [], [], [] 등)리스트 출력 만 List [] 방식으로 출력하면 괜찮습니다. (입력으로). list의 괄호가 {} 또는 () 인 경우 올바른 말에 대해 위의 연설을 반복하십시오. 이 단지 내가 무슨 생각하는지에 대한 질문은 아마도 다른 말을하고 모든 괜찮
RosLuP

2

껍질 , 9 바이트

mo←←kIfE*

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

m            Map
 o←←         taking the first element from the first element
    kI       over lists of identical values from
        *    the Cartesian product of the two input lists
      f      filtered by
       E     both elements of a pair being equal.

GitHub에서 Husk의 소스 코드를 살펴보면 k( "keyon")은 목록을 정렬하고 인접 값을 그룹화하는 구성으로 구현되므로 실제로 "groupOn"의 구현을 찾을 수는 없지만 실제로 "groupOn"을 구현할 수는 없다고 가정하는 것이 안전합니다. Haskell은 기능적 언어이며 인접한 동일한 값을 그룹화하는 것은 매우 간단한 링크 목록 작업입니다. ( 로 변경 하여 여기에서 사용할 수있는 '기타 유형 서명'keyby '의 구현을 찾을 있지만 kHaskell을 모르므로 정확히 어떻게 작동하는지 알 수 없습니다.)I=

또한 모든 종류의 세트 작업이 허용되지 않음을 깨닫기 전에 생각해 낸 멋진 Brachylog 답변 : ⟨∋∈⟩ᵘ


2

아르 자형, 141 83 바이트

l=sapply(strsplit(readLines(file("stdin"))," "),as.numeric)
r=rle(sort(unlist(l)))[[2]]
r[sapply(r,function(x)any(x==l[[1]])&any(x==l[[2]]))]

주세페 향상

function(a,b){r=rle(sort(c(a,b)))[[2]];r[sapply(r,function(x)any(x==a)&any(x==b))]}

온라인으로 시도 여기 여기


작동하지 않는 것 같습니다. 그래도 잘못 사용하려고 시도하고 있으므로 온라인 사용해보기 링크를 제공해야합니다 ! 그것을 사용하는 방법을 보여주고 도전의 요구 사항을 충족한다는 것을 보여줍니다. (답변에 대한 설명도 아프지 않을 것입니다.)
관련없는 문자열

입력을 가정 할 수없고 사전 정의 a되어 b있으므로 입력을 함수 인수 또는 STDIN에서 가져와야합니다.
Giuseppe

1
골퍼가이 기능을 다음 과 같은
Giuseppe

1
@db "header"는 "Code"섹션에 정의 된 익명 함수의 이름을 지정하고 (익명 함수는 완벽하게 허용됨) 바닥 글은이를 호출합니다. Header, Code 및 Footer 섹션은 모두 하나의 코드이지만 "code"섹션의 일부만 바이트 수로 계산됩니다. –)
Giuseppe

1

Python3, 51 바이트

lambda a,b:[v for v in a if{n:1 for n in b}.get(v)]

입력 목록에 중복이 포함될 수있는 경우 :

Python3, 67 바이트

lambda a,b:list({v:1 for v in a if {n:1 for n in b}.get(v)}.keys())

1

PHP ,78, 77 바이트

function($a,$b){foreach($a as$x)foreach($b as$y)$x==$y?$c[$x]=$x:0;return$c;}

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

주름은 없지만 규칙을 준수합니다 (제 생각에).

산출

[], []
[]

[1000], []
[]

[3,1,2,4,3,1,1,1,1,3], [3,1,-1,0,8,3,3,1]
[3,1]

[1,2,1], [3,3,4]
[]
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.