जिमी विविधता का एक दृश्य

25

जैसा कि आप शायद जानते हैं, हाल ही में पॉपिंग में कई प्यारी जिमी चुनौतियां आई हैं । इन चुनौतियों में, आपको हमारे प्यारे दोस्त के कलाबाजी कौशल के साथ चुनौती दी गई थी। अब हमें आपके लिए एक अलग चुनौती मिल गई है। आज आप विभिन्न प्रकार के जिस्मों की पहचान करेंगे!

व्याख्या

जिमी के तीन प्रकार हैं: बौना, कलाबाज, और बॉडी बिल्डर।

This is dwarf Jimmy:               o

This is acrobat Jimmy:            /o\

This is bodybuilder Jimmy:       /-o-\

ये जिम्मी सभी महान दोस्त हैं और वे एक-दूसरे की तरह एक ही पंक्ति पर खड़े होना पसंद करते हैं। आपका काम है, जैसे एक जिमी दृश्य दिया:

  o  /o\       o   /-o-\/-o-\  o          /o\

क्रमशः लाइन पर बौनों, कलाबाजों और तगड़े लोगों की मात्रा का उत्पादन।

चुनौती

  • जिमी दृश्य के रूप में किसी भी उचित रूप में इनपुट लें, जैसा कि ऊपर दिए गए उदाहरण में दिखाया गया है।

    1. इनपुट स्ट्रिंग एक पंक्ति होनी चाहिए और वैकल्पिक रूप से इसमें तीन प्रकार के जिमीज़ और वैकल्पिक व्हॉट्सएप शामिल हैं।

    2. जरूरी नहीं कि स्ट्रिंग में जिमी की सभी किस्में या व्हॉट्सएप हों।

    3. स्ट्रिंग में कोई भी वर्ण नहीं होगा o/\ -।

    4. जिमी किस्मों का कोई भी संयोजन संभव है। इसका मतलब है कि एक ही या विभिन्न प्रकार के जिमी एक दूसरे के बगल में हो सकते हैं। आपको उसका हिसाब देना चाहिए।

    5. व्हाट्सएप का प्रमुख और अनुगामी होना वैकल्पिक है और किसी भी तरह की आवश्यकता नहीं है - आपके कार्यक्रम को व्हाट्सएप को अग्रणी और / या अनुगामी के बिना एक स्ट्रिंग के लिए खाता होना चाहिए।

    6. स्ट्रिंग में केवल मान्य जिममिस और व्हाट्सएप होना चाहिए। उदाहरण के लिए, ---///---अनुमति नहीं है क्योंकि यह एक वैध जिमी अनुक्रम नहीं है।

  • आउटपुट तीन नंबर: दृश्य में बौनों, कलाबाजों और तगड़े की गिनती (संबंधित क्रम में)।

    1. यह कंसोल के लिए स्पेस-अलग-अलग पूर्णांकों के रूप में आउटपुट हो सकता है, या यह किसी प्रकार के कंटेनर (यानी एक सरणी प्रकार) के रूप में फ़ंक्शन से वापसी मान हो सकता है।

    2. आउटपुट, जो भी प्रारूप में है, उसे इस नियम के ऊपर शीर्ष बुलेट में वर्णित किया जाना चाहिए।

  • मानक नियम और खामियां लागू होती हैं।

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

     /-o-\           /-o-\     o/o\  /-o-\       /-o-\                /-o-\
OUTPUT: 1 1 5


      o o               /o\    o o      o                    /o\             /o\
OUTPUT: 5 3 0


 /-o-\     /-o-\            /-o-\/-o-\   o /o\/o\    /-o-\o /-o-\       /o\/-o-\
OUTPUT: 2 3 7


  /-o-\  o                 /-o-\               o/o\
OUTPUT: 2 1 2

यदि आप अधिक परीक्षण मामले चाहते हैं, तो अधिक यादृच्छिक परीक्षण मामलों को उत्पन्न करने के लिए इस उपकरण का उपयोग करें ।

स्कोरिंग

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

आप नीचे विजेट / स्निपेट का विस्तार करके इस पोस्ट के लिए लीडरबोर्ड देख सकते हैं। आपकी पोस्ट को रैंकिंग में शामिल करने के लिए, आपको # header textनिम्नलिखित जानकारी के साथ एक हेडर ( ) चाहिए:

  • भाषा का नाम (इसे कॉमा ,या डैश के साथ समाप्त करें -), उसके बाद ...

  • बाइट गिनती, आपके शीर्ष लेख में दिखाई देने वाली अंतिम संख्या के रूप में।

उदाहरण के लिए, JavaScript (ES6), 72 bytesमान्य है, लेकिन Fortran, 143 bytes (8-bit)अमान्य है क्योंकि बाइट गिनती हैडर में अंतिम संख्या नहीं है (आपका उत्तर 8 बाइट्स के रूप में पहचाना जाएगा - इसका लाभ न लें)।

<!-- Run the snippet to see the leaderboard. Report any bugs to @xMikee1 on Github. -->    <iframe src="https://ozewski.github.io/ppcg-leaderboard/?id=188391" width="100%" height="100%" style="border:none;">Oops, your browser is too old to view this content! Please upgrade to a newer version of your browser that supports HTML5.</iframe><style>html,body{margin:0;padding:0;height:100%;overflow:hidden}</style>
स्निपेट का विस्तार करें

code-golf  string  counting 
— अपना चार्जर कनेक्ट करें
स्रोत
क्या हम मान सकते हैं कि सभी इनपुट में कम से कम एक अग्रणी और अनुगामी स्थान होगा?
— झबरा
7
@connectyourcharger को ऑर्डर निर्दिष्ट करने के लिए उत्तर की आवश्यकता होगी।
— डाटा
4
बस स्पष्ट होने के लिए, बौना जिम्मी एक साथ खड़े हो सकते हैं? मैं अन्यथा सुझाव देने के लिए कुछ नहीं देखता हूं। यदि हां, तो एक परीक्षण का मामला oo /o\ o oअच्छा होगा
— Veskah
1
@Veskah: टेस्ट केस जनरेटर अनुक्रम उत्पन्न करने में सक्षम है oo।
— पुनरावर्ती
8
एक जिमी टैग होने की जरूरत है ।
— MilkyWay90

जवाबों:

8

जेली , (12?) 13 बाइट्स

ċⱮ“-/o”H1¦ŻIṚ

एक मोनाडिक लिंक वर्णों की एक सूची को स्वीकार करता है जो पूर्णांकों की सूची देता है, [ dwarves, acrobats, and body-builders]( Ṛबाइट को सहेजें यदि हम अपना मान निर्दिष्ट कर सकते हैं)

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

कैसे?

सभी जिम्मी एक दिखाते हैं o; सभी गैर बौने दिखाते हैं /; सभी बॉडी-बिल्डर्स दो दिखाते हैं -। इनकी गणना करें, गिनें की संख्या को आधा करें -, और जिमी की गिनती खोजने के लिए घटाव का प्रदर्शन करें:

ċⱮ“-/o”H1¦ŻIṚ - Link: list of characters
  “-/o”       - list of characters ['-', '/', 'o']
 Ɱ            - map across right with:
ċ             -   count occurrences   = [n('-'), n('/'), n('o')]
         ¦    - sparse application...
        1     - ...to indices: [1] -- i.e. n('-')
       H      - ...action: halve    = [n('-')/2, n('/'), n('o')]
          Ż   - prepend a zero =   [0, n('-')/2, n('/'), n('o')]
           I  - incremental differences
              -     = [n('-')/2, n('/')-n('-')/2, n('o')-n('/')]
            Ṛ - reverse
              -     = [n('o')-n('/'), n('/')-n('-')/2, n('-')/2]
— जोनाथन एलन
स्रोत
21

पायथन 3.8 (पूर्व-रिलीज़) , 51 बाइट्स

lambda s:((c:=s.count)('o')-c('/'),c('/o'),c('/-'))

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

— आउटगोल्फर को एरिक करें
स्रोत
अंतिम रूप से अजगर ने कुछ इस तरह जोड़ा। मैं कुछ समय के लिए पायथन को अभिव्यक्तियों के रूप में असाइनमेंट की अनुमति देने के लिए इंतजार कर रहा हूं। एक शर्म की बात है कि यह एक अतिरिक्त बाइट लेता है, लेकिन मैं इसे ले
— जाऊंगा
@HyperNeutrino मूल रूप से एक कारण है कि आप अब साइट के चारों ओर "पायथन 3.8 (पूर्व-रिलीज़)" देख सकते हैं। एक और प्रतिबंध है कि है, जब तक यह अपने आप ही है और न केवल एक बयान में अभिव्यक्ति (इस स्थिति में आप नियमित रूप से काम करने के बजाय पसंद कर सकते हैं), यह parenthesized किया जाना चाहिए (+2 बाइट्स)।
— आउटगॉल्फ जूल
('o')बिना आह्वान के पहली गणना कैसे की जाती है c?
— क्विन
@ क्विन असाइनमेंट एक्सप्रेशन को असाइन करता s.countहै cऔर फिर उसे लौटाता है।
— आउटगॉल्फ
@ErikTheOutgolfer कूल, टीआईएल
— क्विन
12

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

x,y,z=map(input().count,'o/-')
print x-y,y-z/2,z/2

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

-10 बाइट्स लैंबडा एक्सप्रेशन को पूर्ण प्रोग्राम के लिए @xnor के लिए धन्यवाद में परिवर्तित करके (डबल लैम्ब्डा नेस्टेड चीज़ को हटाता है और इसके बजाय असाइनमेंट का उपयोग करता है)

— HyperNeutrino
स्रोत
3
यह एक अच्छा तरीका है, और यह एक कार्यक्रम के रूप में छोटा है ।
— xnor
5

जे , 36 25 बाइट्स

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

2-/\0,~1 1 2%~1#.'o/-'=/]

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

मूल समाधान

जे , 36 बाइट्स

[:(-/@}:,-/@}.,{:)1 1 2%~1#.'o/-'=/]

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

स्पष्टीकरण:

                            'o/-'=/] compare the input with each one of "o/-" characters
                                     / the result is a 3-row matrix /
                         1#.         add up each row to find the number of occurences
                                     of each character, the result is a vector of 3 items
                  1 1 2%~            divide the last item by 2 to find the number of 
                                     bodybuilder Jimmys
[:(              )                   use the result to construct the following vector:
               {:                    the last item
              ,                      appended to
         -/@}.                       the difference of the second and the third items
        ,                            appended to
   -/@}:                             the difference of the first and the second items

एक नमूना जम्मू सत्र:

a=:'  /-o-\  o                 /-o-\               o/o\'
   'o/-'=/a
0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0
0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0
0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   1#.'o/-'=/a
5 3 4  
   1 1 2%~1#.'o/-'=/a
5 3 2
   (-/@}:,-/@}.,{:)1 1 2%~1#.'o/-'=/a
2 1 2
— गैलेन इवानोव
स्रोत
1
— कोल
वूप्स, अब मेरी टिप्पणी को संपादित नहीं कर सकता है - यह भी 25 बाइट्स है यदि यह सही है, तो 0. को जोड़ने का एक अलग तरीका है
— कोल
1
@ हेले हाह, जैसा कि अक्सर मेरे साथ होता है, मैंने पैटर्न नहीं देखा। धन्यवाद!
— गैलेन इवानोव
यह दुर्भाग्यपूर्ण है कि मैंने इसे केवल उसी रूप में देखा जैसा कि आप उस स्पष्टीकरण में संपादित कर रहे थे - हमेशा समझाने की कोशिश करने के लिए खो जाने के लिए शर्म की बात है।
— कोल
@ इसीलिए मैं अपने दोषों का स्पष्टीकरण स्पष्ट रूप से रखूंगा :)
— गैलेन इवानोव
5

CSV, 130 बाइट्स के रूप में एक्सेल

,=LEN(A3)-LEN(A4)
=SUBSTITUTE(A1,"-o",""),=(LEN(A2)-LEN(A3))/2
=SUBSTITUTE(A2,"/o",""),=(LEN(A1)-LEN(A2))/2
=SUBSTITUTE(A3,"o","")

पहले अंतरिक्ष में इनपुट डालें ,, .csv के रूप में सहेजें, एक्सेल में खोलें। आउटपुट बौनों, कलाबाज़ और में तगड़े B1, B2और B3क्रमशः।

एक्सेल, 244 बाइट्स

=LEN(SUBSTITUTE(SUBSTITUTE(A1,"-o",""),"/o",""))-LEN(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,"-o",""),"/o",""),"o",""))&" "&(LEN(SUBSTITUTE(A1,"-o",""))-LEN(SUBSTITUTE(SUBSTITUTE(A1,"-o",""),"/o","")))/2&" "&(LEN(A1)-LEN(SUBSTITUTE(A1,"-o","")))/2
— Wernisch
स्रोत
4

कोटलिन 131 130 129 121 117 97 96 88 बाइट्स

fun String.j(b:Int=count{'-'==it}/2,a:Int=count{'/'==it})=listOf(count{'o'==it}-a,a-b,b)

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

संपादित करें -, यह 100 के तहत मिल गया! मुझे संदेह है कि मैं इसे और अधिक सिकोड़ सकता हूं, लेकिन केवल समय ही बताएगा ...

संपादित करें - बहुत जल्द ही, एक स्ट्रिंग के बजाय एक सूची का उपयोग करके एक और बाइट को गिरा दिया

संपादित करें - माइनस 8 बाइट्स के लिए धन्यवाद AsoLeo एक एक्सटेंशन फ़ंक्शन का उपयोग करने का सुझाव देता है

— क्विन
स्रोत
1
मैं आपको विस्तार विधियों के बारे में बताता हूं, मेरे दोस्त: fun String.j(b:Int=count{'-'==it}/2,a:Int=count{'/'==it})=listOf(count{'o'==it}-a,a-b,b)88 बाइट्स।
— एसो लियो
@ अच्छी तरह से, मैंने वास्तव में इसे मूल रूप से एक विस्तार समारोह के रूप में लिखा था, लेकिन मुझे कुछ और गड़बड़ करना चाहिए था क्योंकि मेरा अधिक बाइट्स था
— क्विन
3

रेटिना , ३ ९ 35 बाइट्स

संपादित करें: -4 बाइट्स @FryAmTheEggMan के लिए धन्यवाद

^((o)|(/o.)|(/-o-.)| )*
$#2 $#3 $#4

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

स्पष्टीकरण:

एक साधारण जगह। यह रेगेक्स के सभी मैचों को ढूँढता है ^((o)|(/o.)|(/-o-.)| )*(जिसके परिणामस्वरूप एक मैच - पूरी स्ट्रिंग) होनी चाहिए और इसे समूह 2, 3, और 4 के कैप्चर की संख्या से बदल देता है। यहाँ रेगेक्स टूट गया है:

^((o)|(/o.)|(/-o-.)| )*
^                               start at the beginning of the string
 (                       )*     have any amount of Jimmy / spaces
     |       |         |        select one of:
  (o)                           capturing group 2 - dwarf
      (/o.)                   capturing group 3 - acrobat
              (/-o-.)         capturing group 4 - bodybuilder

हमें ^एक मैच के रूप में इनपुट काउंट के साथ या अंत शुरू करना होगा । रेटिना के प्रतिस्थापन सिंटैक्स में,$n nth कैप्चरिंग समूह को संदर्भित करता है, और संशोधक #गिनता है कि उसने कितने मैच बनाए।

— lolad
स्रोत
आप कुछ बाइट्स को कम बचकर बचा सकते हैं, क्योंकि स्ट्रिंग को केवल जिमिस होने की गारंटी है: इसे ऑनलाइन आज़माएं!
— फ्रायमई इग्मैन
3

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

एक regex पैटर्न मिलान का उपयोग कर स्ट्रिंग खोजों o, o-या o-\; सूचकांक को निर्धारित करने के लिए प्रत्येक मैच की लंबाई का उपयोग करते हुए, एक सरणी में संबंधित संख्या को बढ़ाता है।

s=>s.replace(/o-?\\?/g,m=>a[m.length-1]++,a=[0,0,0])&&a

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

— darrylyeo
स्रोत
1
@JonathanAllan मैंने अपना जवाब फिर से लिखा।
— darrylyeo
2

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 63 बाइट्स

Reverse@{a=(m=CharacterCounts@#)["-"]/2,b=m["/"]-a,m["o"]-a-b}&

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

55 बाइट्स यदि व्यर्थ ऑर्डर की आवश्यकता समाप्त हो जाती है ...

— समय सीमा समाप्त डेटा
स्रोत
अब @Xcali दूर फिर से छोड़ दिया पर बौने की गणना करनी चाहिए
— समय सीमा समाप्त डाटा
1

पर्ल 5 -p , 41 बाइट्स

$_=1*s/o(?!\\|-)//g.$".1*s|/o||g.$".y/o//

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

गिना जाता है की संख्या कितनी बार oदिखाई देती है \या उसके बाद -बौने पाए जाते हैं और उन्हें स्ट्रिंग से निकाल देते हैं। फिर गणना करता है कि कितनी बार /oएक्रोबेट्स को खोजने के लिए प्रकट होता है और उन्हें स्ट्रिंग से हटा देता है। फिर oबॉडी बिल्डरों को निर्धारित करने के लिए शेष की संख्या को गिना जाता है । संख्याओं के बीच रिक्त स्थान सम्मिलित करता है और अंतर्निहित रूप से परिणाम उत्पन्न करता है।

— Xcali
स्रोत
— नहुएल फौलीउल
@NahuelFouilleul अगर किसी पंक्ति के अंत में बौना है तो वह काम नहीं करता है। इसे बॉडी बिल्डर के रूप में गिना जाता है।
— Xcali
सच है, अन्यथा -4 बाइट्स केवल हटाने1*
— नाहुएल फौइलुल
@NahuelFouilleul यह काम नहीं करता है, या तो। यदि उन प्रकार के कोई उदाहरण नहीं हैं, तो undefइसके बजाय कुछ नहीं ( ) आउटपुट देता है 0।
— Xcali
ठीक है, मैंने सिर्फ परीक्षण के मामलों को देखा
— नहुएल फौलीउल
1

SNOBOL4 (CSNOBOL4) , 135 बाइट्स

	I =INPUT
B	I '-o' =	:F(A)
	B =B + 1	:(B)
A	I '/o' =	:F(D)
	A =A + 1	:(A)
D	I 'o' =	:F(O)
	D =D + 1	:(D)
O	OUTPUT =+D ' ' +A ' ' +B
END

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

प्रत्येक बार स्ट्रिंग से हटाता है -o, /oऔर oस्ट्रिंग से उचित काउंटरों को बढ़ाता है। हाथ और पैर का एक बहुत पीछे छोड़ देता ( /-\, \, और कुछ भी नहीं)।

— ग्यूसेप
स्रोत
0

फोर्थ (gforth) , 118 बाइट्स

: c -rot 0 tuck do over i + c@ 3 pick = - loop nip nip ;
: f 2dup '/ c >r 2dup '- c 2/ -rot 'o c i - . r> over - . . ;

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

व्याख्या

  • की गणना हो जाओ /, -औरo वर्ण
  • बॉडी बिल्डर -2 से विभाजित वर्णों की संख्या है
  • एक्रोबैट उन /पात्रों की संख्या है जो बॉडी बिल्डरों की संख्या घटाते हैं
  • बौना oवर्णों की संख्या है जो एक्रोबेट और बॉडीबिल्डरों की संख्या को घटाती है

कोड स्पष्टीकरण

\ c counts the number of occurrences of the given character in a string
\ stack usage is ( c-addr u1 w1 - u )
: c                 \ start a new word definition
  -rot 0 tuck       \ sets up parameters for a counted loop
  do                \ loop from 0 to string-length - 1 (inclusive)
    over i +        \ get the address of the current character in the string
    c@              \ get the ascii value of the current character              
    3 pick =        \ compare it to the character we're counting
    -               \ subtract result from the accumulator (subtract because -1 = true in forth)
  loop              \ end the loop
  nip nip           \ remove extra values from the stack
;                   \ end the word definition

\ Main function 
: f                 \ start a new word definition
  2dup              \ duplicate the string address and length
  '/ c >r           \ count the number of '/' characters and stick the result on the return stack
  2dup '- c 2/      \ count the number of '-' characters and divide by 2
  -rot 'o c         \ move the string to the top of the stack and count the number of 'o characters
  i - .             \ calculate number of dwarf jimmy's and print
  r> over - .       \ calculate number of acrobat jimmy's and print (drop '/' count from return stack)
  .                 \ print number of body-builder jimmy's
;                   \ end word definition
— reffu
स्रोत
0

05AB1E , 13 बाइट्स

…-/oS¢ć;š0š¥R

यदि कोई आउटपुट-ऑर्डर हटाकर यह 12 बाइट्स हो सकता Rहै[bodybuilder, acrobat, dwarf] अनुमति देता ।

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

माइनर बराबर-बाइट्स वैकल्पिक:

…-/oS¢R`;0)üα

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

स्पष्टीकरण:

…-/o           # Push string "-/o"
    S          # Split to a list of characters: ["-","/","o"]
     ¢         # Count the occurrence of each character in the (implicit) input-string
      ć        # Extract the head; pop and push head and remainder-list
       ;       # Halve this head
        š      # And prepend it back in front of the remainder-list
         0š    # Then also prepend a 0
           ¥   # Get the deltas (forward differences)
            R  # And reverse the list to get the required order of output-counts
               # (after which the result is output implicitly)

…-/oS¢         # Same as above
      R        # Reverse this list
       `       # Pop the list and push its values separately to the stack
        ;      # Halve the top value on the stack
         0     # Push a 0
          )    # Wrap all values on the stack into a list
           ü   # For each overlapping pair of values:
            α  #  Get the absolute difference between the two values
               # (after which the result is output implicitly)
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.