Bu StackOverflow yayınından ilham alındı .

Giriş

Bob'un işi elektronik tablolar oluşturmak ve bunları organize etmektir. Onları organize etme şekli Bob dışında çok az kişi tarafından bilinir, ancak aynı gruba giren her bir elektronik tablonun bir listesini oluşturur. Oluşturduğu e-tabloda bir sürü veri var, ancak şu anda baktığımız tek bir veri parçası var: Bu işe başladığı gün ile e-tabloyu yaptığı gün arasındaki gün sayısı. İlk gün iki e-tablo oluşturdu, ikisini de not etti 0ve uygun yerlerine sıraladı.

Şimdi, patronu her gün ne tür bir e-tablo olduğunu gözden geçirmeyi istiyor ve Bob için bunu anlayacak bir kod yazmak sizin işiniz; elle yapmak için çok fazla e-tablo var.

Giriş

Bob'un size verdiği bilgi, her datumun formda olduğu bir (0 veya 1 endeksli) pürüzlü dizi şeklinde gelir x = a[i][j]. apürüzlü dizinin kendisini çağırdığım işey, elektronik tablonun türü xve dizinin oluşturulduğu tarihtir. jönemsizdir.

Görev

Türlerine göre düzenlenmiş tırtıklı bir e-tablo oluşturma günleri göz önüne alındığında, e-tablo oluşturma gününe göre düzenlenmiş tırtıklı bir e-tablo türleri dizisi döndürün.

Örnekler

Bob sizi bu soyut verilerle bırakmayacak. Bana her şeyin ne olması gerektiğini anlamanıza yardımcı olması için bazı elektronik tablolarının alt kümesini verdi.

Örnek giriş (0 dizinli):

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

Örnek çıktı (yorum ile birlikte, elbette gerekli değildir):

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'un her gün iki e-tablo yapmadığını ve bu nedenle çıktının da pürüzlü olabileceğini unutmayın. Ancak her gün her zaman en az bir e-tablo oluşturur, bu nedenle çıktının asla boş diziler içermesi gerekmez - sonuçta boş diziler varsa, bunları kaldırmanız gerekmez.

Daha fazla test örneği:

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

Çıktının iç listelerinin sıralanması gerekmez.

Her zaman olduğu gibi standart boşluklar yok ve elbette en kısa kod kazanıyor.

(Bu benim ilk sorum olduğu için, lütfen geliştirmek için yapabileceğim her şeyi bana bildirin.)

Jöle , 11 10 bayt

FṀ⁸ċþµJ€x"

Giriş ve çıkış 1 tabanlıdır.

Çevrimiçi deneyin! veya tüm test senaryolarını doğrulayın (kolay karşılaştırma için 0 tabanlı).

Pyth, 13 bayt

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

Çevrimiçi deneyin

Pyth , 14 bayt

ms.e*]k/bdQS{s

Test odası.

Brachylog , 28 bayt

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

açıklama

• Ana yüklem, Girdi ( ?) = bir liste listesi

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

• Tahmin 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
  

• Tahmin 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 bayt

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

Boşver!

Dennis'in Python 2'deki cevabından ilham aldı .

JavaScript (ES6), 58 bayt

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

CJam ( 30 29 bayt)

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

Çevrimiçi demo

İlginçtir ki W, kullanmaktan ziyade kesmek daha kısa ee, çünkü endeksin zaten bir değişkenle sonuçlanmasını istiyorum. e]önce maksimum elemanı bulmak mve bir dizi m+1boş dizi başlatmak için iki bayt kaydetti

Bir baytlık tasarruf için Martin'e bir değer biriktirmek Xyerine bir değer depolayarak teşekkürler .

Not Sondaki boş dizilere izin verilirse, elektronik tablolar kadar boş gün dizisini başlatarak alternatif 29 baytlık bir yaklaşım vardır:

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

CJam, 20 bayt

Peter Taylor'a bu kodu çözümüne dayandırdığım ve 3 bayt kazandığım için teşekkürler.

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

Yığının üstündeki girdiyi bekleyen ve çıktıyla değiştiren isimsiz bir blok.

Burada test edin.

açıklama

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 bayt

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

Ideone üzerinde test edin .

Mathematica, 35 bayt

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

Düzensiz bir listeyi kabul eden ve döndüren adsız bir işlev. 1 tabanlı indeksler kullanır.

Neyse ki Maxtüm girdilerini otomatik olarak düzleştirir, bu nedenle giriş düzensiz bir liste olmasına rağmen bize son gün endeksini getirir. Daha sonra #&@@@#~Position~itüm gün endeksleri için bir liste hesaplıyoruz i. Bu ifadenin kendisi idüzensiz listenin içindeki konumunu bulur (ardışık derinliklerde bir dizi dizin olarak döner), bu nedenle istediğimiz değerler bu listelerin her birinin ilk değerleridir. ilk argümanı döndüren isimsiz bir işlev olan bu alt listelerin her birine #&@@@uygulayarak her alt listeden ilk öğeyi almak için standart bir golf hilesi #&.

Alternatif olarak, aynı bayt sayısı için tekli bir operatör tanımlayabiliriz (ISO 8859-1 kodlu kaynak dosyası varsayarak):

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

Java, 314 bayt

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;

Detaylı

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 bayt

Bir altyordam:

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

Nasıl işlediğini görün:

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