Nगैर-ऋणात्मक पूर्णांकों की सूची को देखते हुए , उन संख्याओं को प्रत्येक बायें-पैड वाले रिक्त स्थान के साथ लम्बाई में आउटपुट करें N। (वैकल्पिक रूप से, एक वर्ण / स्ट्रिंग सूची लौटाएँ।) आप मान सकते हैं कि Nसूची में सबसे बड़ी संख्या के अंकों की संख्या के बराबर या उससे अधिक है। आउटपुट में ट्रेलिंग स्पेस की अनुमति है।

आप इन संख्याओं से युक्त एक स्ट्रिंग भी ले सकते हैं, लेकिन Nस्ट्रिंग की लंबाई नहीं है, बल्कि सूची में तत्वों की संख्या है; इसके अलावा, आप तार की एक सूची ले सकते हैं जैसे ["1", "2", "3"]।

यह एक कोड-गोल्फ है, इसलिए बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है।

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

input => 'output'
0 => '0'
1 => '1'
2 3 => ' 2 3'
2 10 => ' 210'
4 5 6 => '  4  5  6'
17 19 20 => ' 17 19 20'
7 8 9 10 => '   7   8   9  10'
100 200 300 0 => ' 100 200 300   0'
1000 400 30 7 => '1000 400  30   7'
1 33 333 7777 => '   1  33 3337777'
0 0 0 0 0 0 => '     0     0     0     0     0     0'

code-golf string

— कोनोर ओ ब्रायन
स्रोत

क्या प्रत्येक पंक्ति (उचित पैडिंग के साथ) पर संख्या एक मुद्रित की जा सकती है?

— लुइस मेन्डो

@LuisMendo हाँ।

— कॉनर ओ'ब्रायन

8

05AB1E , 3 बाइट्स

कोड:

Dgj

स्पष्टीकरण:

D    # Duplicate the input array
 g   # Get the length 
  j  # Left-pad with spaces to the length of the array

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

— अदनान
स्रोत

1

ओह। खैर जो जल्दी खत्म हो गया था। अच्छी नौकरी!

— कॉनर ओ'ब्रायन

16

पायथन, 32 बाइट्स

lambda l:'%%%ds'%len(l)*len(l)%l

एक अनाम फ़ंक्शन जो इनपुट के रूप में एक टपल लेता है। या तो नंबर या तार काम करते हैं।

उदाहरण:

l=(1,33,333,7777)

'%%%ds'
## A "second-order" format string

'%%%ds'%len(l)           -> '%4s'
## Inserts the length as a number in place of '%d'
## The escaped '%%' becomes '%', ready to take a new format argument
## The result is a format string to pad with that many spaces on the left

'%%%ds'%len(l)*len(l)    -> '%4s%4s%4s%4s'
## Concatenates a copy per element

'%%%ds'%len(l)*len(l)%l  -> '   1  33 3337777'
## Inserts all the tuple elements into the format string 
## So, each one is padded with spaces

— XNOR
स्रोत

7

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

a=>a.map(v=>v.padStart(a.length,' '))

इनपुट: स्ट्रिंग्स की
सरणी आउटपुट: स्ट्रिंग्स की सरणी

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

f=
  a=>a.map(v=>v.padStart(a.length,' '))
;
console.log(f(['0']))
console.log(f(['1']))
console.log(f(['2','3']))
console.log(f(['2','10']))
console.log(f(['4','5','6']))
console.log(f(['17','19','20']))
console.log(f(['7','8','9','10']))
console.log(f(['100','200','300','0']))
console.log(f(['1000','400','30','7']))
console.log(f(['1','33','333','7777']))
console.log(f(['0','0','0','0','0','0']))

Expand snippet

— Hedi
स्रोत

5

PowerShell v2 +, 36 बाइट्स

param($a)$a|%{"{0,$($a.count)}"-f$_}

एगर्स $aकी एक सरणी के रूप में इनपुट लेता है int। उनके साथ लूप्स $a|%{...}। प्रत्येक पुनरावृत्ति, उपयुक्त स्थान को लेफ्ट-पैड के -fलिए वैकल्पिक Alignment Component(आधारित $a.count) के साथ ormat ऑपरेटर का उपयोग करता है । उस परिणामी स्ट्रिंग को पाइप लाइन पर छोड़ दिया जाता है। कार्यक्रम निष्पादन के अंत में, परिणामी तार को एक सरणी के रूप में पाइपलाइन पर छोड़ दिया जाता है।

उदाहरण

आउटपुट प्रत्येक रन पर newline- अलग होता है, क्योंकि यह Write-Outputकिसी ऐरे के लिए प्रोग्राम पूरा होने पर डिफ़ॉल्ट होता है ।

PS C:\Tools\Scripts\golfing> @(0),@(1),@(2,3),@(2,10),@(4,5,6),@(17,19,20),@(7,8,9,10),@(100,200,300,0),@(1000,400,30,7),@(1,33,333,7777),@(0,0,0,0,0,0)|%{""+($_-join',')+" -> ";(.\spaced-out-numbers $_)}
0 -> 
0
1 -> 
1
2,3 -> 
 2
 3
2,10 -> 
 2
10
4,5,6 -> 
  4
  5
  6
17,19,20 -> 
 17
 19
 20
7,8,9,10 -> 
   7
   8
   9
  10
100,200,300,0 -> 
 100
 200
 300
   0
1000,400,30,7 -> 
1000
 400
  30
   7
1,33,333,7777 -> 
   1
  33
 333
7777
0,0,0,0,0,0 -> 
     0
     0
     0
     0
     0
     0

— AdmBorkBork
स्रोत

5

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

a=>a.map(n=>" ".repeat(a.length-n.length)+n)

तर्कों को तार की सूची के रूप में लेता है और तार की सूची भी लौटाता है।

स्पष्टीकरण:

a=>                                                   An unnamed function, which takes one argument, a
   a.map(n=>                               )          Do the following to each element n in a:
            " ".repeat(a.length-n.length)             Generate the spaces needed to justify the number
                                         +n           Append the number

— Loovjo
स्रोत

1

तार की एक सरणी स्वीकार्य है, इसलिए .join("")इसकी आवश्यकता नहीं है।

— कॉनर ओ'ब्रायन

1

a=>a.map(n=>(" ".repeat(l=a.length)+n).slice(-l))एक ही लंबाई है लेकिन पूर्णांक के साथ-साथ तार पर काम करता है।

— नील

5

पर्ल, 26 बाइट्स

-4 बाइट्स @ थॉन हास्पेल को धन्यवाद

कोड + -aध्वज के 25 बाइट्स ।

printf"%*s",~~@F,$_ for@F

साथ दौड़ो :

perl -ae 'printf"%*s",~~@F,$_ for@F' <<< "10 11 12"

(पर्ल के कुछ पुराने संस्करण पर, आपको जोड़ने की आवश्यकता हो सकती है -n)

— बापू
स्रोत

1

-aविकल्प का उपयोग करने से आपका कोड छोटा हो जाएगा ...

— टन हास्पेल

@ टॉन्होस्पेल हम, जो काफी स्पष्ट लगता है, मुझे मूर्खतापूर्ण लगता है .. धन्यवाद के लिए धन्यवाद

— दादा

थोड़ा अलग तरीका लूप से बचा जाता है और एक बाइट बचाता है: इसे ऑनलाइन आज़माएं!

— Xcali

5

बैश, १४

printf %$#d $@

कमांड लाइन पर दी गई इनपुट सूची।

यहाँ समझाने के लिए ज्यादा नहीं। printfपास किए गए आर्गों की संख्या के आधार पर, आवश्यक पैडिंग करने के लिए अंतर्निहित सुविधाओं का उपयोग करता है :

$# पारित की संख्या की संख्या है
%<n>d एक प्रिंटफ़ प्रारूप निर्दिष्ट होता है जो पूर्णांक को n अग्रणी स्थानों तक प्रिंट करता है
$@ पारित सभी आर्ग की सूची है
के प्रत्येक सदस्य के लिए प्रारूप विनिर्देशक का पुन: उपयोग किया जाता है $@।

Ideone ।

— डिजिटल आघात
स्रोत

4

विम, 19 बाइट्स

YPPG!{<C-F>|R%ri<CR>djVGgJ

संख्या-प्रति-पंक्ति की एक सूची लेता है। पर निर्भर करता है :set expandtab, जो लोकप्रिय है, लेकिन सार्वभौमिक नहीं है।

आप स्पष्ट रूप से इसके लिए उपयोग करना चाहते हैं :right। सवाल यह है कि कमांड लाइन पर लाइनों की संख्या कैसे प्राप्त करें। पारंपरिक तरीका है :%ri<C-R>=line('$'), लेकिन वह सब लंबा है।

सामान्य मोड !कमांड का उपयोग करके कमांड लाइन बनाने के लिए छोटा, अधिक उद्यमी दृष्टिकोण है । इसमें कुछ अजीब वर्कअराउंड शामिल हैं, फ़ाइल को 2 लाइनों द्वारा विस्तारित करना फिर उन्हें फिर से निकालना, लेकिन यह 2 बाइट्स से कम निकलता है। और मैं थोड़े हैरान हूं कि मुझे प्राप्त होने वाली कमांड लाइन (जैसे :%ri+4!) वास्तव में काम करती है, लेकिन यह करता है।

— udioica
स्रोत

मुझे नहीं लगता कि आप एक ऐसी सुविधा पर भरोसा कर सकते हैं जो डिफ़ॉल्ट रूप से बंद है।

— DJMcMayhem

@DJMcMayhem मैंने अपने जीवन के बहुत से घंटे बिताए हैं, जो कि खराब इंडेंट सेटिंग्स को विमगॉल्फ में लड़ रहे हैं। स्पष्ट रूप से सेटिंग expandtabइस समाधान में 7 स्ट्रोक जोड़ता है। कारण यह है कि मुझे अब जीतने वाले टैब से बचने / हटाने के लिए अन्य तरीकों की जांच करनी होगी। यह बहुत समय है, बिल्कुल भी मज़ेदार नहीं है, मेरे समाधान की गुणवत्ता को बदतर बनाता है, और प्रदान किए गए किसी भी परीक्षण के मामलों को भी प्रभावित नहीं करता है (कोई भी 8+ नंबर नहीं है)। यदि यह नियम है, यह नियम है, लेकिन मैं इसके बिना ऐसा करने के बजाय गैर-प्रतिस्पर्धा को चिह्नित करूंगा expandtab।

— --ऑडिका

@DJMcMayhem के बारे में Ypp!{। यह वास्तव में कम है। यह भी काम नहीं करता है। यह हमेशा फ़ाइल की लंबाई की परवाह किए बिना नंबर 1 को कमांड लाइन में लाएगा।

— वर्जिनिया

4

रूबी, 40 36 34 बाइट्स

->m{m.map{|i|$><<i.rjust(m.size)}}

अधिक पर काम किया जा सकता है।

मेमने के रूप में बुलाओ।

स्पष्टीकरण:

->m{m.map{|i|$><<i.rjust(m.size)}}
->m{                             } # lambda taking array m
    m.map{|i|                   }  # map over array using variable i
             $><<                  # output to $> (stdout)
                 i.rjust(m.size)   # right justify i to m's length

— dkudriavtsev
स्रोत

2

जेली , 7 6 बाइट्स

L⁶xaUU

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

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

L⁶xaUU  Main link. Argument: A (array of strings)

L       Yield the l, the length of A.
 ⁶x     Repeat ' ' l times.

    U   Upend; reverse all strings in A.
   a    Perform vectorizing logical AND, replacing spaces with their corresponding
        digits and leaving spaces without corresponding digits untouched.
     U  Upend; reverse the strings in the result to restore the original order of
        its digits, moving the spaces to the left.

— डेनिस
स्रोत

2

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

#~StringPadLeft~Length@#&

इनपुट और आउटपुट दोनों स्ट्रिंग्स की सूची है।

व्याख्या

Length@#

इनपुट की लंबाई (तत्व की संख्या) प्राप्त करें।

#~StringPadLeft~...

पैड ने इनपुट में प्रत्येक तत्व को छोड़ दिया ताकि उनकी लंबाई इनपुट की लंबाई से मेल खाए।

— जंगवान मिन
स्रोत

2

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

बेनामी फ़ंक्शन, इनपुट: स्ट्रिंग ऑफ़ अरेंजमेंट, आउटपुट: स्ट्रिंग्स की सरणी
एक पुनरावर्ती पैडिंग फ़ंक्शन का उपयोग करना

a=>a.map(x=>p(x),p=x=>x[a.length-1]?x:p(' '+x))

इनपुट के रूप में एक पूर्णांक / स्ट्रिंग सरणी के लिए, 49 बाइट्स:

a=>a.map(x=>p(x),p=x=>(y=' '+x)[a.length]?x:p(y))

परीक्षा

f=
a=>a.map(x=>p(x),p=x=>x[a.length-1]?x:p(' '+x))

function update() {
  var l=I.value.match(/\d+/g)||[]
  O.textContent = f(l)
}

update()

<input id=I oninput='update()' value='1000,400,30,7'>
<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

2

PHP, 55 बाइट्स

<?foreach($a=$_GET[a]as$i)printf("%".count($a)."s",$i);

स्पष्ट संस्करण 59 बाइट्स

<?foreach($a=$_GET[a]as$i)echo str_pad($i,count($a)," ",0);

— जार्ग हुल्सरमन
स्रोत

1

स्ट्रैप_पैड का उपयोग क्यों किया जाता है, जब प्रिंटफ़ पर्याप्त है? foreach($a=$_GET[a]as$i)printf("%".count($a)."s",$i);

— क्रिप्टो

2

जे, 4 बाइट्स

":~#

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

एक सरणी के रूप में दाईं ओर संख्याओं की सूची लेने और गद्देदार स्ट्रिंग को वापस करने के लिए यूनिरी फ़ंक्शन।

यहाँ यह REPL में उपयोग में है। ध्यान दें कि इनपुट लाइनें तीन स्थानों पर इंडेंट की जाती हैं।

   f=: ":~#
   f 2 3
 2 3
   f 2 10
 210
   f 1111 222 33 4
1111 222  33   4

— algorithmshark
स्रोत

वाह। आपने J में मेरे संदर्भ समाधान को हरा दिया! बहुत अच्छा।

— कॉनर ओ'ब्रायन

1

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

lS%_,f{Se[}

इसे ऑनलाइन आज़माएं!(एक परीक्षण सूट के रूप में।)

व्याख्या

l      e# Read input.
S%     e# Split around spaces.
_,     e# Copy and get length.
f{     e# Map this block over the list, passing in the length on each iteration.
  Se[  e#   Left-pad to the given length with spaces.
}

— मार्टिन एंडर
स्रोत

1

कोटलिन, 90 बाइट्स

golfed:

fun main(a:Array<String>){a.forEach{b->for(i in 1..a.size-b.length){print(" ")};print(b)}}

Ungolfed:

fun main(a: Array<String>) {
    a.forEach { b ->
        for (i in 1..a.size - b.length) {
            print(" ")
        }
        print(b)
    }
}

— Psyduck77
स्रोत

1

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

k=length
f l=map(\s->replicate(k l-k s)' '++s)l

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

— arjanen
स्रोत

1

जावा, 83 82 बाइट्स

a->{String s="";for(int i=a.length,j=i;i-->0;)s+="%"+j+"s";return s.format(s,a);};

सरणी की लंबाई के बराबर रिक्त स्थान द्वारा दिए गए तर्कों को पैड करने के लिए डिज़ाइन किया गया एक प्रारूप स्ट्रिंग का निर्माण करता है। प्रारूप स्ट्रिंग के लिए एक तर्क के रूप में उपयोग किया जाता है String.format, और फिर परिणाम वापस आ जाता है। कार्यात्मक इंटरफ़ेस String[]या तो एक या एक Integer[]समान स्वीकार कर सकता है ।

पूरी कक्षा:

public class Test {
    public static void main(String[] args) {
        java.util.function.Function<Integer[], String> f = a -> {
            String s = "";
            for (int i = a.length, j = i; i-- > 0;)
                s += "%" + j + "s";
            return s.format(s, a);
        };

        System.out.println(f.apply(new Integer[] {0}));
        System.out.println(f.apply(new Integer[] {2, 10}));
        System.out.println(f.apply(new Integer[] {7, 8, 9, 10}));
        System.out.println(f.apply(new Integer[] {1, 33, 333, 7777}));
        System.out.println(f.apply(new Integer[] {0, 0, 0, 0, 0, 0}));
    }
}

Ideone पर इसे आज़माएं।

-1 बाइट @KevinCruijssen को धन्यवाद।

— टीएनटी
स्रोत

अच्छा तरीका, +1। आप इसे इस तरह से int ...और s+=...अंदर डालकर 1 बाइट में गोल्फ कर सकते हैं if:for(int i=a.length,j=i;i-->0;s+="%"+j+"s");

— केविन क्रूज़सेन

1

ग्रूवी, 36 बाइट्स

{a->a.collect{it.padLeft(a.size())}}

केवल स्ट्रिंग्स की सरणी में ले जाता है, गद्देदार स्ट्रिंग्स के सरणी को आउटपुट करता है।

— जादू ऑक्टोपस Urn
स्रोत

1

MATL, 14 बाइट्स

'%%%dd'inYDGYD

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

यह पहले प्रारूप स्ट्रिंग का निर्माण करके स्वरूपित स्ट्रिंग निर्माण का उपयोग करता है: %(NUM)dऔर फिर इस प्रारूप स्ट्रिंग और इनपुट का उपयोग करके फिर से स्ट्रिंग प्रारूपण लागू करता है।

— Suever
स्रोत

1

जावास्क्रिप्ट 33 बाइट्स

@ हेडी के समान - लेकिन डिफ़ॉल्ट पैडिंग '' है, इसलिए इसके 4 चार्ट कम हैं

a=>a.map(s=>s.padStart(a.length))

f=a=>a.map(s=>s.padStart(a.length))

console.log(f(["0"]))
console.log(f(["1"]))
console.log(f(["2","3"]))
console.log(f(["2","10"]))
console.log(f(["17" ,"19" ,"2"]))
console.log(f(["1000" ,"400" ,"30" ,"7"]))

स्निपेट का विस्तार करें

— DanielIndie
स्रोत

1

के (ओके) , 11 बाइट्स

समाधान:

,/(-#x)$$x:

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

स्पष्टीकरण:

दायें-बायें व्याख्या की। सूची की लंबाई के साथ स्ट्रिंग और बाएं-पैड में कनवर्ट करें, फिर समतल करें:

,/(-#x)$$x: / the solution                      | example:
         x: / save as 'x'                       |
        $   / string                            | $10 20 30 -> "10","20","30"
       $    / pad right by left                 | 5$"abc" -> "abc  "
  (   )     / do the stuff in brackets together |
    #x      / count x                           | #10 20 30 -> 3
   -        / negate                            |
,/          / flatten (concatenate-over)        | ,/" a"," b"," c" -> " a b c"

— streetster
स्रोत

0

पायथ - 7 बाइट्स

पैडिंग बिलिन का उपयोग करते हुए सीधा उत्तर।

sm.[;lQ

टेस्ट सूट ।

— Maltysen
स्रोत

0

सी #, 39 बाइट्स

s=>s.ConvertAll(c=>c.PadLeft(s.Count));

एक List<string>और आउटपुट लेता है aList<string> ।

स्पष्टीकरण:

/*Func<List<string>, List<string>> Lambda =*/ s =>
    s.ConvertAll(c =>                                // Create a new List<string> by...
        c.PadLeft(s.Count)                           // ...padding each element by 'N'
    )
;

LINQ का उपयोग करने के लिए कुछ बाइट्स कम हो गए हैं यदि आयात की गणना नहीं की गई है और फिर वापस लौट रहे हैं IEnumerable<string> एक पूर्ण विकसित सूची के बजाय :

सी #, 35 + 18 = 53 बाइट्स

using System.Linq;s=>s.Select(c=>c.PadLeft(s.Count));

— दूध
स्रोत

0

आर, 47 बाइट्स

cat(sprintf("%*.f",length(n<-scan()),n),sep="")

स्टड से इनपुट पढ़ता है और सी-स्टाइल का उपयोग करता है sprintf । किसी तरह से catफ़ंक्शन की आवश्यकता नहीं होनी चाहिए, लेकिन इसके बिना प्रत्येक तत्व पर उद्धरण को दबाने का तरीका नहीं मिल सकता है। यदि हम केवल उद्धरण और अंत चाहते हैं, तो हम थोड़े लंबे विकल्प का उपयोग कर सकते हैं:

paste0(sprintf("%*.f",length(n<-scan()),n),collapse="")

— Billywob
स्रोत

बाहर-बाहर की संख्या

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

05AB1E , 3 बाइट्स

पायथन, 32 बाइट्स

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

PowerShell v2 +, 36 बाइट्स

उदाहरण

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

पर्ल, 26 बाइट्स

बैश, १४

विम, 19 बाइट्स

रूबी, 40 36 34 बाइट्स

जेली , 7 6 बाइट्स

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

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

व्याख्या

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

PHP, 55 बाइट्स

जे, 4 बाइट्स

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

व्याख्या

कोटलिन, 90 बाइट्स

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

जावा, 83 82 बाइट्स

ग्रूवी, 36 बाइट्स

MATL, 14 बाइट्स

जावास्क्रिप्ट 33 बाइट्स

के (ओके) , 11 बाइट्स

पायथ - 7 बाइट्स

सी #, 39 बाइट्स

सी #, 35 + 18 = 53 बाइट्स

आर, 47 बाइट्स