이 StackOverflow 게시물에서 영감을 얻었 습니다.

소개

Bob의 임무는 스프레드 시트를 작성하고 구성하는 것입니다. 그가 구성하는 방식은 Bob을 제외하고는 거의 알려져 있지 않지만 동일한 그룹에 속하는 각 스프레드 시트 목록을 작성합니다. 그가 만든 스프레드 시트에는 많은 데이터가 있지만 지금보고있는 데이터는 단 하나뿐입니다. 그가이 일을 시작한 날과 스프레드 시트를 만든 날 사이의 일수입니다. 첫날 그는 두 개의 스프레드 시트를 작성 0하여 해당 위치로 분류하고 정렬했습니다.

이제 그의 상사는 매일 어떤 종류의 스프레드 시트가 발생했는지 검토하도록 요청하고 있으며 Bob에게이를 알아낼 코드를 작성하는 것이 당신의 임무입니다. 손으로 할 수있는 스프레드 시트가 너무 많습니다.

입력

Bob이 제공 한 정보는 각 데이텀이 형식 인 (0 또는 1 인덱스) 들쭉날쭉 한 배열의 형태로 제공 x = a[i][j]됩니다. a들쭉날쭉 한 배열 자체라고 부르는 것이 i스프레드 시트의 유형이며 x배열이 작성된 날짜입니다. j중요하지 않습니다.

작업

스프레드 시트 생성 날짜가 유형별로 구성되어있는 들쭉날쭉 한 배열이 지정된 경우 스프레드 시트 생성 일로 구성된 스프레드 시트 유형이 들쭉날쭉 한 배열을 반환합니다.

예

밥은이 추상적 인 데이터 만 남기려고하지 않습니다. 그는 모든 것이 무엇인지 알아내는 데 도움이되는 스프레드 시트 중 일부를 나에게주었습니다.

입력 예 (0 인덱스) :

a = [
[3,2,5,0], # Bob doesn't necessarily sort his lists
[1,3],
[2,1,0,4],
[4,5,3],
[6,6]
]

출력 예 (주석이 필요하지 않은 주석) :

output = [
[0,2] # On day 0, Bob made one type 0 and one type 2 spreadsheet
[1,2] # On day 1, Bob made one type 1 and one type 2 spreadsheet
[0,2] # On day 2, Bob made one type 0 and one type 2 spreadsheet
[0,1,3] # On day 3, Bob made one type 0, one type 1, and one type 3 spreadsheet
[2,3] # On day 4, Bob made one type 2 and one type 3 spreadsheet
[0,3] # On day 5, Bob made one type 0 and one type 3 spreadsheet   
[4,4] # On day 6, Bob made two type 4 spreadsheets
]

Bob이 매일 두 개의 스프레드 시트를 만드는 것은 아니기 때문에 결과물이 들쭉날쭉해질 수 있습니다. 그러나 그는 매일 적어도 하나의 스프레드 시트를 작성하므로 출력에 빈 배열이 포함될 필요는 없습니다. 출력에 빈 배열이 있으면 제거 할 필요는 없습니다.

더 많은 테스트 사례 :

[[3,5,6,2],[0,0,0],[1,0,3,4]] -> [[1,1,1,2],[2],[0],[0,2],[2],[0],[0]]
[[-1]] -> Undefined behavior, as all input numbers will be non-negative integers. 
[[0],[0],[],[0]] -> [[0,1,3]]

출력의 내부 목록은 정렬 할 필요가 없습니다.

항상 그렇듯이 표준 허점이 없으며 물론 가장 짧은 코드가 승리합니다.

(이것이 나의 첫 번째 질문이므로 개선하기 위해 할 수있는 일을 알려주십시오.)

젤리 , 11 10 바이트

FṀ⁸ċþµJ€x"

입력 및 출력은 1 기반입니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 (쉬운 비교를 위해 0 기반).

Pyth, 13 바이트

eMM.ghkSs,RVU

         ,RV      vectorized right map of pair, over:
            UQ      [0, …, len(input) - 1] and
              Q     input
                  (this replaces each date with a [date, type] pair)
        s         concatenate
       S          sort
   .ghk           group by first element (date)
eMM               last element (type) of each sublist

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

Pyth , 14 바이트

ms.e*]k/bdQS{s

테스트 스위트.

Brachylog , 28 바이트

:1f.
cdo:Im:?:2f.
t:.m:Im~h?

설명

• 기본 술어, 입력 ( ?) = 목록 목록

  :1f.              Find all valid outputs of predicate 1 with ? as input
  

• 술어 1 :

  c                 Concatenate the list of lists into a single list
   do               Remove duplicates and sort
     :Im            Take the Ith element of that sorted list
        :?:2f.      Find all valid outputs of predicate 2 with [Element:?] as input
  

• 술부 2 :

  t:.m              Take the (Output)th element of the list of lists
      :Im           Take the Ith element of that list
         ~h?        This element is the element of the input [Element:List of lists]
  

루아, 114 바이트

r={}for i,t in ipairs(...)do for _,v in ipairs(t)do if r[v] then r[v][#r[v]+1]=i else r[v]={i}end end end return r

무시 했어!

Python 2에서의 Dennis의 답변에서 영감을 얻었습니다 .

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

a=>a.map((b,i)=>b.map(j=>(r[j]=r[j]||[]).push(i)),r=[])&&r

CJam ( 30 29 바이트)

Mq~{W):W;{:X)Me]_X=W+X\t}/}/`

온라인 데모

흥미롭게도을 W사용 하는 것보다 해킹하는 것이 더 짧습니다 ee. 주로 색인에 변수가 있기를 원하기 때문입니다. e]먼저 최대 요소를 찾고 빈 배열 m의 배열을 초기화하여 2 바이트를 절약했습니다 m+1.

스택 주위를 저글링하는 대신 값을 저장하여 1 바이트 절약을위한 Martin 에게 감사합니다 X.

NB 후행 빈 배열이 허용되는 경우 스프레드 시트가있는 빈 일 수만큼 배열을 초기화하여 대체 29 바이트 방식이 있습니다.

q~_e_,Ma*\{W):W;{_2$=W+t}/}/`

CJam, 20 바이트

솔루션을 기반으로이 코드를 작성하고 3 바이트를 절약 할 수있게 해 준 Peter Taylor에게 감사합니다.

{ee::f{S*\+S/}:~:.+}

이름이없는 블록은 스택 위에 입력을 예상하고 출력으로 대체합니다.

여기에서 테스트하십시오.

설명

ee    e# Enumerate the input. E.g. if the input is 
      e#   [[3 5 6 2] [0 0 0] [1 0 3 4]]
      e# this gives:
      e#   [[0 [3 5 6 2]] [1 [0 0 0]] [2 [1 0 3 4]]]
::f{  e# The exact details of how this works are a bit tricky, but in effect
      e# this calls the subsequent block once for every spreadsheet and
      e# its correspond index, so the first time we'll have 0 and 3 on the
      e# stack, the next time 0 5, and at the last iteration 2 and 4.
      e# Note that this is a map operation, so we'll end up with an array
      e# on the stack.
  S*  e#   So the stack holds [... index date] now. We start by creating
      e#   a string of 'date' spaces, so "   " on the first iteration.
  \+  e#   We swap this with the index and append the index.
  S/  e#   Now we split this thing on spaces, which gives us 'date' empty
      e#   lists and a list containing the index, e.g. [[] [] [] [0]].
}
:~    e# This flattens the first level of the result, so that we get a list
      e# of all those lists we just created. This is simply one list for
      e# every spreadsheet with its type in the last element.
:.+   e# Finally we fold pairwise concatenation over this list. All the 
      e# empty lists won't affect the result so we'll just end up with all
      e# the types in lists for the correct date.

파이썬 2, 82 바이트

r=[];i=0
for t in input():
 for v in t:r+=[()]*-(~v+len(r));r[v]+=i,
 i+=1
print r

Ideone에서 테스트하십시오 .

Mathematica, 35 바이트

Table[#&@@@#~Position~i,{i,Max@#}]&

비정형 목록을 수락하고 반환하는 명명되지 않은 함수입니다. 1 기반 인덱스를 사용합니다.

고맙게도 Max자동으로 모든 입력을 평탄화하므로 입력이 거친 목록이더라도 마지막 날 색인을 얻습니다. 그런 다음 #&@@@#~Position~i하루 종일 지수 목록을 계산합니다 i. 이 표현식 자체는 i비정형 목록 내부 의 위치를 ​​찾고 (연속 깊이에서 인덱스 배열로 반환), 원하는 값은 각 목록의 첫 번째 값입니다. #&@@@는 #&첫 번째 인수를 반환하는 명명되지 않은 함수 인 각 하위 목록에 적용 하여 모든 하위 목록에서 첫 번째 요소를 검색하는 표준 골프 트릭 입니다.

또는 동일한 바이트 수에 대해 단항 연산자를 정의 할 수 있습니다 (ISO 8859-1로 인코딩 된 소스 파일 가정).

±n_:=#&@@@n~Position~#&~Array~Max@n

자바, 314 바이트

int[][]f(int[][]n){int w=0;Map<Integer,List<Integer>>m=new TreeMap<>();for(int i=0;i<n.length;i++)for(Integer x:n[i]){if(m.get(x)==null)m.put(x,new ArrayList<>());m.get(x).add(i);w=x>w?x:w;}int[][]z=new int[w+1][];for(int i=0,j;i<w+1;i++){z[i]=new int[m.get(i).size()];j=0;for(int x:m.get(i))z[i][j++]=x;}return z;

상세한

public static Integer[][] f(Integer[][]n)
{
    int w=0;
    Map<Integer,List<Integer>>m=new TreeMap<>();

    for(int i=0;i<n.length;i++)
    {
        for(Integer x : n[i])
        {
            if(m.get(x)==null) m.put(x,new ArrayList<Integer>());
            m.get(x).add(i);
            w=x>w?x:w;
        }
    }

    Integer[][]z=new Integer[w+1][];
    for(int i=0,j; i<w+1; i++)
    {
        z[i]=new Integer[m.get(i).size()];
        j=0;for(Integer x : m.get(i))z[i][j++]=x;
    }

    return z;
}

펄 5, 48 바이트

서브 루틴 :

{for$i(0..@_){map{push@{$b[$_]},$i}@{$_[$i]}}@b}

다음과 같이 실제로 작동하십시오.

perl -e'print "@$_$/" for sub{for$i(0..@_){map{push@{$b[$_]},$i}@{$_[$i]}}@b}->([3,2,5,0],[1,3],[2,1,0,4],[4,5,3],[6,6])'