एक संख्यात्मक सूची कनवर्टर करें


20

जब आप संख्याओं की सूची (वेक्टर, एरे ...) को एक प्रोग्राम से दूसरे प्रोग्राम में कॉपी-पेस्ट करना चाहते हैं, तो आप उससे नफरत नहीं करते हैं, लेकिन जिस फॉर्मेट में आपके नंबर हैं, वह उस फॉर्मेट से मेल नहीं खाता है जिसकी आपको जरूरत है। ?

उदाहरण के लिए, MATLAB में आपके पास इस तरह से एक अलग सूची हो सकती है:

[1 2 3 4 5]    (you can also have it comma separated, but that's not the point)

अजगर में आपको उस सूची को एक वैध इनपुट बनाने के लिए अल्पविराम सम्मिलित करना होगा, इसलिए आपको इसे परिवर्तित करना होगा

[1, 2, 3, 4, 5]

यह काम करने के लिए। C ++ में आप कुछ ऐसा चाहते हैं:

{16,2,77,29}

और इसी तरह।

हर किसी के जीवन को सरल बनाने के लिए, एक सूची कनवर्टर बनाते हैं, जो किसी भी प्रारूप * पर एक सूची बनाता है, और दूसरे निर्दिष्ट प्रारूप पर एक सूची को आउटपुट करता है।

मान्य कोष्ठक हैं:

[list]
{list}
(list)
<list>
list      (no surrounding brackets)

मान्य सीमांकक हैं:

a,b,c
a;b;c
a b c
a,  b,  c       <-- Several spaces. Must only be supported as input.
a;     b; c     <-- Several spaces. Must only be supported as input.
a   b   c       <-- Several spaces. Must only be supported as input. 

ध्यान दें, इनपुट संख्या के बीच रिक्त स्थान के किसी भी संख्या हो सकती है, लेकिन उत्पादन (यदि शून्य रिक्त स्थान के लिए चुन सकते हैं ,या ;(अगर यह के अंतरिक्ष-प्रतिबंधित) परिसीमक के रूप में प्रयोग किया जाता है), या एक ही जगह।

इनपुट सूची के अलावा, एक स्ट्रिंग (या दो वर्ण) होगा जो आउटपुट स्वरूप को परिभाषित करता है। प्रारूप स्ट्रिंग पहले प्रारंभ कोष्ठक प्रकार हो जाएगा (केवल), [, (, <, {या (पिछले एक एक भी इस्तेमाल किया जब कोई आस-पास के ब्रैकेट है जगह नहीं है)। ब्रैकेट प्रकार का पालन सीमांकक प्रकार ,, ;या (अंतिम एक एकल स्थान है) द्वारा किया जाएगा। ऊपर वर्णित क्रम में दो इनपुट प्रारूप वर्णों को एक तर्क (स्ट्रिंग या दो लगातार वर्ण) के रूप में लिया जाना चाहिए।

प्रारूप के तार के कुछ उदाहरण:

[,    <-- Output format:   [a,b,c]
{;    <-- Output format:   {a;b;c}
      <-- Two spaces, output list has format:   a b c   

नियम:

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

कुछ उदाहरण:

1 2 3 4
[,
[1,2,3,4]

<1;  2;  3>
 ;    <-- Space + semicolon
1;2;3
not valid:  1.000;2.000;3.000   (Input is only integers => Output must be integers)

{-1.3, 3.4, 4, 5.55555555}
[,
[-1.300,3.400,4.000,5.556]  (5.555 is also valid. Rounding is optional)
also valid: [-1.3,3.4,4,5.55555555]

बाइट्स में सबसे छोटा कोड जीत जाता है। हमेशा की तरह, जिस दिन चैलेंज पोस्ट किया गया था, उसमें से एक सप्ताह विजेता का चयन किया जाएगा। उत्तर जो बाद में पोस्ट किए गए हैं वे अभी भी जीत सकते हैं यदि वे वर्तमान विजेता से कम हैं।


लीडरबोर्ड

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से सूची बनाता है) क) प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes


क्या अनुगामी और अग्रणी व्हाट्सएप की अनुमति है?
ओवरएक्टर

@overactor, पहले दो नियम देखें। व्हाट्सएप को लीड करना ठीक नहीं है, ट्रेलिंग ठीक है।
स्टिव ग्रिफिन

क्या हम विपरीत क्रम में इनपुट ले सकते हैं? (डेलिमिटर पहले, सूची दूसरे)
मार्टिन एंडर

@ मार्टिनबटनर, हाँ। यह निर्दिष्ट नहीं है कि इसे पहले सूचीबद्ध किया जाना है, इसलिए आप चुन सकते हैं।
स्टिव ग्रिफ़िन

J _नकारात्मक तत्वों को दर्शाने के लिए उपयोग करता है। :(
जर्बद डिक

जवाबों:


1

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

l)l_5ms`-SerS%*\S-_o_'(#(f-

इसे यहाँ आज़माएँ।

व्याख्या

l      e# Read the format string.
)      e# Extract the separator.
l_     e# Read the list.
5ms`   e# Get a string that contains -.0123456789.
-      e# Get the characters in the list that are not in the string.
Ser    e# Replace those characters with spaces.
S%     e# Split by those characters, with duplicates removed.
*      e# Join with the separator.
\S-    e# Remove spaces (if any) from the left bracket.
_o     e# Output a copy of that character before the stack.
_'(#   e# Find '( in the left bracket string.
(      e# Get -1 if '( is the first character, and -2 if it doesn't exist.
f-     e# Subtract the number from every character in the left bracket string,
          making a right bracket.

8

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

एक अनाम फ़ंक्शन के रूप में

संपादित करें: 2 बाइट ने thx को बचाया @ user81655 (और 5 इसे अभी समीक्षा कर रहा है)

(l,[a,b])=>a.trim()+l.match(/[-\d.]+/g).join(b)+']})> '['[{(< '.indexOf(a)]

टेस्ट स्निपेट

F=(l,[a,b])=>a.trim()+l.match(/[-\d.]+/g).join(b)+']})> '['[{(< '.indexOf(a)]

// Test
console.log=x=>O.innerHTML+=x+'\n'
// default test suite
t=[['1 2 3 4','[,'],['<1;  2;  3>',' ;'],['{-1.3, 3.4, 4, 5.55555555}','[,']]
t.forEach(t=>console.log(t[0]+' *'+t[1]+'* '+F(t[0],t[1])))
function test() { console.log(P1.value+' *'+P2.value+'* '+F(P1.value,P2.value)) }
#P1 { width: 10em }
#P2 { width: 2em }
P1<input id=P1>
P2<input id=P2>
<button onclick="test()">-></button>
<pre id=O></pre>


6

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

l(S-l"{[<(,}]>);":BSerS%@*1$B5/~er

इसका परीक्षण यहां करें।

पहली पंक्ति पर प्रारूप और दूसरी पर सूची की अपेक्षा करता है।

व्याख्या

l   e# Read the format line.
(   e# Pull off the first character, which is the opening bracket.
S-  e# Set complement with a space, which leaves brackets unchanged and turns a space
    e# into an empty string.
l   e# Read the list.
"{[<(,}]>);":B
    e# Push this string which contains all the characters in the list we want to ignore.
Ser e# Replace each occurrence of one of them with a space.
S%  e# Split the string around runs of spaces, to get the numbers.
@   e# Pull up the the delimiter string.
*   e# Join the numbers in the list with that character.
1$  e# Copy the opening bracket (which may be an empty string).
B5/ e# Push B again and split it into chunks of 5: ["{[<(," "}]>);"]
~   e# Unwrap the array to leave both chunks on the stack.
er  e# Use them for transliteration, to turn the opening bracket into a closing one.

5

पायथ, 33 बाइट्स

rjjezrXwJ"<>[]  {}(),;"d7@c6JChz6

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

J"<>[]  {}(),;"  assign this string to J

rjjezrXwJd7@c6JChz6   implicit: z = first input string, e.g. "[;"
       w              read another string from input (the list of numbers)
      X Jd            replace every char of ^ that appears in J with a space
     r    7           parse ^ (the string of numbers and spaces) into a list
  jez                 put z[1] (the separator symbol) between the numbers
            c6J       split J into 6 pieces ["<>", "[]", "  ", "{}", "()", ",;"]
               Chz    ASCII-value of z[0] (opening bracket symbol)
           @          take the correspondent (mod 6) brackets from the list
 j                    and put the numbers between these brackets
r                 7   remove leading and trailing spaces

क्या आप इस बात का स्पष्टीकरण जोड़ सकते हैं कि यह कैसे काम करता है?
शेल्वैकु

1
@ आप यहाँ हैं।

5

पॉवरशेल, १० , १०० 95 85 बाइट्स

$i,$z=$args;($z[0]+($i-split'[^\d.-]+'-ne''-join$z[1])+' }) >]'[($z[0]-32)%6]).Trim()

(पिछले संस्करणों के लिए संशोधन इतिहास देखें)

एक और 15 बाइट्स को हटाने $bऔर $sचर और आंतरिक स्ट्रिंग पर पार्न्स को बदलते हुए।

यह दो स्ट्रिंग्स के रूप में इनपुट लेता है और उन्हें स्टोर करता है $iऔर $zफिर, हम एक नया आउटपुट स्ट्रिंग बनाते हैं। भीतरी कोष्ठक -splitरों $iएक regex के साथ केवल अंक का चयन करने के लिए, तो -joinवापस अनुरोध किया सीमांकक के साथ एक साथ है। हम मानते हैं कि सीमांकक इनपुट के पहले चरित्र (जैसे [) के साथ और इसे पहले वर्ण के ASCII मूल्य और कुछ सूत्रीकरण प्रवंचना के आधार पर एक स्ट्रिंग में अनुक्रमण के साथ बंद करें। बाहरी .Trim()किसी भी अग्रणी या अनुगामी रिक्त स्थान को निकालता है।


मुझे लगता है कि आप अपनी समापन कोष्ठक अभिव्यक्ति "]})>"["[{(< ".IndexOf($b[0])]को कुछ इस तरह से बदल सकते हैं ' }) >]'[($b[0]-32)%6]($b[0]-32)%6आप देता 0,2,4,5,1ब्रैकेट वर्ण, जो आप बंद कोष्ठक स्ट्रिंग में सूचकांक के लिए उपयोग कर सकते हैं खोलने के लिए ' }) >]'। एक छोटा "सूत्र" हो सकता है, लेकिन यह काफी अच्छा लगता है।
डैंको डर्बिएक

@ DankoDurbić बहुत बढ़िया! मैं ASCII मूल्यों के आधार पर सही आउटपुट चरित्र पर चयन करने के लिए कुछ गणित के साथ आने की कोशिश कर रहा था, लेकिन मुझे सही फॉर्मूला नहीं मिला। मैं ()एक दूसरे के ठीक बगल में होने के कारण फंसता रहा, लेकिन दूसरे कोष्ठक के बीच एक चरित्र था, इसलिए मैं अनुक्रमण के साथ गया। धन्यवाद!
AdmBorkBork 16

ऑपरेटर के String.Replace()बजाय का उपयोग करके -replaceआप एक और 2 बाइट्स खरीदेंगे (साथ में एक चरित्र वर्ग से बचने या परिभाषित करने की आवश्यकता नहीं [])
मैथियास आर जेसेन

@ MathiasR.Jessen जब तक मैं यहाँ कुछ याद नहीं कर रहा हूँ, .Replace('[]{}()<>;,',' ')व्यक्तिगत पात्रों को नहीं पकड़ेगा , बल्कि प्रतीकात्मक पूरे से मेल खाने की कोशिश करेगा, जो मौजूद नहीं है। हमें Regex.Replace का उपयोग करना होगा , जिसमें एक [regex]::.NET कॉल शामिल है और इसके बजाय कोड लंबा होगा।
AdmBorkBork

@TessellatingHeckler धन्यवाद! मैं के -ne''बजाय का उपयोग कर एक और बाइट गोल्फ |?{$_}
AdmBorkBork

4

पायथन 2, 96 बाइट्स

import re
lambda(a,(b,c)):(b+c.join(re.findall('[-\d\.]+',a))+'])>} '['[(<{ '.index(b)]).strip()

इस रूप में कॉल करें:

f(('{-1.3, 3.4, ,4, 5.55555555}','[,'))

आउटपुट:

[-1.3,3.4,4,5.55555555]

2

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

(a,b)=>(c=a.match(/-?\d+(\.\d+)?/g).join(b[1]),d=b[0],d<"'"?c:d+c+"]}>)"["[{<(".indexOf(d)])

एक अनाम फ़ंक्शन, इसे इस तरह से चलाएं

((a,b)=>(c=a.match(/-?\d+(\.\d+)?/g).join(b[1]),d=b[0],d<"'"?c:d+c+"]}>)"["[{<(".indexOf(d)]))("{1;  2;3;   4}","<;")

यह शायद आगे गोल्फ रास्ता हो सकता है ..

Ungolfed

(a,b)=>(                             // "{1;  2;3;   4}", "<;"
    c=a.match(/-?\d+(\.\d+)?/g)      // regex to match decimals
    .join(b[1]),                     // c -> "1;2;3;4"
    d=b[0],                          // d -> "<"
    d<"'" ?                          // if d is smaller than ' then ...
        c :                          // return just "1;2;3;4"
        d + c +                      // "<" + "1;2;3;4" + ...
        "]}>)" [ "[{<(".indexOf(d) ] // "]}>)"[2] -> ">"
)

मुझे लगता है कि आपको एक सूची के रूप में एक स्ट्रिंग के रूप में लेना होगा।
ओवरएक्टर

पूरी तरह से इस गलत समझा The input will be a list of integer or decimal numbers (both positive and negative (and zero)), and a string of two characters:। इसे ठीक किया, धन्यवाद
बेसब्रू कंबरवुबवबूब

2

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

माथेमैटिका आमतौर पर स्ट्रिंग इनपुट के साथ अनाड़ी होता है जब तक कि स्ट्रिंग को टेक्स्ट के रूप में व्याख्या करने के लिए नहीं होता है।

c=Characters;t_~f~p_:=({b,s}=c@p;b<>Riffle[StringCases[t,NumberString],s]<>(b/.Thread[c@"[ {<(" -> c@"] }>)"]))

व्याख्या

StringCases[t,NumberString]नंबर स्ट्रिंग्स की सूची देता है।

Riffleसंख्याओं के बीच विभाजकों को सम्मिलित करता है।

/.Thread[c@"[ {<(" -> c@"] }>)"]) बाएं "ब्रैकेट" को सही ब्रैकेट के साथ बदल देता है।

<>का infix रूप है StringJoin। यह एक साथ सब्सट्रेट को चमकता है।


2

मतलाब, 85 बाइट्स

@(s,x)[x(1) strjoin(regexp(s,'-?\d+\.?\d*','match'),x(2)) x(1)+(x(1)~=32)+(x(1)~=40)]

उदाहरण का उपयोग करें:

>> @(s,x)[x(1) strjoin(regexp(s,'-?\d+\.?\d*','match'),x(2)) x(1)+(x(1)~=32)+(x(1)~=40)]
ans = 
    @(s,x)[x(1),strjoin(regexp(s,'-?\d+\.?\d*','match'),x(2)),x(1)+(x(1)~=32)+(x(1)~=40)]

>> ans('1 2.4 -3 -444.555 5', '[,')
ans =
[1,2.4,-3,-444.555,5]

1

जूलिया, 95 बाइट्स

f(l,s)=(x=s[1]<33?"":s[1:1])*join(matchall(r"[\d.-]+",l),s[2])*string(x>""?s[1]+(s[1]<41?1:2):x)

यह एक फंक्शन है f जो दो स्ट्रिंग्स को स्वीकार करता है और एक स्ट्रिंग लौटाता है।

Ungolfed:

function f{T<:AbstractString}(l::T, s::T)
    # Extract the numbers from the input list
    n = matchall(r"[\d.-]+", l)

    # Join them back into a string separated by given separator
    j = join(n, s[2])

    # Set the opening bracket type as the empty string unless
    # the given bracket type is not a space
    x = s[1] < 33 ? "" : s[1:1]

    # Get the closing bracket type by adding 1 or 2 to the ASCII
    # value of the opening bracket unless it's an empty string
    c = string(x > "" ? s[1] + (s[1] < 41 ? 1 : 2) : x)

    # Put it all together and return
    return x * j * c
end

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.