एक शून्य का वजन

Question

संख्याओं की एक क्रमबद्ध सूची (संभवतः अग्रणी शून्य के साथ) को देखते हुए, संख्याओं को लंबवत रूप से व्यवस्थित करें, फिर सभी शून्य को नीचे की ओर जाने दें और सभी ओवरहैंग नीचे-सबसे खुले स्लॉट में जाएं। परिणामी पूर्णांक आउटपुट, अग्रणी शून्य को हटाते हुए।

काम किया उदाहरण

कहें कि हमें इनपुट के रूप में निम्नलिखित दिए गए हैं:

['0000312941295', '239124000124581598', '32852353800451258', '10235923505185190', '1491359102149']

पहले हम इसे लंबवत रूप से व्यवस्थित करते हैं:

0000312941295
239124000124581598
32852353800451258
10235923505185190
1491359102149

फिर, कॉलम द्वारा कॉलम, शून्य को "अन्य नंबरों के माध्यम से" छोड़ दें ताकि वे नीचे की तरफ आराम करें और अन्य नंबरों को "पुश" करें। यह पहले जोड़े के रूप में निम्नानुसार होगा परिणाम:

2000312941295
339124000124581598
12852353800451258
10235923505185190
0491359102149
^

2300312941295
329124000124581598
14852353800451258
10235923505185190
0091359102149
 ^

2390312941295
328124000124581598
14252353800451258
10935923505185190
0001359102149
  ^

...

2391312941295
328524538124581598
14232323525451258
10915991001185190
0000350000049
                ^

अगला, सभी ओवरहैंगों को गिरा दें जैसे कि गुरुत्वाकर्षण उन्हें रेत की तरह नीचे खींच रहा है।

2391312941295
3285245381245 1598
14232323525458258
10915991001181190
00003500000495
             ^

2391312941295
3285245381245  598
14232323525458158
10915991001181290
000035000004951
              ^

...

2391312941295
3285245381245
14232323525458159
10915991001181258
000035000004951908
                 ^

अंत में, अग्रणी शून्य को हटाते हुए, इन नंबरों को आउटपुट करें। हमारे काम किए गए उदाहरण के लिए, आउटपुट:

[2391312941295, 3285245381245, 14232323525458159, 10915991001181258, 35000004951908]

एक अन्य उदाहरण के लिए, मान लीजिए कि इनपुट [1234000,12345678,1234,12340608,12341234] ।

1234000
12345678
1234
12340608
12341234

शून्य छोड़ें:

1234  
12345678
1234163
12340208
12340004

शेष ओवरहैंगिंग अंकों को छोड़ें:

1234  
1234567
12341638
12340208
12340004

आउटपुट है [1234, 1234567, 12341638, 12340208, 12340004]।

नियम

• इनपुट में अग्रणी शून्य हो सकता है। उत्पादन में अग्रणी शून्य नहीं होना चाहिए ।
• यदि लागू हो, तो आप मान सकते हैं कि इनपुट / आउटपुट आपकी भाषा के देशी पूर्णांक प्रकार में फिट होगा।
• इनपुट और आउटपुट किसी भी सुविधाजनक विधि द्वारा दिया जा सकता है ।
• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

क्या हम मान सकते हैं कि आउटपुट संख्या हमारी भाषा की शुद्धता से अधिक नहीं होगी? (JS राउंड 14232323525458159टू 14232323525458160)

— ETHproductions

@ETHproductions मुझे लगता है कि यह PPCG डिफ़ॉल्ट है।

— को एग्री आउटलोफर

and all overhangs drop to the bottom-most open slotमेरी टूटी चुनौती के लिए एक अच्छा तय था :)।

— मैजिक ऑक्टोपस Urn

@PeterCordes हां, इनपुट में अग्रणी शून्य हो सकता है, इसलिए इसे संभालने में सक्षम होना चाहिए। मैं ज्यादातर भाषाओं के लिए कल्पना करता हूं, इसका मतलब है कि इनपुट को एक स्ट्रिंग के रूप में लें।

— AdmBorkBork

@PeterCordes इनपुट और आउटपुट आवश्यक रूप से बेस -10 में होने की आवश्यकता नहीं है (यह अनुमति दी गई डिफ़ॉल्ट I / O विधियों में है), इसलिए जब तक किसी भिन्न आधार का उपयोग करना कार्य को तुच्छ नहीं करता है (यह एक मानक खामी है)। दूसरे, मुझे लगता है कि मैंने यह निर्दिष्ट नहीं किया था कि अग्रणी शून्य को पूरी तरह से हटा दिया जाना चाहिए , हालांकि यही इरादा था। मैं यह नियम करने जा रहा हूं कि शून्य को स्पेस के साथ बदलने की अनुमति नहीं है, क्योंकि आउटपुट आउटपुट . 1234से बहुत अलग है 1234।

— AdmBorkBork

Answer 1

जेली , 8 बाइट्स

Z¬Þ€UZṚḌ

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

यह काम किस प्रकार करता है

Z¬Þ€UZṚḌ  Main link. Argument: M (2D array / matrix)

Z         Zip; transpose M by reading columns as rows.
 ¬Þ€      Sort each row of the transpose by logical NOT, pushing 0's to the end.
    U     Upend; reverse all sorted rows of the transpose.
     Z    Zip again, restoring rows from columns. Overhangs rise to the top.
      Ṛ   Reverse the order of the rows.
       Ḍ  Decimal; convert the rows from base 10 to integer.

Comments

क्या? जैसा कि मैं उस प्रश्न को पढ़ रहा था जो मैं सोच रहा था: "अंत में, कोई रास्ता नहीं है कि कोई इसके लिए 20 बाइट्स से कम खींच सके"। पागलपन

— क्रंचर

Sort each row of the transpose by logical NOT, pushing 0's to the end.क्या यह एक स्थिर प्रकार होने की गारंटी है?

— क्रंचर

हां, जेली पायथन का उपयोग sortedकरती है, जो स्थिर होने की गारंटी है।

— डेनिस

मैं इस तरह के कम्यूटेटिव लुकिंग वर्जन को पसंद करता हूं: ṚZẸÞ€ZṚḌ:)

— जोनाथन एलन

Answer 2

05AB1E , 11 बाइट्स

ζεð†R0†R}øï

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

Comments

†पहले कभी नहीं देखा , अच्छा है।

— मैजिक ऑक्टोपस Urn

Answer 3

भूसी , 12 बाइट्स

md↔TmoÖ±miT↔

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

व्याख्या

md↔Tm(Ö±mi)T↔  -- input as list of strings, example: ["103","32","258"]
            ↔  -- reverse: ["258","32","103"]
           T   -- transpose: ["231","520","83"]
    m(    )    -- with each line do (example with "520")
        mi     -- | convert each char to digit: [5,2,0]
      Ö±       -- | sort by signum (stable): [0,5,2]
               -- : [[2,3,1],[0,5,2],[8,3]]
   T           -- transpose: [[2,0,8],[3,5,3],[1,2]]
  ↔            -- reverse: [[1,2],[3,5,3],[2,0,8]]%
md             -- convert each to integer: [12,353,208]

Answer 4

अजगर २ , 118 बाइट्स

lambda l:[int(''.join(z))for z in zip(*map(lambda*a:['']*a.count(None)+[e for e in a if'0'<e]+['0']*a.count('0'),*l))]

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

अनप्लग्ड संस्करण

def f(list_):
 max_len = max(len(x) for x in list_)
 transposed_list = zip(*[list(row)+(max_len-len(row))*[None] for row in list_])
 weighted_list = [['']*column.count(None)+[cell for cell in column if cell != '0' and cell != None]+['0']*column.count('0') for column in transposed_list]
 return [int(''.join(row)) for row in zip(*weighted_list)]

पहली दो पंक्तियाँ समतुल्य हैं map(lambda*a...), डिफ़ॉल्ट व्यवहार यदि एस के mapसाथ भरना है Noneयदि एक सूची दूसरे से छोटी है।
e>'0'के समतुल्य है cell != '0' and cell != None, क्योंकि यदि यह कोई अंक (1 ~ 9) है तो इसका उच्च कोडपॉइंट होगा, और (किसी भी) स्ट्रिंग की तुलना में अधिक है None।

Comments

इस के एक ungolfed संस्करण पोस्ट करने के लिए देखभाल?

— पीटर कॉर्ड्स

@PeterCordes ने कुछ अस्पष्ट बिंदुओं के लिए अनगुल्ड संस्करण और एक संक्षिप्त स्पष्टीकरण जोड़ा

— Rod

Answer 5

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

iRT_C_M!DMC

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

Answer 6

रेटिना 0.8.2 , 95 92 बाइट्स

m(+`^((.)*)(.+)(¶(?<-2>.)*)(?(2)_)$
$1$4$3
+`^((.)*)0(.*¶(?>(?<-2>.)*))([^0])
$1$4${3}0
^0+

इसे ऑनलाइन आज़माएं! व्याख्या: पहला चरण शून्य अंक को गिराता है क्योंकि इससे शून्य को गिराने के लिए दूसरा चरण आसान होता है (संपादित करें: 3-बाइट की बचत के लिए और भी आसान)। तीसरा चरण तब अग्रणी शून्य को हटाता है।

Answer 7

रूबी , 104 बाइट्स

->a{a.map{|x|x.ljust(99).chars}.transpose.map{|x|x.sort_by{|x|x<?1?x:?!}}.transpose.map{|x|x.join.to_i}}

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

व्याख्या

->a{
  a.map{|x|x.ljust(99).chars}  # Fill spaces to make this rectangular
    .transpose.map{|x|
       x.sort_by{|x|x<?1?x:?!} # Treat all chars but " 1" as ! (see ascii table)
    }.transpose.map{|x|x.join.to_i} # Convert back to numbers
                       # note: if no leading 0s, eval x*'' , doesn't work here
}

Answer 8

एपीएल (Dyalog यूनिकोड) , 26 बाइट्स ^SBCS

अनाम टाइसिट उपसर्ग फ़ंक्शन एक वर्ण मैट्रिक्स को तर्क के रूप में ले रहा है और संख्याओं की सूची लौटा रहा है।

⍎⍤1∘⍉' 0'(∩∘⊃,~,∩∘⊃∘⌽)⍤1⍨⍉

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

⍉ इनपुट स्थानांतरित करें (जैसा कि हमें कॉलम पर काम करने की आवश्यकता है)

' 0'(...)⍤1⍨ सही तर्क के ' 0'रूप में  प्रत्येक पंक्ति (टेंसर रैंक 1 का उप-सरणी) के साथ निम्नलिखित टैकट फ़ंक्शन लागू करें (तर्कों को स्वैप करता है):⍨

 ∩ पंक्ति के प्रतिच्छेदन
 ∘ और
 ⊃  के पहले ' 0'
 (यानी row∩' ', प्रत्येक पंक्ति से सभी रिक्त स्थान)

 , के बाद…

 ~ सेट अंतर
 (यानी row~' 0', पंक्ति लेकिन रिक्त स्थान और शून्य के बिना)

 , के बाद…

 ∩ पंक्ति का प्रतिच्छेदन
 ∘ और  उलट  का
 ⊃ पहला
 ∘
 ⌽' 0'
 (यानीrow∩'0' , प्रत्येक पंक्ति से सभी शून्य)

⍎⍤1 उस (यानी प्रत्येक स्तंभ; अब संशोधित इनपुट पंक्तियों)  के हस्तांतरण के प्रत्येक पंक्ति (टेन्सर रैंक 1 के उप-सरणी)
∘ का मूल्यांकन
⍉करें।

Comments

कोष्ठक बिट चतुर है। मुझे वहां के इरादे को समझने में थोड़ा समय लगा, हालांकि मुझे पता है कि अलग-अलग वर्ग क्या करते हैं। एक बार जब मैं इसे समझ गया, तो इसे हराना आसान है: ⍎⍤1∘⍉{⍵[⍋3|2×' 0'⍳⍵]}⍤1∘⍉( ⎕io←0) यह आगे गोल्फ हो सकता है, उदाहरण के लिए, मैंने ⍋

— डाइएडिक का

वास्तव में, उपरोक्त एक पूर्ण कार्यक्रम के रूप में छोटा है (ट्रेन नहीं):⍎⍤1⍉{⍵[⍋3|2×' 0'⍳⍵]}⍤1⍉⎕

— ngn

@ इस तरह की एक अलग विधि खुद की पोस्ट की योग्यता है। पूर्व और बाद के प्रसंस्करण स्पष्ट है।

— Adám

Answer 9

पर्ल 5 , -p0 77 बाइट्स

पुरानी शैली की गिनती: 79 बाइट्स (के +2लिए p0)

अंतिम न्यूलाइन के बिना एसटीडीआईएन पर लाइनों के रूप में इनपुट दें (अन्यथा सब कुछ ओवरहैंग के रूप में देखा जाता है और इनपुट स्ट्रिंग नीचे क्रैश होने पर अंतिम नईलाइन शीर्ष पर पहुंच जाती है)। उदाहरण के लिए:

0000312941295
239124000124581598
32852353800451258
10235923505185190
1491359102149

ओवरहैंग को गिराना और 0एक रेगेक्स में गिरना थोड़ा मुश्किल था

#!/usr/bin/perl -p0
s/^.{@{+}}\K((0)|.+$)(.*
.{@{+}})((?(2)[1-9]|$))/$4$3$1/m while/|/g;s/^0+//mg

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

Answer 10

रूबी , 203 बाइट्स

->a{t=->b{b[0].zip(*b[1..-1])}
m=a.map{|s|s.size}.max
a.map!{|s|(s+" "*m)[0...m].chars}
a=t[a].map{|c|c.size.times{|i|" 0"[c[i]]&&(c.slice!(i)==?0?c.push(?0):c.unshift(" "))}
c}
t[a].map{|r|r.join.to_i}}

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

एक लैम्बडा स्ट्रिंग्स की एक सरणी को स्वीकार करता है और इन्टस की एक सरणी लौटाता है। मुझे लगता है कि मुझे कुछ याद आ रहा है; यह बहुत बड़ा लगता है: /

->a{
  t = -> b { b[0].zip(*b[1..-1]) }     # t is a lambda that transposes 2D arrays
  m = a.map{ |s| s.size }.max          # m is the maximum input string length
  a.map!{ |s| (s+" "*m)[0...m].chars } # Right-pad every string to the same length
  a = t[a].map{ |c|                    # Transpose a, and for every row (column)
    c.size.times{ |i|                  # For every character in the column
      " 0"[c[i]] && (                  # If the character is 0 or space
        c.slice!(i) == ?0 ?            # Remove it from the column, and if it was 0,
          c.push(?0) :                 # Push a 0 to the end (bottom) of the column, else
          c.unshift(" ")               # Add a space to the top of the column
      )
    }
    c
  }
  t[a].map{ |r| r.join.to_i }          # Transpose a back, and parse each row to int
}

Comments

मैं outgolfed इस (अभी)

— Unihedron

@ यूनीहेड्रन वाह, आपने मुझे 50% से हराया। आपने मेरे +1 को सुनिश्चित कर लिया है।

— 1922 को benj2240

Answer 11

एपीएल (डायलॉग क्लासिक) , 24 23 22 बाइट्स

⍎⍤1⍉{⍵[⍒⌈9÷⍨⎕d⍳⍵]}⍤1⍉⎕

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

एडम के समाधान पर आधारित है