अंक अपनी गलियों में

32

इनपुट:

पूर्णांकों की एक सूची

आउटपुट:

-0123456789किसी भी डुप्लिकेट अंकों की अनदेखी करते हुए, प्रत्येक अंक (और ऋण चिह्न) को अपनी लेन में रखें ।

उदाहरण:

इनपुट: [1,729,4728510,-3832,748129321,89842,-938744,0,11111]

आउटपुट:

-0123456789  <- Added as clarification only, it's not part of the output

  1         
   2    7 9
 012 45 78 
-  23    8 
  1234  789
   2 4   89
-   34  789
 0         
  1

चुनौती नियम:

  • संख्या में किसी भी डुप्लिकेट अंकों की अनदेखी की जाती है।
  • I / O किसी भी उचित प्रारूप में हो सकता है। इनपुट स्ट्रिंग्स या चरित्र-सरणी की एक सूची / सरणी के रूप में हो सकता है। आउटपुट स्ट्रिंग्स, वर्ण, चरित्र-मैट्रिक्स, आदि की एक सूची के रूप में हो सकता है।
  • अनुगामी स्थान वैकल्पिक हैं।
  • नई लाइनों के अग्रणी या अनुगामी की कोई भी मात्रा वैकल्पिक है (लेकिन लाइनों के बीच नहीं)।
  • इनपुट में हमेशा कम से कम एक पूर्णांक होगा
  • आपको कम से कम -2,147,483,648हालाँकि 2,147,483,647(32-बिट) की पूर्णांक श्रेणी का समर्थन करना होगा ।
  • इनपुट-लिस्ट में कभी भी शामिल नहीं होंगे -0, 00(या दो से अधिक शून्य), या अग्रणी शून्य (यानी 012) के साथ पूर्णांक ।
  • यदि आप नकारात्मक संख्याओं (जैसे ऊपरी ¯) के लिए एक अलग प्रतीक का उपयोग करते हैं, तो आपको इसके बजाय, जब तक यह संगत है, तब तक इसका उपयोग करने की अनुमति है।
  • आपको अंकों के बीच एक स्थान का परिसीमन करने की अनुमति है (इसलिए 5 या 8 के बिना एक पंक्ति - 0 1 2 3 4 6 7 9इसके बजाय हो सकती है -01234 67 9), जब तक कि यह सुसंगत है (और इसलिए बीच में भी जगह होनी चाहिए -और 0)।

सामान्य नियम:

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

परीक्षण के मामलों:

Input: [1,729,4728510,-3832,748129321,89842,-938744,0,11111]
Output:
  1         
   2    7 9
 012 45 78 
-  23    8 
  1234  789
   2 4   89
-   34  789
 0         
  1        

Input: [4,534,4,4,53,26,71,835044,-3559534,-1027849356,-9,-99,-3459,-3459,-94593,-10234567859]
Output:
      4     
     345    
      4     
      4     
     3 5    
    2   6   
   1     7  
  0  345  8 
 -   345   9
 -0123456789
 -         9
 -         9
 -   345   9
 -   345   9
 -   345   9
 -0123456789

Input: [112,379,-3,409817,239087123,-96,0,895127308,-97140,923,-748]
Output:
  12       
   3    7 9
-  3       
 01 4   789
 0123   789
-      6  9
 0         
  123 5 789
-01  4  7 9
   23     9
-    4  78 

Input: [-15,-14,-13,-12,-11,10,-9,-8,-7,-5,-4,-3,-1,0,9,100,101,102,1103,104,105,106,116,-12345690]
Output:
- 1   5    
- 1  4     
- 1 3      
- 12       
- 1        
-01        
-         9
-        8 
-       7  
-     5    
-    4     
-   3      
- 1        
 0         
          9
 01        
 01        
 012       
 01 3      
 01  4     
 01   5    
 01    6   
  1    6   
-0123456  9

Input: [99,88,77,66,55,44,33,22,11,10,0,0,0,-941]
Output:
          9
         8 
        7  
       6   
      5    
     4     
    3      
   2       
  1        
 01        
 0         
 0         
 0         
- 1  4    9
code-golf  ascii-art  number  integer 
— केविन क्रूज़सेन
स्रोत
क्या आउटपुट में अंकों के बीच रिक्त स्थान की अनुमति होगी?
— शैगी
क्या हम ¯इसके बजाय ऊपरी माइनस का उपयोग कर सकते हैं -?
— एरियल
लापता अंकों को अभी भी रिक्त स्थान के साथ बदल दिया जाएगा, इसलिए, आपके उदाहरण में, 4 और 6 और 7 और 9 के बीच 3 स्थान होंगे: "-0 1 2 3 4 <space> 6 7 <space> 9"(कई रिक्त स्थान किसी कारण के लिए टिप्पणियों में ढह जाते हैं)
— झबरा
1
मैं उम्मीद कर रहा था कि चुपके से तुम एक अतीत! : डी वेल-स्पॉटेड!
— शैगी
1
— स्ट्रीटस्टर

जवाबों:

4

स्टैक्स , 8 बाइट्स

║V≡u╝─é╢

इसे चलाएं और डीबग करें

यह मानक इनपुट पर प्रति पंक्ति एक नंबर लेता है। यह प्रत्येक वर्ण के लक्ष्य सूचकांक को खोजने और परिणाम के उस सूचकांक में असाइन करने से काम करता है। यदि सूचकांक सीमा से बाहर है, तो सरणी को शून्य तक विस्तारित किया जाता है जब तक कि यह फिट न हो जाए। आउटपुट के दौरान, 0एक स्थान बन जाता है। बाकी चरित्र कोड हैं।

अनपैक्ड, अनगुल्फेड, और टिप्पणी की, यह वही है जो ऐसा दिखता है।

m       for each line of input, execute the rest of the program and print the result
 zs     put an empty array under the line of input
 F      for each character code in the line of input, run the rest of the program
  Vd    "0123456789"
  I^    get the index of the character in this string and increment
  _&    assign this character to that index in the original string

इसको चलाओ

— पुनरावर्ती
स्रोत
किसी की लंबाई की सूची इनपुट करने के लिए कैसे है? (अगर यह सिर्फ मूल्य या मूल्य है और एक नई लाइन यह काम नहीं करता है।)
— जोनाथन एलन
1
अरे हाँ, अच्छी बात है। इनपुट का एक वैकल्पिक रूप जो एकल मानों के लिए भी काम करता है ["7"]। यह प्रारूप कई मानों को भी संभाल सकता है जैसे कि ["34", "43"]।
— पुनरावर्ती
6

05AB1E , 13 बाइट्स

कोड:

v'-žh«DyмSð:,

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

v               # For each element in the input..
 '-žh«          #   Push -0123456789
      D         #   Duplicate this string
       yм       #   String subtraction with the current element
                    e.g. "-0123456789" "456" м  →  "-0123789"
         Sð:    #   Replace all remaining elements with spaces
                    e.g. "-0123456789" "-0123789" Sð:  →  "     456   "
            ,   #   Pop and print with a newline
— अदनान
स्रोत
1
अच्छा! प्रतिस्थापन-मार्ग पर जाने से मैं इन्सर्ट-रूट से छोटा था :)
— एमिग्ना
2
@Emigna इन्सर्ट-रूट भी एक बहुत ही दिलचस्प तरीका है। वास्तव में, मुझे लगता है कि आप 4 बाइट्स बचा सकते हैं vðTúyvyÐd+ǝ},;)।
— अदनान
1
प्रतिभाशाली! मुझे नहीं पता था कि ǝइस तरह काम करेगा -0। लेकिन अब जब मैं इसका पता लगाता हूं, तो यह वास्तव में एक संख्या है, न कि एक तार जैसा कि मैंने पहली बार इसे पढ़ा: पी
— एमिग्ना
Ooooof ... मैं 23bytes पर था। 05AB1E (मानवता पर दंड)।
— मैजिक ऑक्टोपस Urn
4

जावास्क्रिप्ट, 59 58 बाइट्स

इनपुट और आउटपुट स्ट्रिंग्स की एक सरणी के रूप में।

a=>a.map(x=>`-0123456789`.replace(eval(`/[^${x}]/g`),` `))

कोशिश करो

o.innerText=(g=s=>(f=
a=>a.map(x=>`-0123456789`.replace(eval(`/[^${x}]/g`),` `))
)(s.split`,`).join`\n`)(i.value="1,729,4728510,-3832,748129321,89842,-938744,0,11111");oninput=_=>o.innerText=g(i.value)
input{width:100%;}
<input id=i><pre id=o></pre>
स्निपेट का विस्तार करें

मूल

तार के एक सरणी के रूप में इनपुट लेता है और चरित्र सरणियों की एक सरणी आउटपुट करता है

a=>a.map(x=>[...`-0123456789`].map(y=>-~x.search(y)?y:` `))

कोड स्निपेट दिखाएं

— झबरा
स्रोत
1
इस तरह के एक सुरुचिपूर्ण समाधान, मैं वास्तव में इसे पसंद करता हूं।
— ब्रायन एच।
4

APL (Dyalog) , 32 12 बाइट्स

28 बाइट्स ने @ Adám और @ngn को धन्यवाद दिया

⊃¨⎕∘.∩'¯',⎕d

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

— Uriel
स्रोत
1
एक ही विचार, 15 {' '@(~∊∘⍵)'¯',⎕D}¨:। स्पष्ट रूप -से तुच्छ परिवर्तन के साथ भी ले सकते हैं।
— आदम
{⊃¨⍵∘.∩'¯',⎕d}
— nn
या यहां तक ​​कि⊃¨⎕∘.∩'¯',⎕d
— nn
3

05AB1E , 17 13 बाइट्स

अदनान की बदौलत 4 बाइट बच गईं

vðTúyvyÐd+ǝ},

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

व्याख्या

v               # loop over elements y in input
 ðTú            # push a space prepended by 10 spaces
    yv          # for each element y in the outer y
      y         # push y
       Ðd+      # push y+isdigit(y)
          ǝ     # insert y at this position in the space-string
           }    # end inner loop
            ,   # print
— Emigna
स्रोत
3

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

अनाम लैम्ब्डा प्रसंस्करण संख्या की सरणी:

->a{a.map{|n|"-0123456789".tr"^#{n}",?\s}}

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

वैकल्पिक रूप से, एक पूरी तरह से पर्ल जैसा पूरा कार्यक्रम बहुत छोटा है। मेरे अनुसार-pl स्विच इस संदर्भ में काफी मज़ेदार लगेंगे:

रूबी -pl , 29 बाइट्स

$_="-0123456789".tr"^#$_"," "

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

अंत में, निम्नलिखित संभव है यदि यह आउटपुट स्ट्रिंग्स को उद्धृत करने के लिए स्वीकार्य है:

रूबी -n , 27 बाइट्स

p"-0123456789".tr ?^+$_,?\s

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

— किरिल एल।
स्रोत
3

जावास्क्रिप्ट (Node.js) , 60 बाइट्स

  • ज्वाइन को कम करने के लिए @Andrew टेलर को धन्यवाद (8 वर्ण)
  • XYatch के लिए @ यायर रैंड (8 वर्ण) को धन्यवाद
a=>a.map(X=>"-0123456789".replace(/./g,x=>X.match(x)?x:" "))

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

— DanielIndie
स्रोत
ओह, वह joinचाल प्यारी है - लेकिन सवाल यह है कि तार की एक सरणी की तरह पढ़ता है ठीक है आउटपुट तो शायद आप इसे हटाने से 8 बाइट्स दाढ़ी कर सकते हैं?
— एंड्रयू टेलर
यकीन है कि आप की जगह एक और बचा सकता है (X+"").includes(x)के साथRegExp(x).test(X)
— एंड्रयू टेलर
(X+"").match(x)और भी छोटा होगा। प्रश्न इनपुट को स्ट्रिंग्स की एक सरणी होने की अनुमति देता है, इसलिए यह भी हो सकता है X.match(x)।
— यार रैंड
2

Japt , 16 बाइट्स

इनपुट और आउटपुट स्ट्रिंग्स की एक सरणी के रूप में।

£Ao ¬i- ®iS gXøZ

कोशिश करो

व्याख्या

£                    :Map over each element X
 Ao                  :  Range [0,10)
    ¬                :  Join to a string
     i-              :  Prepend "-"
        ®            :  Map over each character Z
         iS          :    Prepend a space
            g        :    Get the character at index
             XøZ     :      X contains Z? (true=1, false=0)
— झबरा
स्रोत
2

पायथन 3 , 77 64 बाइट्स

-12 बाइट्स @Rod का धन्यवाद

lambda x:[[[" ",z][z in str(y)]for z in"-0123456789"]for y in x]

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

पायथन में गोल्फ में मेरा पहला उचित प्रयास। सलाह का स्वागत!

वर्णों का 2D सरणी लौटाता है।

— मजाक कर रहा है
स्रोत
1
आप उपयोग कर सकते हैं '-0123456789'बजाय range(10)और पहले खंड और स्वैप ड्रॉप str(z)के साथ z, आप भी को Python2 करने के लिए स्विच और उपयोग कर सकते हैं `y`बजाय str(y)( ``- बराबर करने के लिए + है repr)
— रॉड
में शानदार जगह in "-।
— जोनाथन फ्रीच
2

हास्केल , 47 बाइट्स

map(\s->do d<-"-0123456789";max" "[d|elem d s])

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

उपयोग maxएक स्थान डालने के लिए है जहां कोई तत्व मौजूद नहीं है, क्योंकि कोई स्थान किसी अंक या माइनस साइन से छोटा है।

यदि अनुगामी स्थानों की एक अस्पष्ट संख्या ठीक है, तो दो बाइट्स बचाए जा सकते हैं:

45 बाइट्स

map(\s->do d<-'-':['0'..];max" "[d|elem d s])

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

— XNOR
स्रोत
2

MATL , 13 बाइट्स

"45KY2ht@gm*c

इनपुट स्ट्रिंग्स का एक सेल ऐरे है। इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

         % Implicit input: cell array of strings, for example {'1','729',...,'11111'}
"        % For each cell
  45     %   Push 45 (ASCII code of '-')
  KY2    %   Push predefined literal '0123456789'
  h      %   Concatenate horizontally: gives '-0123456789'
  t      %   Duplicate
  @      %   Push current cell, for example {'729'}
  g      %   Convert cell to matrix. This effectively gives the cell's contents, '729'
  m      %   Ismember: gives an array of zeros and ones indicating membership of each
         %   char from '-0123456789' in '729'. The result in the example is
         %   [0 0 0 1 0 0 0 0 1 0 1]
  *      %   Multiply, element-wise. Chars are implicity converted to ASCII 
         %   Gives the array [0 0 0 50 0 0 0 0 55 0 57] 
  c      %   Convert ASCII codes to chars. 0 is displayed as space. Gives the string
         %   '   2    7 9'
         % Implicit end
         % Implicilly display each string on a different line
— लुइस मेंडो
स्रोत
2

जे , 32 27 बाइट्स

-5 बाइट्स FrownyFrog के लिए धन्यवाद!

10|.":(10<."."0@[)}11$' '"0

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

मूल समाधान:

जे , 32 बाइट्स

(('_0123456789'i.[)}11$' '"0)@":

स्पष्टीकरण:

@": वर्णों में बदलें और

}11$' '"0 इन वर्णों के लिए 11 स्थानों की एक सरणी की सामग्री को बदलें

'_0123456789'i.[ इस सूची में वर्णों के सूचकांकों द्वारा इंगित स्थानों पर

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

— गैलेन इवानोव
स्रोत
1
10|.":(10<."."0@[)}11$' '"0
— फ्रॉन्फ्रॉग
@ FrownyFrog अच्छा समाधान, धन्यवाद!
— गैलेन इवानोव
2

Google शीट , 124 बाइट्स

=Transpose(ArrayFormula(If(IsError(Find(Mid("-0123456789",Row($1:$11),1),Split(A1,",")))," ",Mid("-0123456789",Row($1:$11),1

इनपुट सेल में एक अल्पविराम से अलग की गई सूची है A1 । आउटपुट उस सीमा में है B1:L?जहां ?हालांकि कई प्रविष्टियां इनपुट थीं। (आप जहां चाहें सूत्र डाल सकते हैं, मैंने अभी B1सुविधा के लिए चुना है।) ध्यान दें कि सूत्र स्वतः ही चार समापन कोष्ठक जोड़ देंगे सूत्र के अंत में, हमें उन चार बाइट्स को बचाते हुए।

स्क्रीनशॉट

एक और टेस्ट केस और दूसरा टेस्ट केस

स्पष्टीकरण:

  • Mid("-0123456789",Row($1:$11),1) बारी-बारी से 11 पात्रों में से प्रत्येक को चुनता है।
  • Find(Mid(~),Split(A1,","))प्रत्येक इनपुट तत्वों में उन वर्णों की तलाश करता है। यह या तो एक संख्यात्मक मान लौटाता है या, अगर यह नहीं मिला है, तो एक त्रुटि।
  • If(IsError(Find(~)," ",Mid(~))यदि चरित्र नहीं मिला या यदि पात्र था तो एक स्थान पर वापस आ जाएगा। (मैं चाहता हूं कि इस Mid(~)हिस्से को डुप्लिकेट करने से बचने का एक तरीका था, लेकिन मुझे इसका कोई पता नहीं है।)
  • ArrayFormula(If(~))वह है जो मल्टी-सेल संदर्भ को Mid(~)और Find(~)कार्य में बनाता है । यह भी है कि क्या एक सेल कई कोशिकाओं में एक मान रिटर्न बनाता है।
  • Transpose(ArrayFormula(~)) लौटे सरणी स्थानांतरित क्योंकि यह बग़ल में शुरू होता है।
— इंजीनियर टोस्ट
स्रोत
2

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

ØD”-;¹⁶e?€Ʋ€

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

-2 जोनाथन एलन को धन्यवाद एक नियम को पढ़ने जो मैंने नहीं किया।

ध्यान दें कि TIO लिंक में उपयोग किया जाने वाला I / O प्रारूप वास्तविक नहीं है, जो कि स्ट्रिंग अभ्यावेदन की सूची के रूप में इनपुट है और लाइनों की सूची के रूप में आउटपुट है।

— आउटगोल्फर को एरिक करें
स्रोत
1

पर्ल 6 , 35 बाइट्स

{.map:{map {m/$^a/||' '},'-',|^10}}

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

आउटपुट एक कैरेक्टर मैट्रिक्स है जिसमें रेगेक्स मैच या स्पेस कैरेक्टर होते हैं।

— nwellnhof
स्रोत
'इनपुट किसी भी उचित प्रारूप में हो सकता' stdin हो सकता है, तो शायद -peआप प्रारंभिक .map, ब्रेसिज़ और स्वैप के साथ बांटना दिया जाएगा $^aके लिए$_
— फिल एच
@PHH -pऔर -nकिसी तरह छोटी गाड़ी लगती है, कम से कम TIO पर। किसी कारण के $_लिए ब्लॉक करने के लिए पारित नहीं किया है। उदाहरण 1 देखें , उदाहरण 2 ।
— nwellnhof
1

जावा 8, 53 बाइट्स

a->a.map(i->"-0123456789".replaceAll("[^"+i+"]"," "))

मेरी खुद की चुनौती आसान है जितना मैंने सोचा था कि जब मैंने इसे बनाया होगा ..

इनपुट और आउटपुट दोनों एक के रूप में java.util.stream.Stream<String>।

स्पष्टीकरण:

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

a->                              // Method with String-Stream as both input and return-type
  a.map(i->                      //  For every String in the input:
    "-0123456789"                //   Replace it with "-0123456789",
    .replaceAll("[^"+i+"]"," ")) //   with every character not in `i` replaced with a space
— केविन क्रूज़सेन
स्रोत
1

आर , 96 75 बाइट्स

for(i in scan())cat(paste(gsub(paste0("[^",i,"]")," ","-0123456789"),"\n"))

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

इस रेगेक्स दृष्टिकोण का सुझाव देने के लिए केविन क्रूज़सेन का धन्यवाद!

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

— ग्यूसेप
स्रोत
मैं आर को बहुत अच्छी तरह से नहीं जानता, इसलिए मुझे यकीन है कि इसे आगे बढ़ाया जा सकता है, लेकिन यह अलग दृष्टिकोण 12 बाइट्स छोटा है function(N)for(i in N)cat(paste(gsub(paste("[^","]",sep=i)," ","-0123456789"),"\n")):। (पूर्णांक-सरणी के बजाय स्ट्रिंग-सरणी के रूप में इनपुट।) इसे ऑनलाइन आज़माएं।
— केविन क्रूजसेन
@KevinCruijssen आह, अच्छा, हाँ, मैं नीचे गोल्फ के रूप में अच्छी तरह से कर सकते हैं।
— ग्यूसेप
1

SOGL V0.12 , 14 13 बाइट्स

{ø,{²²⁴WI1ž}P

यह कोशिश करो!

स्पष्टीकरण:

{ø,{²²⁴WI1ž}P

{            repeat input times
 ø,            push an empty string and the next input above that
   {       }   for each character in the input
    ²²           push "0123456789"
      ⁴          copy the character on top
       W         and get it's index in that string (1-indexed, 0 for the non-existent "-")
        I        increment that (SOGL is 1-indexed, so this is required)
         1ž      at coordinates (index; 1) in the string pushed earlier, insert that original copy of the character
            P  print the current line
— dzaima
स्रोत
1

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

VQm*d}dNs+\-UT

तार की सूची के रूप में इनपुट लेता है और प्रत्येक पंक्ति के लिए तार की एक सूची आउटपुट करता है।
इसे यहाँ आज़माएँ

व्याख्या

VQm*d}dNs+\-UT
VQ                For each string in the input...
  m     s+\-UT    ... and each character in "-0123456789"...
     }dN          ... check if the character is in the string...
   *d             ... and get that character or an empty string.
1

रेटिना , 26 बाइट्स

%"-0123456789"~`.+
[^$&]¶

इसे ऑनलाइन आज़माएं! नोट: अनुगामी स्थान। स्पष्टीकरण: इनपुट की प्रत्येक पंक्ति के लिए एक बार %अपने बच्चे के चरण को निष्पादित करता है ~। ~पहले अपने बच्चे के चरण को निष्पादित करता है, जो लाइन को अंदर लपेटता है [^और ]<CR><SP>एक प्रोग्राम का निर्माण करता है जो वर्णों को रिक्त स्थान के अनुरूप नहीं बदलता है। "-0123456789"निर्दिष्ट करता है कि कार्यक्रम के लिए इनपुट दिया स्ट्रिंग है ( $प्रतिस्थापन अनुमति दी जाती है लेकिन मैं उन्हें जरूरत नहीं है)।

— नील
स्रोत
1

पर्ल 5 -n , 30 बाइट्स

-पहली स्थिति में कहीं और दिखाई देने पर काम नहीं करेगा

#!/usr/bin/perl -n
say"-0123456789"=~s/[^$_]/ /gr

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

— टन हास्पेल
स्रोत
काम नहीं करेगा अगर -पहले की तुलना में कहीं और दिखाई दे सकता है अगर वह सच हो सकता है तो आप इस चुनौती का जवाब नहीं दे रहे हैं, क्योंकि वे अब पूर्णांक नहीं होंगे। : P
— आउटगोल्फर
1

सी (जीसीसी) , 95 94 बाइट्स

c,d;f(l,n)char**l;{for(;n--;l++)for(c=0;c<12;)putchar(strchr(*l,d=c++?c+46:45)?d:d^58?32:10);}

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

तार की सूची के रूप में इनपुट। STDOUT में आउटपुट।

— gastropner
स्रोत
आप को हटाने के द्वारा गोल्फ एक बाइट कर सकते हैं c++, और बदलते d=c?c+47:करने के लिए d=c++?c+46:।
— केविन क्रूज़सेन
1

K4 , 30 27 बाइट्स

समाधान:

{?[a in$x;a:"-",.Q.n;" "]}'

उदाहरण:

q)k){?[a in$x;a:"-",.Q.n;" "]}'1 729 4728510 -3832 748129321 89842 -938744 0 11111
"  1        "
"   2    7 9"
" 012 45 78 "
"-  23    8 "
"  1234  789"
"   2 4   89"
"-   34  789"
" 0         "
"  1        "

स्पष्टीकरण:

इनपुट के आधार पर "-0123 ..." या "" लौटें। दायें-बायें व्याख्या की। एपीएल उत्तर के लिए कोई प्रतियोगिता नहीं :(

{?[a in$x;a:"-",.Q.n;" "]}' / the solution
{                        }' / lambda for each
 ?[      ;          ;   ]   / if[cond;true;false]
                .Q.n        / string "0123456789"
            "-",            / join with "-"
          a:                / save as a
       $x                   / convert input to string
   a in                     / return boolean list where each a in x
                     " "    / whitespace (return when false)
— streetster
स्रोत
0

एपीएल + विन, 33 बाइट्स

एक स्ट्रिंग के रूप में स्क्रीन इनपुट के लिए संकेत

n←11⍴' '⋄n['-0123456789'⍳s]←s←⎕⋄n
— ग्राहम
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.