मेरा मध्य नाम क्या है?

30

नोट: जीतने वाला उत्तर 4/12/17 को चुना जाएगा , वर्तमान विजेता जोल्फ, 1 बाइट है ।

मुझे आश्चर्य है कि अभी तक इस साइट पर मेरे मध्य नाम की कोई चुनौती नहीं है। मैंने बहुत खोज की लेकिन कुछ नहीं मिला। यदि यह एक डुबकी है, तो कृपया इसे इस तरह ध्वजांकित करें।

आपकी चुनौती

एक स्ट्रिंग को पार्स करें जो दिखता है Jo Jean Smithऔर वापस लौटता है Jean।

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

Input: Samantha Vee Hills
Output: Vee

Input: Bob Dillinger
Output: (empty string or newline)

Input: John Jacob Jingleheimer Schmidt
Output: Jacob Jingleheimer

Input: Jose Mario Carasco-Williams
Output: Mario

Input: James Alfred Van Allen
Output: Alfred Van

(यह अंतिम एक तकनीकी रूप से गलत है, लेकिन इसे ठीक करना बहुत कठिन होगा।)

टिप्पणियाँ:

  • नामों में हमेशा कम से कम 2 अंतरिक्ष-अलग हिस्से होंगे, जिनके बीच असीमित मध्य नाम या स्ट्रिंग की एक सूची / सरणी हो सकती है।
  • नामों में वर्णमाला (केस-असंवेदनशील) और - ( 0x2d) हो सकता है
  • आप एक अनुगामी न्यूलाइन का उत्पादन कर सकते हैं।
  • आपको एक अनुगामी न्यूलाइन रखने के लिए इनपुट की आवश्यकता हो सकती है।
  • STDIN, एक फ़ंक्शन पैरामीटर, या कमांड-लाइन तर्क से इनपुट की अनुमति है, लेकिन इसमें हार्ड-कोडिंग की अनुमति नहीं है।
  • मानक खामियों से मना किया।
  • आउटपुट फंक्शन रिटर्न वैल्यू, STDOUT, STDERR आदि हो सकता है।
  • आउटपुट में अनुगामी रिक्त स्थान / newlines / tabs की अनुमति है।
  • कोई सवाल? नीचे टिप्पणी करें!

यह कोड-गोल्फ है , इसलिए बाइट्स जीतने वाला सबसे छोटा खिलाड़ी है!

code-golf  string 
— programmer5000
स्रोत
2
क्या आउटपुट स्ट्रिंग्स की सूची हो सकता है?
— एंथनी फाम
5
यदि किसी स्थान-पृथक स्ट्रिंग की तुलना में अन्य स्वरूपों की अनुमति है, तो कृपया उसे विनिर्देश में संपादित करें।
— मार्टिन एंडर
5
@ प्रोग्रामर 5000: यदि इनपुट स्ट्रिंग्स की एक सूची हो सकती है, तो आउटपुट के बारे में कैसे? क्या ["John", "Jacob", "Jingleheimer", "Schmidt"]-> ["Jacob", "Jingleheimer"]एक वैध समाधान है?
— नीमी
3
क्या प्रमुख स्थानों की अनुमति है?
— betseg
2
@DJ क्योंकि "वान" उनका मध्य नाम नहीं है, यह उनके अंतिम नाम का हिस्सा है। एक विशेष रूप से मनोरंजक मामला डेविड लॉयड जॉर्ज है, जिसका पहला नाम डेविड है और अंतिम नाम लॉयड जॉर्ज है। वास्तविक लोगों के नामों को इस तरह से पार्स करने के किसी भी प्रयास को बर्बाद किया जाता है। वास्तव में, आप यह भी नहीं बता सकते कि पहले और अंतिम नाम क्या हैं (ली ली के बारे में सोचें)।
— डेविड कॉनराड

जवाबों:

4

जोल्फ, 1 बाइट

€

इनपुट के अंदर हो जाता है। यहाँ कोशिश करो!

— कोनोर ओ ब्रायन
स्रोत
उदाहरण के लिए चल रहा है प्रतीत नहीं कर सकते हैं - जब मैं किसी भी बटन पर क्लिक करता हूं तो कुछ भी नहीं होता है। Chrome का उपयोग कर 57.0.2987.133
@YiminRong मैं केवल फ़ायरफ़ॉक्स पर काम करने का आश्वासन दे सकता हूं।
— कॉनर ओ'ब्रायन
44

ओम , 2 बाइट्स (CP437)

स्वीकार करता है और तार की सूची देता है।

()

स्पष्टीकरण:

()   Main wire, arguments: a

(    Remove the first element of a
 )   ...and then the last element of that
     Implicit output
— निक क्लिफोर्ड
स्रोत
10
मुझे लगता है कि नौकरी के लिए सही उपकरण
— रोहन झुनझुनवाला
15

विम, 6 5 बाइट्स

dW$BD

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

(एक अनुगामी स्थान के साथ आउटपुट)

चूंकि V V के साथ उल्टा-संगत है, इसलिए मैंने V के लिए एक TIO लिंक शामिल किया है।

व्याख्या

dW                      " Delete up to the next word (removes the first name)
$                       " Go to the end of the line
B                       " Go back one word
D                       " Delete it
— क्रिकटी लिथोस
स्रोत
Drat, तुम मुझे यह करने के लिए हराया। dWWDआपको एक बाइट बचाता है।
— DJMcMayhem
5
@DJMcMayhem केवल एक मध्य नाम के लिए काम करता है।
— मार्टिन एंडर
DW और dw में क्या अंतर है?
— डंकन एक्स सिम्पसन
1
@DuncanXSimpson व्हॉट्सएप dWतक डिलीट dwगैर-शब्द वर्ण तक हटाता है।
— निधि मोनिका का मुकदमा
14

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

lambda n:n.split()[1:-1]

यह ऑनलाइन स्ट्रिंग इनपुट की कोशिश करो!

इनपुट प्रारूप: स्ट्रिंग


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

lambda n:n[1:-1]

ऑनलाइन सूची इनपुट की कोशिश करो!

इनपुट प्रारूप: सूची

— कीर्तन प्रभाकरं
स्रोत
आपको Pythonइसके बजाय शीर्षक को संपादित करना चाहिए Python 2, क्योंकि यह भी काम करता है Python 3, बस इसे पोस्ट करना था।
— श्री एक्सकोडर
@ L3viathan क्योंकि ओपी ने आउटपुट प्रारूप का उल्लेख नहीं किया है must be a string, और चूंकि इनपुट प्रारूप को एक सूची होने की अनुमति है, इसलिए सूची को प्रिंट करना गलत परिणाम नहीं माना जा सकता है!
— कीर्तन प्रभाकरन
प्रश्न पर टिप्पणियों के अनुसार, आप इनपुट और स्ट्रिंग्स की एक सूची को आउटपुट कर सकते हैं। बाइट्स का एक गुच्छा बचाओlambda n:n[1:-1]
— ल्यूक Sawczak
1
जब से आप स्टैडिन से पढ़ सकते हैं, लैम्ब्डा को input()केवल पायथन 3 से बदल सकते हैं
— BallpointBen
तुम सही हो। धन्यवाद। मैं संपादन जोड़ दिया है!
— कीर्तन प्रभाकरन
13

ब्रेन-फ्लैक , 133 बाइट्स

{{}((((()()()()){}){}){}[{}](<()>)){{}{}(<(())>)}{}}{}{({}<>)<>}<>{{}((((()()()()){}){}){}[{}](<()>)){{}{}(<(())>)}{}}{}{({}<>)<>}<>

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

कोड के 132 बाइट्स, साथ ही -cध्वज के लिए 1 बाइट जो एएससीआईआई इनपुट और आउटपुट की अनुमति देता है।

दुर्भाग्य से, इसमें बहुत सारे डुप्लिकेट किए गए कोड हैं, लेकिन पुन: उपयोग करना वास्तव में मुश्किल होगा। मैं बाद में इस पर गौर करूंगा। यहाँ एक स्पष्टीकरण है:

#While True
{
    #Pop
    {}

    #Not equals 32
    ((((()()()()){}){}){}[{}](<()>)){{}{}(<(())>)}{}

#Endwhile
}

#Pop the 0
{}

#Reverse Stack
{({}<>)<>}<>

#While True
{
    #Pop
    {}

    #Not equals 32
    ((((()()()()){}){}){}[{}](<()>)){{}{}(<(())>)}{}

#Endwhile
}

#Pop the 0
{}

#Reverse Stack
{({}<>)<>}<>
— DJMcMayhem
स्रोत
86 बाइट्स जब आप टिप्पणियाँ निकालते हैं। मैंने पहली दो और अंतिम पंक्ति को जोड़ा। टीआईओ
— रिले
@ रिले कूल समाधान। इसे स्वयं पोस्ट करने के लिए स्वतंत्र महसूस करें!
— DJMcMayhem
12

हास्केल, 23 , 17 9 बाइट्स

init.tail

लेता है और तार की सूची देता है। इसे ऑनलाइन आज़माएं!

पहले तार को गिराओ, आखिरी तार को गिराओ।

संपादित करें: @ जेनरिक डिस्प्ले ने नोट किया, कि इनपुट स्ट्रिंग्स की एक सूची हो सकती है, जिसने 6 बाइट्स को बचाया।

एडिट II: एक स्ट्रिंग के बजाय स्ट्रिंग्स की वापसी सूची

— nimi
स्रोत
ऐसा लगता है कि सूची में अनुमति के अनुसार इनपुट है, इसलिए -5 बाइट के लिए शब्दों को छोड़ दें
— जेनेरिक डिस्प्ले नाम
@GenericDisplayName: ओह, ध्यान नहीं दिया। धन्यवाद!
— nimi
मेरे ओम का उत्तर और गणितज्ञ दोनों स्ट्रिंग्स के आउटपुट सूचियों का उत्तर देते हैं, इसलिए आप शायद unwords.-8 बाइट छोड़ सकते हैं ।
— निक क्लिफर्ड
@ नाइक क्लिफोर्ड: हां, मैंने खुद देखा और ओपी से स्पष्टीकरण मांगा।
— मिमी
11

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

Rest@*Most

एक अनाम फ़ंक्शन जो स्ट्रिंग की सूची को स्वीकार करता है और वापस करता है।

Restअंतिम तत्व को Mostछोड़ता है, पहले तत्व को त्यागता है, @*फ़ंक्शन रचना है। अदला-बदली Restऔर Mostया राइट-रचना का उपयोग कर /*के बजाय भी काम करेंगे। यह #[[2;;-2]]&एक बाइट द्वारा अनुक्रमण को धड़कता है ।

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

ब्रेन-फ्लैक , 86 बाइट्स

(()()){({}[()]<{{}((((()()()()){}){}){}[{}](<()>)){{}{}(<(())>)}{}}{}{({}<>)<>}<>>)}{}

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

इस उत्तर से अधिकांश कोड आता है । यदि आप मेरे समाधान को पसंद करते हैं तो आपको उस एक को भी उभारना चाहिए।

#Push 2
(()())

#Loop twice
{({}[()]<

  #While not a space
  {
      #Pop
      {}

      #Not equals 32
      ((((()()()()){}){}){}[{}](<()>)){{}{}(<(())>)}{}

  #Endwhile
  }

  #Pop the 0
  {}

  #Reverse Stack
  {({}<>)<>}<>

#End loop twice
>)}{}
— रिले
स्रोत
बहुत बढ़िया! मैंने बाद में धकेलने के लिए काउंटर रखने के बारे में नहीं सोचा था, इसलिए मैंने बहुत लंबे समय तक यह सोचने में बिताया कि विभिन्न स्टैक के पार कैसे जाना है।
— DJMcMayhem
8

जावा 7, 74 बाइट्स

String f(String s){return s.substring(s.indexOf(' '),s.lastIndexOf(' '));}

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

s->s.substring(s.indexOf(' '),s.lastIndexOf(' '))

फंक्शन जो स्पेस कैरेक्टर की पहली घटना और आखिरी की पहचान करता है और बीच को अर्क करता है। परिणामी स्ट्रिंग को एक स्थान वर्ण द्वारा प्रीफ़िक्स किया गया है (पोस्टिंग के समय, ओपी ने स्पष्ट नहीं किया है कि यदि प्रमुख स्थान अनुमत हैं), जिसे जोड़कर समाप्त किया जा सकता है.trim() 7 बाइट्स की अतिरिक्त लागत के लिए कोड को ।

सी # की तुलना में, जावा में उप-स्ट्रिंग लंबाई के बजाय अंत सूचकांक को निर्दिष्ट करने का लाभ है, जो बाइट की गिनती को नीचे लाता है।

— adrianmp
स्रोत
7

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

स्ट्रिंग की एक सरणी लेता है और आउटपुट करता है।

([_,...a])=>a.pop()&&a

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

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

स्ट्रिंग संस्करण (27 बाइट्स)

एक स्ट्रिंग लेता है और आउटपुट करता है। आउटपुट स्ट्रिंग या तो एक एकल स्थान है यदि कोई मध्य नाम नहीं मिला, या अग्रणी और अनुगामी रिक्त स्थान के साथ मध्य नाम।

s=>(/ .* /.exec(s)||' ')[0]

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

— Arnauld
स्रोत
/./.exec.bind(/ .* /)# 2 की नकल करने के लिए लगता है, सिवाय कुछ nullनहीं
— dandavis
7

AWK , 17 10 बाइट्स

@ बाइट के लिए धन्यवाद 7 बाइट्स बचाए!

$NF=$1=x;1

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

स्पष्टीकरण:

$NF=    set last word to
$1=     set first word to
x       an empty variable, ie empty string
1       default action, ie print everything
— betseg
स्रोत
11 बाइट्स के लिए नीचे के बाल काटे जा सकता है$NF=$1="";1
— स्टीव
3
या 10 का उपयोग$NF=$1=x;1
— स्टीव
1
@ जल्दी करो क्या करता 1है? मैं AWK पर इतना अच्छा नहीं हूँ :)
— betseg
1 का अर्थ है $ 0 को प्रिंट करने के लिए डिफ़ॉल्ट क्रिया, अर्थात।
— स्टीव
6

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

{it.split()[1..-2]}

स्पष्टीकरण:

{        
 it                  all closures have an implicit argument called "it"
   .split()          splits by spaces by default. Returns an array of words
           [1..-2]   take the whole array from the second index (1) to the penultimate index (-2). Implicitly return
                  }

एक बंद / अनाम फ़ंक्शन

— staticmethod
स्रोत
1
PPCG में आपका स्वागत है! क्या आप स्ट्रिंग्स की सूची को इनपुट के रूप में छोड़ सकते हैं .split()?
— मार्टिन एंडर
मार्टिन एंडर हाँ, यदि आप मानते हैं कि इनपुट हमेशा तार की एक सूची होगी तो {यह [1 ..- 2]} काम करेगा।
— स्थैतिकमोद
5

PHP, 37 बाइट्स

<?=join(" ",array_slice($argv,2,-1));

सरणी के रूप में आउटपुट के लिए -4 बाइट्स

print_r(array_slice($argv,2,-1));

PHP, 42 बाइट्स

echo trim(trim($argn,join(range("!",z))));

PHP, 50 बाइट्स

echo preg_filter("#(^[^\s]+ |[^\s]+$)#","",$argn);
— जार्ग हुल्सरमन
स्रोत
4

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

^\S+ |\S+$

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

पहले शब्द (इसके बाद का स्थान सहित) और अंतिम शब्द से मेल खाता है और दोनों को हटा देता है।

यदि I / O एक पंक्तिबद्ध-पृथक सूची हो सकती है, तो इसे 8 बाइट्स में किया जा सकता है:

A1`
G-2`

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

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

पर्ल 5 , 27 18 बाइट्स

-nविकल्प के साथ चलाने की आवश्यकता है ।

/ (.+) /&&print$1

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

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

संपादित करें

-9 बाइट्स दादा को धन्यवाद ।

गैर-लालची क्वांटिफायर की जरूरत नहीं है, कुछ अन्य चीजों के साथ।

— मैक्सिम मिखायलोव
स्रोत
/ (.+) /&&print$1सॉर्टर होना चाहिए। कुछ नए लोगों को पर्ल के साथ गोल्फ करते हुए देखना शानदार है!
— दादा
@ दादा टिप के लिए धन्यवाद! यह वास्तव में मेरा पहली बार पर्ल में लेखन है। क्या आप जानते हैं कि print if s| (.+) |\1|काम क्यों नहीं होता है? मेरे लिए यह वही है जो आपने लिखा है।
— मैक्सिम मिखायलोव
print if s| (.+) |\1|मध्य भाग की जगह ... मध्य भाग! (पहले और बाद में रिक्त स्थान घटाएं), इसलिए यह काम नहीं करता है। दूसरी तरफ, मैंने जो सुझाव दिया वह केवल मध्य भाग से मेल खाता है और केवल इसे प्रिंट करता है ( $1)।
— दादा
4

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

संपादित करें:

a=>a.slice(1,-1)

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

ungolfed:

function(name) {
  return a.slice(1, -1); //start at the second item and end at the second to last item
};

मैं कुछ सरल गुणों को भूल गया slice, और यह कि इनपुट एक सरणी हो सकती है। @Neil और @ fəˈn @t Ik की बदौलत मैं 27 बाइट निकाल पाया। अभी भी वास्तव में प्रतिस्पर्धा नहीं है।

मूल:

यह वास्तव में प्रतिस्पर्धा नहीं है, लेकिन यहां एक जावास्क्रिप्ट समाधान है:

a=>{a=a.split(' ');return a.slice(1, a.length-1)}

यह इसके बराबर एक अनाम फ़ंक्शन बनाता है:

function(name) {
  let name = name.split(' '); //first middle last -> [first, middle, last]
  return name.slice(1, name.length - 1); //get the second item to the second to last item in the array.
}

मैंने इसे कैसे गोल्फ दिया

यह एक बहुत ही सरल गोल्फ है। मैंने फ़ंक्शन को एक तीर फ़ंक्शन में बदल दिया । फिर मैंने कोड "छोटा" किया। इसमें nameएकल वर्ण ( aइस मामले में) का नाम बदलना और हटाना शामिल थाlet चर विघटन को शामिल करना शामिल था।

टुकड़ा

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

आशा है कि यह किसी को भी मदद करता है जो चुनौती पर फंस गया है।

— डेविड आर्चीबाल्ड
स्रोत
length -अनावश्यक है, के रूप में sliceपहले से ही समाप्त करने के लिए रिश्तेदार होने के रूप में नकारात्मक लंबाई स्वीकार करता है। इसका मतलब है कि अब आपको मध्यवर्ती चर की आवश्यकता नहीं है, इसलिए आप अपने तीर फ़ंक्शन को एक ब्लॉक से एक अभिव्यक्ति में बदल सकते हैं।
— नील
वास्तव में यह जिस तरह से काम करता है वह -1अंतिम है लेकिन एक है जो आपको यहां चाहिए।
— नील
यह स्लाइस (1, -1) भी है। टुकड़ा (1, -2) अंत से दो को निकालता है।
— f --n 0tɪk
आप यह भी मान सकते हैं कि आपको शुरू करने के लिए एक सरणी दी गई थी, जो आपको सिर्फ स्लाइस करने के लिए तैयार करती है और आप कर रहे हैं।
— f --n 0tɪk
मुझे 99% यकीन है कि जब से मैंने इसे शुरू किया था तब से इसे बदल दिया गया था। एक बार फिर धन्यवाद।
— डेविड आर्किबाल्ड
3

रोड़ा , 9 बाइट्स

{_[1:-1]}

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

बहुत दिलचस्प समाधान नहीं है। स्ट्रीम से एक सूची लेता है और मध्य नाम लौटाता है।

21 बाइट्स और I / O:

{[(_/" ")[1:-1]&" "]}

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

यह /(विभाजन) और &(शामिल) का उपयोग करता है ।

— fergusq
स्रोत
3

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

ḊṖ

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

यह एक गैर-इनलाइन लिंक (यानी फ़ंक्शन) के रूप में काम करता है, न कि एक पूर्ण कार्यक्रम।

'John','Jacob','Jingleheimer','Schmidt' → 'Jacob','Jingleheimer'

एक पूर्ण कार्यक्रम के रूप में, यह 3 बाइट्स होगा: ḊṖKजो एक अंतरिक्ष-पृथक मध्य नाम को प्रिंट करता है।

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

सी #, 67 बाइट्स

s=>s.Substring(s.IndexOf(' ')+1,s.LastIndexOf(' ')-s.IndexOf(' '));

बेनामी फ़ंक्शन जो अंतरिक्ष चरित्र और पिछले एक की पहली घटना की पहचान करता है और बीच को निकालता है। यह एक अनुगामी स्थान भी निकालता है, जिसे 2 बाइट्स की कीमत पर हटाया जा सकता है।

परीक्षण मामलों के साथ पूरा कार्यक्रम:

using System;

namespace WhatsMyMiddleName
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string, string> f =
            s=>s.Substring(s.IndexOf(' ')+1,s.LastIndexOf(' ')-s.IndexOf(' '));

            Console.WriteLine(f("Jo Jean Smith"));          // "Jean"
            Console.WriteLine(f("Samantha Vee Hills"));     // "Vee"
            Console.WriteLine(f("Bob Dillinger"));          // ""
            Console.WriteLine(f("John Jacob Jingleheimer Schmidt"));// "Jacob Jingleheimer"
            Console.WriteLine(f("Jose Mario Carasco-Williams"));    // "Mario"
            Console.WriteLine(f("James Alfred Van Allen")); // "Alfred Van"
        }
    }
}
— adrianmp
स्रोत
3

आर, 30 27 22 बाइट्स

User11599 के कारण वर्तमान समाधान!

head(scan(,''),-1)[-1]

स्टड से इनपुट लेता है, प्रत्येक मध्य नाम को एक अलग स्ट्रिंग के रूप में देता है। character()कोई मध्य नाम के मामले में रिटर्न ; यह characterलंबाई के वर्ग का एक वेक्टर है 0।

स्पष्टीकरण:

स्टड की एक सूची में स्टडिन पढ़ें, रिक्त स्थान से अलग

     scan(,'')

अंतिम तत्व निकालें। डिफ़ॉल्ट करने के साथ, सूची headके पहले nतत्वों को लौटाता nहै 6। अगर nहै -1कि यह सब लेकिन पिछले तत्व देता है।

head(scan(,''),-1)

अब, इस सूची के पहले तत्व को हटा दें।

head(scan(,''),-1)[-1]

इससे मध्य नाम (s) प्राप्त होता है।

— rturnbull
स्रोत
1
इससे भी छोटा: सिर (स्कैन, ''), - 1) [- 1] 22 बाइट्स। ध्यान दें कि '' दो एकल उद्धरण हैं।
— user11599
यदि आप 27 बाइट्स, कैट (हेड (स्कैन, ''), - 1) [- 1]]
— user11599
स्पष्टीकरण: स्कैन (, '') शब्दों में स्ट्रिंग को तोड़ता है, सिर (..., - 1) अंतिम शब्द को गिराता है, सिर (..., - 1) [- 1] फिर पहला शब्द, बिल्ली () गिरता है आउटपुट उद्धरणों को प्रारूपित करता है। कोई मध्य नाम के लिए, परिणाम सही नहीं है, यह चरित्र (0) है, खाली स्ट्रिंग।
— user11599
@ user11599 वाह, धन्यवाद! मैं के साथ head()और आसपास खेला था tail(), लेकिन मुझे नहीं पता था कि आप दूसरे तर्क के रूप में एक नकारात्मक संख्या पारित कर सकते हैं। अच्छा!
— rturnbull
आपके स्कैन (, '') के उपयोग ने मुझे प्रेरित किया। मैं इस तरह संपर्क करने के बारे में नहीं सोचा था।
— user11599
3

रूबी, 24 13 बाइट्स

p ARGV[1..-2]

सहेजे गए 11 बाइट्स को Piccolo की ओर इशारा करते हुए बताते हैं कि सरणी-जैसे आउटपुट की अनुमति है।

नाम को अलग कमांड लाइन तर्क के रूप में लेता है, जैसे:

$ ruby script.rb John Jacob Jingleheimer Schmidt

या

$ ruby -e 'p ARGV[1..-2]' John Jacob Jingleheimer Schmidt

पिछला कोड (एक उचित स्ट्रिंग आउटपुट):

puts ARGV[1..-2].join" "
— Flambino
स्रोत
@ जोर्डन अच्छा विचार - हालांकि इसके साथ अप्रत्याशित होने की $><<ARGV[1..-2].join" "शिकायत होती है " ", इसलिए मुझे कोष्ठक जोड़ना होगा - जो अंत में 1 बाइट जोड़ देगा।
— फ्लाम्बिनो
आह, बिल्कुल। मेरी गलती।
— जॉर्डन
मूल पोस्टर में कहा गया है कि आउटपुट एक सरणी हो सकता है, इसलिए आप अपने कोड को बदलकर कुछ वर्णों को बंद कर सकते हैं puts ARGV[1..-2], बस आप जानते हैं।
— पिकाको
@Piccolo हुह? मुझे वह कहीं दिखाई नहीं देता? यदि सत्य हैं; p ARGV[1..-2]13 बाइट्स के लिए
— ओपीएस
— पिकाको
3

गोलांग , 152 81 बाइट्स

import ."strings"
func f(x string)[]string{var k=Fields(x);return k[1:len(k)-1];}

यह "सामन्था वी हिल्स" (दोहरे उद्धरण चिह्नों के साथ) के रूप में इनपुट लेता है और मध्य नाम को स्टैडआउट में वापस करता है।

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

संपादित करें: @ दादा, ध्यान दें कि "उत्तर के रूप में कार्य करने की अनुमति है" मेरे कोड को 71 बाइट्स छोटा करता है। एक बड़ा धन्यवाद!

— ersinakyuz
स्रोत
साइट पर आपका स्वागत है। किसी फ़ंक्शन को उत्तर के रूप में सबमिट करने की अनुमति है, इसलिए आप कुछ ऐसा करके अपने कोड को छोटा कर सकते हैं: इसे ऑनलाइन आज़माएं! । जाओ में गोल्फ के लिए युक्तियाँ पर एक नज़र है !
— दादा
युक्तियों के लिए धन्यवाद @ दादा और मेरे कोड को छोटा करें। यह मेरी पहली कोड प्रविष्टि थी।
— 8:रसिंयुज
3

मतलाब, 81 , 79 , 78 , 55 बाइट्स

function x=a(s)
s=strsplit(s);x=strjoin(s(2:end-1));end

एक इनपुट स्ट्रिंग में लेता है, s एक सेल ऐरे में विभाजित होता है (डिफ़ॉल्ट सीमांकक, व्हाट्सएप चार्ट), जिससे मध्य तत्व एक्सेस होता है। फिर मध्य तत्वों को समतल किया जाता है, या एक खाली स्ट्रिंग वापस किया जाता है।

संपादित करें: 3 बाइट बचाने के लिए लुइस मेंडो के लिए धन्यवाद!

संपादित 2: अंकित से बेहतर समाधान!

— ओवेन मॉर्गन
स्रोत
मैं स्मार्ट आदमी नहीं हूँ! संपादित।
— ओवेन मॉर्गन
आप nnzसेल सरणी पर उपयोग नहीं कर सकते , लेकिन मैंने अन्य दो बदलाव किए :)
— Owen Morgan
अंकित द्वारा सुझाए गए संपादन , जिनके पास टिप्पणी करने के लिए पर्याप्त प्रतिनिधि नहीं है। (55 बाइट्स):function x=a(s) s=strsplit(s);x=strjoin(s(2:end-1));end
— mbomb007
3

सी, 42 बाइट्स

f(char**b){for(;b[2];printf("%s ",*++b));}

पैरामीटर संकेत करने के लिए चार की एक पूर्ण समाप्त सरणी है।

इसे यहां देखें ।

कमांड लाइन तर्कों का उपयोग समान फ़ंक्शन के साथ भी किया जा सकता है ।

सी, 51 बाइट्स

main(a,b)char**b;{for(;b[3];printf("%s ",b++[2]));}

एक पूरा कार्यक्रम। इनपुट कमांड लाइन तर्कों के माध्यम से किया जाता है।

इसे यहां देखें ।

सी, 54 बाइट्स

f(char**b){*strrchr(*b=strchr(*b,32),32)=0;*b+=!!**b;}

पैरामीटर एक / बाहर पैरामीटर है।

इसे यहां देखें ।

— 2501
स्रोत
PPCG में आपका स्वागत है!
— मार्टिन एंडर
विजुअल स्टूडियो 2012 के साथ संकलन करते समय मुझे निम्न त्रुटि प्राप्त हो रही है: त्रुटि C2100: अवैध अप्रत्यक्षता
— जोहान डू टिट
@JohanduToit VS C11 या C99 अनुरूप नहीं है। मेरा कोड है व्यावहारिक प्रमाण के रूप में, gcc और clang दोनों एक मान्य प्रोग्राम संकलित करते हैं।
— 2501
2

अजगर 2, 42 19 16 बाइट्स

lambda n:n[1:-1]

इसे ऑनलाइन आज़माएं! 23 बाइट बचाने के लिए @ कृति लिथोस को धन्यवाद! 3 और बाइट्स बचाने के लिए @math_junkie धन्यवाद। इनपुट के लिए, सूची के प्रत्येक नाम को स्ट्रिंग की तरह एक सूची में रखें:

["Samantha", "Vee", "Hills"]

और हां, ओपी ने एक मान्य इनपुट होने के लिए एक सूची को मंजूरी दी है।

व्याख्या

lambda n:n[1:-1]    # Returns only the middle elements... pretty literal here
— एंथोनी फाम
स्रोत
1
print input()[1:-1]छोटा है
— कृति लिथोस
स्प्रिंग स्लाइसिंग यकीन है कि मुश्किल है
— एंथनी फाम
lambda n:n[1:-1]इससे भी छोटा है
— गणित नशेड़ी
1
मैंने गलत इनपुट के साथ कोशिश की होगी। लेकिन जब मैंने कोशिश की, Samantha Vee Hillsतो आपके द्वारा साझा किए गए repl.it लिंक में इनपुट के रूप में, यह सिर्फ प्रिंट amantha Vee Hillकरता है जो निश्चित रूप से आवश्यक आउटपुट नहीं है।
— कीर्तन प्रभाकरन
2
Names will always have at least 2 space-separated partsसवाल का पहला बिंदु सही है।
— कीर्तन प्रभाकरन
2

सी ++, 91 बाइट्स

#import<list>
#import<string>
void f(std::list<std::string>&n){n.pop_front();n.pop_back();}

इनपुट को स्ट्रिंग्स की सूची के संदर्भ के रूप में लेता है और सूची को सीधे संशोधित करता है।

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

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