Inspiriert von diesem StackOverflow-Beitrag.

Einführung

Bobs Aufgabe ist es, Tabellen zu erstellen und zu organisieren. Die Art und Weise, wie er sie organisiert, ist nur wenigen bekannt, außer Bob. Er erstellt jedoch eine Liste aller Tabellenkalkulationen, die derselben Gruppe angehören. Das von ihm erstellte Arbeitsblatt enthält eine Reihe von Daten, aber es gibt nur ein einziges Datenelement, das wir derzeit betrachten: Die Anzahl der Tage zwischen dem Tag, an dem er diesen Job gestartet hat, und dem Tag, an dem er das Arbeitsblatt erstellt hat. Am ersten Tag erstellte er zwei Tabellenkalkulationen, notierte beide als 0und sortierte sie an den richtigen Positionen.

Jetzt bittet sein Chef um eine Überprüfung, welche Art von Tabellenkalkulation jeden Tag passiert ist, und es ist Ihre Aufgabe, Code zu schreiben, der das für Bob herausfindet. er hat viel zu viele Tabellenkalkulationen, um es von Hand zu tun.

Eingang

Bobs Informationen, die er Ihnen gibt, werden in Form eines (0 oder 1 indizierten) gezackten Arrays geliefert, wobei jedes Datum von der Form ist x = a[i][j]. aist das, was ich das gezackte Array selbst nenne, iist der Typ der Tabelle und xist das Datum, an dem das Array erstellt wurde. jist unwichtig.

Die Aufgabe

Wenn eine gezackte Reihe von Tabellenkalkulationstagen nach Typ geordnet ist, geben Sie eine gezackte Reihe von Tabellenkalkulationstypen zurück, die nach Tabellenkalkulationstag geordnet sind.

Beispiele

Bob wird Sie nicht einfach mit diesen abstrakten Daten zurücklassen. Er hat mir einen Teil seiner Tabellen gegeben, um Ihnen dabei zu helfen, herauszufinden, was alles sein soll.

Beispieleingabe (0-indiziert):

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

Beispielausgabe (mit Kommentar, der natürlich nicht benötigt wird):

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
]

Beachten Sie, dass Bob nicht immer zwei Tabellen pro Tag erstellt, sodass die Ausgabe möglicherweise auch uneinheitlich ist. Er erstellt jedoch immer mindestens eine Tabelle pro Tag, sodass die Ausgabe niemals leere Arrays enthalten muss. Wenn Ihre Ausgabe am Ende leere Arrays enthält, müssen Sie sie nicht entfernen.

Weitere Testfälle:

[[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]]

Die inneren Listen der Ausgabe müssen nicht sortiert werden.

Wie immer gibt es keine Standardlücken und natürlich gewinnt der kürzeste Code.

(Da dies meine erste Frage ist, lassen Sie mich bitte wissen, was ich tun kann, um sie zu verbessern.)

Jelly , 11 bis 10 Bytes

FṀ⁸ċþµJ€x"

Eingang und Ausgang sind 1-basiert.

Probieren Sie es online! oder überprüfen Sie alle Testfälle (0-basiert zum einfachen Vergleich).

Pyth, 13 Bytes

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

Probieren Sie es online aus

Pyth , 14 Bytes

ms.e*]k/bdQS{s

Testsuite.

Brachylog , 28 Bytes

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

Erläuterung

• Hauptprädikat, Input ( ?) = eine Liste von Listen

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

• Prädikat 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
  

• Prädikat 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]
  

Lua, 114 Bytes

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

Ideone es!

Inspiriert von Dennis 'Antwort in Python 2 .

JavaScript (ES6), 58 Byte

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

CJam ( 30 29 Bytes)

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

Online-Demo

Seltsamerweise ist es kürzer, mit etwas herumzuhacken, Wals es zu benutzen ee, hauptsächlich, weil der Index sowieso in einer Variablen enden soll. e]sparte zwei Bytes über das erste Finden des maximalen Elementsm und ein Array von m+1leeren Arrays zu initialisieren .

Vielen Dank an Martin für die Einsparung von einem Byte, indem er einen Wert speichert, Xanstatt ihn um den Stapel zu jonglieren.

Hinweis: Wenn nachgestellte leere Arrays zulässig sind, können Sie alternativ 29-Byte-Ansätze verwenden, indem Sie das Array mit so vielen leeren Tagen wie Tabellenkalkulationen initialisieren:

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

CJam, 20 Bytes

Vielen Dank an Peter Taylor, der mir ermöglicht hat, diesen Code auf seine Lösung zu stützen und 3 Bytes zu sparen.

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

Ein unbenannter Block, der die Eingabe über dem Stapel erwartet und durch die Ausgabe ersetzt.

Teste es hier.

Erläuterung

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.

Python 2, 82 Bytes

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

Teste es auf Ideone .

Mathematica, 35 Bytes

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

Eine unbenannte Funktion, die eine uneinheitliche Liste akzeptiert und zurückgibt. Verwendet 1-basierte Indizes.

Dankenswerterweise Maxwerden alle Eingaben automatisch geglättet, sodass wir den Index für den letzten Tag erhalten, obwohl es sich bei der Eingabe um eine uneinheitliche Liste handelt. Wir berechnen dann einfach eine Liste #&@@@#~Position~ialler Tagesindizesi . Dieser Ausdruck selbst findet die Position iinnerhalb der uneinheitlichen Liste (Rückgabe als ein Array von Indizes in aufeinanderfolgenden Tiefen), sodass die gewünschten Werte die ersten Werte jeder dieser Listen sind. #&@@@ist ein Standardtrick zum Golfen, um das erste Element aus jeder Unterliste abzurufen, indem es #&auf jede dieser Unterlisten angewendet wird. Dies ist eine unbenannte Funktion, die ihr erstes Argument zurückgibt.

Alternativ können wir einen unären Operator für dieselbe Bytezahl definieren (unter der Annahme einer ISO 8859-1-codierten Quelldatei):

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

Java, 314 Bytes

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;

Detailliert

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

Perl 5, 48 Bytes

Ein Unterprogramm:

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

Sehen Sie es in Aktion wie folgt:

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