सूचकांक की सूचियों की सूची बनाना

Question

इस StackOverflow पोस्ट से प्रेरित है ।

परिचय

बॉब का काम स्प्रेडशीट बनाना और उन्हें व्यवस्थित करना है। जिस तरह से वह उन्हें आयोजित करता है वह बॉब को छोड़कर बहुत कम लोगों को ज्ञात है, लेकिन वह प्रत्येक स्प्रेडशीट की एक सूची बनाता है जो एक ही समूह के अंतर्गत आती हैं। स्प्रेडशीट में डेटा का एक गुच्छा है जो वह बनाता है, लेकिन डेटा का केवल एक टुकड़ा है जिसे हम अभी देख रहे हैं: जिस दिन उसने यह काम शुरू किया था और जिस दिन उसने स्प्रेडशीट बनाई थी, उसके बीच के दिनों की संख्या। पहले दिन उसने दो स्प्रैडशीट बनाईं, उन दोनों को नोट किया 0और उन्हें उनके उचित स्थानों पर छांटा।

अब, उसका बॉस प्रत्येक दिन किस प्रकार की स्प्रेडशीट की समीक्षा करता है, और यह आपके लिए कुछ कोड लिखने का काम है, जो बॉब के लिए समझेगा; उसके पास अभी तक बहुत से स्प्रैडशीट हैं, इसे हाथ से करने के लिए।

इनपुट

बॉब की जानकारी जो वह आपको देता है, एक (0-or-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
]

ध्यान दें कि बॉब हमेशा हर दिन दो स्प्रेडशीट नहीं बनाता है, और इसलिए आउटपुट को दांतेदार किया जा सकता है। लेकिन वह हमेशा हर दिन कम से कम एक स्प्रेडशीट बनाता है, इसलिए आउटपुट को खाली सरणियों को रखने की आवश्यकता नहीं होगी - हालांकि यदि आपके आउटपुट में अंत में खाली सरणियाँ हैं, तो आपको उन्हें निकालने की आवश्यकता नहीं है।

अधिक परीक्षण के मामले:

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

आउटपुट की आंतरिक सूचियों को क्रमबद्ध करने की आवश्यकता नहीं है।

हमेशा की तरह, कोई मानक खामियां नहीं हैं, और निश्चित रूप से सबसे छोटा कोड जीतता है।

(जैसा कि यह मेरा पहला प्रश्न है, कृपया मुझे इसे सुधारने के लिए कुछ भी कर सकते हैं।)

Comments

हो सकता है बॉब किसी प्रकार का कोई स्प्रेडशीट न बनाए?

— xnor

@xnor नहीं, बॉब हमेशा हर दिन एक स्प्रेडशीट बनाएगा। ये स्प्रेडशीट कंपनी के संचालन के लिए बहुत महत्वपूर्ण हैं कि अगर बॉब को बीमार में कॉल करना है, तो दूसरे व्यक्ति को अस्थायी रूप से उस दिन के स्प्रैडशीट बनाने के लिए पोस्ट किया जाता है और बॉब अपने स्वयं के स्प्रेडशीट बनाने से पहले अगली सुबह उन्हें व्यवस्थित करता है।

— स्टीवन एच।

@ डेनिस उस उदाहरण को एक साथ रखने पर मैं थोड़ा थक गया था, और मुझे लगता है कि यह दिखाया गया है। : पी फिक्स्ड (दोनों)!

— स्टीवन एच।

जंच रहे हो। यह एक बहुत अच्छी चुनौती है, खासकर यह देखते हुए कि यह आपकी पहली है। :) Btw, यदि आप जागरूक नहीं हैं, तो हमारे पास एक सैंडबॉक्स है जहाँ समुदाय "लाइव" होने से पहले प्रतिक्रिया दे सकता है।

— डेनिस

मैंने आपकी टिप्पणी के आधार पर एक वक्तव्य में संपादित किया " नहीं, बॉब हमेशा हर दिन एक स्प्रेडशीट बनाएगा ", लेकिन अब जब मैंने अपने स्वयं के उत्तर का अनुकूलन करने की कोशिश की है, तो मुझे एहसास हुआ है कि यह संभवतः आपके उद्देश्य से अधिक प्रतिबंधात्मक है। क्या खाली सरणियों की अनुमति है? ईजी [[0 0]]आउटपुट दे सकता है [[0 0] []]?

— पीटर टेलर

Answer 1

जेली , 11 10 बाइट्स

FṀ⁸ċþµJ€x"

इनपुट और आउटपुट 1-आधारित हैं।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें (आसान तुलना के लिए 0-आधारित)।

Answer 2

पायथ, 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

इसे ऑनलाइन आज़माएं

Answer 3

अजगर , 14 बाइट्स

ms.e*]k/bdQS{s

परीक्षण सूट।

Answer 4

ब्रेकीलॉग , 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]
  

Answer 5

लूआ, 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

Ideone यह!

पायथन 2 में डेनिस के जवाब से प्रेरित ।

Answer 6

जावास्क्रिप्ट (ईएस 6), 58 बाइट्स

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

Answer 7

CJam ( 30 29 बाइट्स)

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

ऑनलाइन डेमो

उत्सुकता से यह Wउपयोग करने की तुलना में चारों ओर हैक करने के लिए छोटा है ee, मुख्यतः क्योंकि मैं चाहता हूं कि सूचकांक किसी भी तरह एक चर में समाप्त हो जाए। e]पहले अधिकतम तत्व को खोजने mऔर m+1खाली सरणियों के एक सरणी को शुरू करने पर दो बाइट्स बचाए ।

मार्टिन के लिए एक बाइट बचाने के लिए धन्यवाद Xइसके बजाय स्टैक के चारों ओर करतब दिखाने के बजाय एक मूल्य जमा करके ।

NB यदि खाली सरणियों को अनुगामी करने की अनुमति है, तो स्प्रेडशीट के रूप में कई खाली दिनों की सरणी को आरंभ करने के बजाय वैकल्पिक 29-बाइट दृष्टिकोण है:

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

Answer 8

सीजेएम, 20 बाइट्स

पीटर टेलर ने मुझे इस कोड को उसके समाधान और 3 बाइट्स को बचाने के लिए धन्यवाद दिया।

{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.

Answer 9

पायथन 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 पर इसका परीक्षण करें ।

Answer 10

गणितज्ञ, 35 बाइट्स

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

एक अनाम फ़ंक्शन जो रैग्ड सूची को स्वीकार करता है और लौटाता है। 1-आधारित सूचकांकों का उपयोग करता है।

शुक्र है कि Maxस्वचालित रूप से इसके सभी इनपुटों को समतल कर दिया गया है, इसलिए यह हमें अंतिम दिन का इंडेक्स मिलता है, भले ही इनपुट एक रैग्ड सूची हो। फिर हम #&@@@#~Position~iपूरे दिन के सूचकांकों की सूची तैयार करते हैं i। यह अभिव्यक्ति स्वयं ही iरैग्ड सूची के अंदर की स्थिति का पता लगाती है (क्रमिक गहराई पर सूचकांकों की एक सरणी के रूप में वापसी), इसलिए हम जो मान चाहते हैं, उनमें से प्रत्येक सूची का पहला मान है। #&@@@प्रत्येक सबलिस्ट से पहला तत्व प्राप्त करने के लिए एक मानक गोल्फिंग ट्रिक है #&, जो उन सब्लिस्ट्स में से प्रत्येक पर लागू होता है, जो एक अनाम फ़ंक्शन है जो अपना पहला तर्क देता है।

वैकल्पिक रूप से, हम समान बाइट-काउंट (ISO 8859-1 एन्कोडेड सोर्स फ़ाइल मानकर) के लिए एक अपर ऑपरेटर को परिभाषित कर सकते हैं:

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

Answer 11

जावा, 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;
}

Comments

क्या आपको वास्तव में जरूरत है Map?

— लीक नून

Answer 12

पर्ल 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])'