क्या जिमी अपने मंच से गिर जाएगा?

29

पृष्ठभूमि की कहानी

मिलिए मेरे दोस्त जिमी से:

/o\

जिमी एक छोटा पात्र है जो प्लेटफार्मों पर खड़ा होना पसंद करता है। यहाँ जिमी सुरक्षित रूप से एक मंच पर खड़ा है:

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

अब, जिमी को संतुलन की एक अच्छी समझ है, इसलिए वह मंच के एक पैर से सुरक्षित रूप से खड़ा हो सकता है, जैसे:

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

यद्यपि यदि वह मंच से दो या अधिक शरीर के अंगों के साथ खड़ा है, तो वह गिर जाएगा। ये दोनों उदाहरण हैं कि जिमी कहां गिरेगा:

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

चुनौती

आपकी चुनौती यह निर्धारित करने के लिए एक कार्यक्रम लिखने की है, जिमी के मंच और स्थिति के साथ एक स्ट्रिंग दी गई है, अगर जिमी बिना गिरने के मंच पर खड़ा हो सकता है।

  • इनपुट: जिमी की स्थिति और उसके तहत मंच की स्थिति को दर्शाने वाली दो लाइनें। यह दो अलग-अलग इनपुट, एकल इनपुट, या किसी प्रकार की एक सरणी से हो सकता है।

    1. आप किसी भी उचित रूप, समावेश कार्यों और मानक इनपुट के माध्यम से इनपुट ले सकते हैं। केवल हार्ड-कोडिंग का सहारा लें यदि आपकी भाषा अन्य इनपुट विधियों का समर्थन नहीं करती है।

  • आउटपुट: बूलियन सच्चे और झूठे या पूर्णांक 1 या 0 को सही / गलत का प्रतिनिधित्व करने के लिए क्रमशः महत्व देता है।

    1. बूलियन मूल्य इस पर आधारित है कि क्या जिमी मंच पर रह सकता है या नहीं - सच है अगर जिमी मंच पर रह सकता है, या गलत है अगर वह गिर जाएगा।

  • मंच का आकार मनमाना है और इसे इच्छानुसार बदला जा सकता है। आपका कार्यक्रम उसी के लिए होना चाहिए।

    1. प्लेटफ़ॉर्म शून्य की लंबाई नहीं हो सकता है, और प्लेटफ़ॉर्म पूरा होना चाहिए (प्लेटफ़ॉर्म में कोई छेद नहीं)।

    2. याद रखें कि जब शरीर के दो हिस्से प्लेटफ़ॉर्म से लटक रहे थे तब जिमी गिर गया। शरीर का एक अंग उसके शरीर का एक ASCII वर्ण है।

    3. प्लेटफ़ॉर्म के अंत में ट्रेलिंग व्हाट्सएप की आवश्यकता नहीं है, लेकिन आपके कार्यक्रम को दोनों स्थितियों के लिए ध्यान देना चाहिए, जहां प्लेटफॉर्म के बाद व्हाट्सएप है और जहां नहीं है।

  • मना कर दिया है कि मानक खामियों से सावधान रहें ।

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

         /o\               ✔️ TRUE
  -------------

/o\                        ✔️ TRUE
 ----------

                    /o\    ❌ FALSE
  ------------------

               /o\         ❌ FALSE
  -------

    /o\                    ❌ FALSE
     -

स्कोरिंग

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

लीडरबोर्ड

आप नीचे विजेट / स्निपेट का विस्तार करके इस पोस्ट के लिए लीडरबोर्ड देख सकते हैं। आपकी पोस्ट को रैंकिंग में शामिल करने के लिए, आपको # 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://xmikee1.github.io/ppcg-leaderboard/?id=187586" 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  ascii-art 
— अपना चार्जर कनेक्ट करें
स्रोत
क्या हम जिमी के बाद पीछे चल रहे व्हाट्सएप को मान सकते हैं? इसके अलावा अगर आप वर्णों के सरणियों की अनुमति दे रहे हैं, तो कुछ भाषाओं में उन्हें व्हाट्सएप के साथ गद्देदार होना पड़ेगा।
— निक कैनेडी
@NickKennedy आपको व्हॉट्सएप या बिना ट्रेलिंग व्हाट्सएप के अकाउंटिंग की जरूरत है। मैंने उस पर सख्त नियम नहीं बनाए।
— संयोजक 23
12
शीर्षक है " प्लेटफ़ॉर्म की जिम्मी गिरावट " और आपको आउटपुट की आवश्यकता होगी "प्लेटफ़ॉर्म पर जिमी रहना होगा "। क्या यह अपेक्षित व्यवहार है?
— टीश
6
क्या आप अपने परीक्षण मामलों को सुधार कर उन्हें कॉपी और पेस्ट करना आसान बना सकते हैं, कृपया?
— झबरा
2
क्या सत्य-मिथ्या मूल्यों की अदला-बदली की अनुमति है? (यानी आउटपुट सच है जब जिमी गिरता है और जब ऐसा नहीं होता है तो झूठ होता है?)
— श्री एक्सकोडर

जवाबों:

20

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

n⁶Sċ2Ẓ

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

स्पष्टीकरण:

n⁶Sċ2Ẓ  args: z (e.g. [['/', 'o', '\\'], [' ', '-']] => 0)
        implicit return value: z ([['/', 'o', '\\'], [' ', '-']])
n⁶      dyad-nilad pair ([[1, 1, 1], [0, 1]])
 ⁶       4th command-line argument or space [4th CLA assumed absent] (' ')
n        vectorized inequality ([[1, 1, 1], [0, 1]])
  S     reduction by addition with base case 0 ([1, 2, 1])
   ċ2   dyad-nilad pair (1)
    2    literal (2)
   ċ     number of occurrences of right in left (1)
     Ẓ  primality (0)
— आउटग्रॉफर को एरिक करें
स्रोत
26
कभी-कभी मुझे आश्चर्य होता है कि मानव जाति ने यह देखने के लिए कितना उन्नत किया है कि 6 बाइट्स में आप जांच सकते हैं कि कोई व्यक्ति अपने कयामत के लिए एक मंच से गिरने वाला है या नहीं।
— IMustBeSomeone
4
@IMustBeSomeone, अगर मैं अपने कयामत के लिए एक मंच से गिरने जा रहा हूं, तो मैं चाहता हूं कि कोई मुझे बताने में जल्दबाजी करे!
— झबरा
18
@ शैगी मुझे हमेशा लगा कि जब लोग एक परिचय के साथ चुनौती देते हैं तो यह मज़ेदार था: "क्योंकि हम एक्स पर बहुत अधिक समय नहीं बिताना चाहते हैं, कोड को जितना संभव हो उतना छोटा होना चाहिए।", भले ही कोड-गोल्फ और प्रदर्शन। ज्यादातर मामलों में विपरीत हैं। अगर हम से O ( n n ) तक जाने वाली बाइट को बचा सकते हैं , जो प्रदर्शन की परवाह करता है, तो हमें बाइट मिल गई! ; पीO(log⁡(n))O(nn)
— केविन क्रूज़सेन
1
मैं जेली नहीं जानता, लेकिन Sपंक्तियों के बजाय स्तम्भों का योग क्यों है ? : एस अगर मैंने विकी को सही ढंग से देखा तो कोड करता है: n⁶प्रत्येक वर्ण की जांच करें कि यह एक स्थान (यानी ['/o\\', ' -'] -> [[1,1,1],[0,1]]) के बराबर नहीं है ; Sयोग सूची (लेकिन किसी कारण से यह पंक्तियों के बजाय स्तम्भ स्तम्भ .. इसलिए [[1,1,1],[0,1]] -> [1,2,1]); ċ22s की मात्रा गिनें; Ẓजाँच करें कि क्या यह एक प्रमुख (इसलिए 2 या 3) है, परिणाम के बाद आउटपुट है। लेकिन मुझे उम्मीद [[1,1,1],[0,1]]थी कि [3,1]..
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन Sके बराबर है 0;+/Ɗ, यानी, प्रारंभिक मूल्य के साथ इसके अलावा (जो सदिश करता है) को कम करें 0। §वह करता है जो आप करने की उम्मीद Sकरते हैं।
— आउटगॉल्फ जूल
19

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

के रूप में इनपुट लेता है (a)(b)। रिटर्न 0 या 1 ।

a=>b=>b[a.search`o`]=='-'&/--/.test(b)

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

कैसे?

हम "o"पहली कड़ी में जिमी के शरीर के मध्य भाग की स्थिति की तलाश करते हैं और एक ही स्थिति में दूसरे तार में एक परीक्षण डैश है।

b[a.search`o`] == '-'

इस स्थिति में जिमी असुरक्षित होगा एकमात्र मामला एकल-डैश प्लेटफ़ॉर्म के साथ है:

/o\
 -

इसलिए हम अतिरिक्त रूप से सुनिश्चित करते हैं कि प्लेटफॉर्म की चौड़ाई कम से कम 2 :

/--/.test(b)

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

वैकल्पिक संस्करण अगर हम मान लें कि जिमी के नीचे हमेशा या तो डैश या स्थान हैं (यानी इनपुट आयताकार है)।

a=>b=>b[a.search`o`]!=0&/--/.test(b)

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

इस तथ्य का लाभ उठाता है कि एक संख्यात्मक मूल्य के लिए जोर अंतरिक्ष के लिए 0 है और डैश के लिए NaN है ।

— Arnauld
स्रोत
वाह। क्या आप बता सकते हैं कि यह कैसे काम करता है?
— संयोजिका
@connectyourcharger मैंने एक स्पष्टीकरण जोड़ा है।
— अरनुलद
3
प्रतिभाशाली! JS उत्तर आमतौर पर उतना छोटा नहीं होता है।
— कनेक्टीओचार्जर
— ओलिवर
@ ओलिवर के लिए विफल हो जाएगा"/o\\\n__"
— tsh
10

एक्सेल, 67 45 44 बाइट्स

=(MID(A2,FIND("o",A1),1)="-")*(TRIM(A2)>"-")

में A1एक मंच पर जिमी रखो A2।

2 शर्तों की जाँच की:

  • क्या जिमी का धड़ ( o) मंच पर है?
  • क्या प्लेटफॉर्म सिर्फ से अधिक है -?
— Wernisch
स्रोत
1
@Keeta संपादन पहले पाँच मिनट के भीतर संपादित इतिहास में नहीं दिखाया गया है।
— निधि मोनिका मुकदमा
सीमित परीक्षण मैंने किया था से, मुझे लगता है कि आप बदल सकते हैं <>करने के लिए>
— टेलर स्कॉट
9

पायथन 3, 88 43 बाइट्स

इनपुट को दो तार वाली सूची के रूप में दिया गया है: पहली स्ट्रिंग पहली पंक्ति है; दूसरी कड़ी दूसरी पंक्ति है।

lambda a:sum(1-(" "in i)for i in zip(*a))>1

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

एक और संस्करण, 43 बाइट्स के लिए बांधना (मैं इसे 43 से कम नहीं कर पाया):

lambda a,b:b[a.find("/"):][:3].count("-")>1

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

जो किंग से एक टिप के लिए 42 बाइट्स के कारण नीचे।

पुराना संस्करण:

lambda s:sum((s.split("\n")[1]+" "*len(s))[i]=="-"and s[i]!=" "for i in range(len(s)))>1

-2 बाइट्स श्रीकोटिलिज्म ओ'जैक को धन्यवाद।

यह दो अलग-अलग इनपुट्स लेकर काम करता है, फिर संबंधित अक्षरों को जोड़ देता है। यह उन युग्मों की संख्या को गिनाता है जहां न तो वर्ण एक स्थान है, फिर सही है अगर यह संख्या 1 से अधिक है।

— mprogrammer
स्रोत
8

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

{?/''B|Bq/}o&[~^]

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

दो मापदंडों को लेता है और जिमी मंच पर रहेगा या नहीं इसकी एक बूलियन देता है। यह दो लाइनों को एक साथ XORing द्वारा काम करता है और जाँच करता है कि क्या जिमी का कोई हिस्सा अभी भी प्लेटफ़ॉर्म पर है।

स्पष्टीकरण:

             &[~^]   # String XOR operator
{          }o        # Combined with the anonymous function
 ?/       /          # That checks for the regex match
   ''B              # Unprintable, B, which is "/o" ~^ "--"
       |Bq           # Or B, q, which is "o\" ~^ "--"
— मजाक कर रहा है
स्रोत
6

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

a#b=[1|(p,'-')<-zip a b,p>' ']>[1]

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

मुझे यह एक अन्य हैस्केल उत्तर के साथ अपनी नीचे की तकनीक के संयोजन से मिला ।

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

x#'-'|x/=' '=1
x#y=0
(((>1).sum).).zipWith(#)

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

यह उन बॉडी पार्ट्स (नॉन-स्पेस कैरेक्टर) की संख्या गिनाता है जो प्लेटफॉर्म के ऊपर होते हैं और फिर चेक करते हैं कि यह 1 से अधिक है। जिस कारण से हम प्लेटफॉर्म पर बॉडी पार्ट्स को बंद करते हैं, वह zipWithटॉप लाइन को काट देगा। नीचे की लंबाई होना और इस तरह जिमी के शरीर के अंगों को काट देना। यह हमें cycle" "सूची को पैड करने जैसा कुछ करने से रोकता है ।

— गेहूं का जादूगर
स्रोत
1
क्या आप infix में परिवर्तित होकर 2 बाइट्स कम नहीं कर सकते हैं?
— कोल
1
जब आप टिप्पणी करते हैं तो @cole Yep मैं केवल संपादन कर रहा था :)
— गेहूं जादूगर
4

मैथॉल्फ , 6 14 बाइट्स

`^@╞^αmÆû-oñ╧╙

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

निक केनेडी द्वारा प्रस्तुत किनारे के मामले के लिए 8 बाइट्स को जोड़ना पड़ा।

चेक करता है कि "-o-"क्या दोनों लाइनों के ज़िप्ड स्ट्रिंग का विकल्प है, और ज़िप्ड स्ट्रिंग जहां पहली इनपुट लाइन में पहला वर्ण हटा दिया गया है। दो अलग-अलग स्ट्रिंग्स के रूप में इनपुट लेता है, एकमात्र परिवर्तन के साथ चरित्र इनपुट है /o\\, क्योंकि \\मैथॉल्फ में एक स्ट्रिंग में बैकस्लैश इनपुट करने का सही तरीका है।

व्याख्या

`                duplicate the top two items
 ^               zip top two elements on stack
  @              rrot3
   ╞             discard from left of string/array
    ^            zip top two elements on stack
     α           wrap last two elements in array
      mÆ         explicit map using 5 operators
        û-oñ     push "-o" and palindromize to make "-o-"
            ╧    pop a, b, a.contains(b)
                 map block ends here
             ╙   max of list
— maxb
स्रोत
ओह, यह मेरे मैथगॉल्फ उत्तर की तुलना में एक बेहतर दृष्टिकोण है .. इंटरलेवे के बाद मैंने इसे "-ओ-" के लिए सीधे जाँच के बजाय आकार 2 के भागों में विभाजित किया।
— केविन क्रूज़सेन
1
के लिए विफल रहता है tio.run/##y00syUjPz0n7/z/u8G7d/MMbH01d/v@/un5@TIy6grqurvp/3RQA
— निक कैनेडी
@NickKennedy अच्छी पकड़! मैं देखूंगा कि मैं कोड को कैसे ठीक कर सकता हूं और पास होने के बाद पोस्ट को अपडेट कर सकता हूं। यह शायद कुछ बाइट्स जोड़ देगा, जो दुर्भाग्यपूर्ण है।
— मैक्स
3

05AB1E (विरासत) , 9 8 7 बाइट्स

ζðм2ùgp

-1 बाइट @ मिस्टरकोड के लिए धन्यवादके दृष्टिकोण के साथðм2ù ।

दो तार की सूची के रूप में इनपुट।

केवल 05AB1E के विरासत संस्करण में काम करता है, क्योंकि ζतार की एक सूची के साथ-साथ पात्रों की 2 डी सूची भी स्थानांतरित कर सकता है, जबकि ζनए 05AB1E संस्करण में केवल वर्णों की 2 डी सूची के साथ काम करता है।

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

स्पष्टीकरण:

ζ        # Zip/transpose; swapping rows/columns, with space as default filler
 ðм      # Remove all spaces from each string
   2ù    # Only leave strings of size 2
     g   # Count how many there are left
      p  # Check if this is a prime (2 or 3)
         # (after which the result is output implicitly)
— केविन क्रूज़सेन
स्रोत
1
आपका शीर्षक लीडरबोर्ड को तोड़ता है, smh :)
— संयोजकचर
@connectyourcharger आह, शायद इसलिए कि मैं हमेशा bytesकोड-पेज से लिंक करता हूं ताकि आपको पता हो कि यह UTF-8 में एन्कोडेड नहीं है, लेकिन इसके बजाय कस्टम एन्कोडिंग का उपयोग करता है। ;) यदि आप चाहते हैं कि मैं शीर्षक के नीचे एन्कोडिंग लगाने के लिए अपने उत्तर को संपादित कर सकता हूं, लेकिन ईमानदारी से लीडरबोर्ड कोड को इम्हो को संभालने में सक्षम होना चाहिए।
— केविन क्रूज़सेन
मुझे ऐसा लगता है कि मुझे 05AB1E के लिए एक विशेष मामले को जोड़ने की आवश्यकता है - यह केवल उन भाषाओं में से एक है जिनके पास कोड पृष्ठ के साथ समस्याएं हैं। जल्द ही आने वाली ईश को ठीक करें।
— संयोजकचर
1
एक संशोधित regex के साथ आने के लिए संघर्ष। अभी के लिए यह एक स्थायी बग होगा। यदि आप यहां स्क्रिप्ट का योगदान करना चाहते हैं: github.com/xMikee1/ppcg-leaderboard/edit/master/docs/script.js । मुझे बाइट्स पार्सिंग को पूरी तरह से रिफलेक्टर करना पड़ सकता है।
— संयोजक
Can't you modify the URL to https://github.com/Adriandmen/05AB1E/wiki/Codepage?7 to make 7 the last number without invalidating the URL?
— L. F.
3

Dyalog APL Extended, 11 10 8 bytes

2≤1⊥∧⌿⍤<

Try it online!

Explanation:

2≤1⊥∧⌿⍤<  a monadic train
       <  Compare the input with the implicit prototype element - a space.
          Returns a boolean matrix of characters that are greater than 0x20
    ∧⌿⍤   and-reduce that, i.e. places where both Jimmy and a platform is
  1⊥      base 1 decode, aka sum - the amount of body parts over the platform
2≤        is that greater-or-equal to 2?

-2 thanks to Adám.

— dzaima
स्रोत
1
— Adám
3

Excel, 36 bytes

=LEN(TRIM(MID(A2,FIND("/",A1),3)))>1

Jimmy in A1, on a platform in A2.

Finds the position of Jimmy, and takes the 3 bytes of the platform and trims off spaces. If the resulting platform length is long enough, Jimmy stands.

— Keeta
स्रोत
3

EXCEL, 94 71 bytes . VBA (Excel), 87 bytes

A1 = Jimmy , A2 = platform

-23 bytes. Thank you @Wernisch.

=(FIND("-",A2)-FIND("/",A1)<2)*(FIND("\",A1)-LEN(A2)<2)*(TRIM(A2)<>"-")

?[(FIND("-",A2)-FIND("/",A1)<2)*(FIND("\",A1)-LEN(A2)<2)]*(len(replace([A2]," ",""))>1)

— remoel
स्रोत
1
Can't you use trim instead of len(replace?
— Wernisch
oh! that never sink in my head. haha Thanks @Wernisch :)
— remoel
3

///, 85 93 87 bytes

/~/\/\///\/o\\/(o)~ 
/
~
~/ (o) /(o)~ (o)-/(o)~- -/--~(o) - ~/) ~/)-~/o~/(-/1~-~/(~/)~

Try it online!

Output's a 1 if Jimmy is safe. Otherwise outputs nothing. (Unary 1 and 0.) Because there is no other way to take input in ///, it needs to be hard-coded:

/~/\/\///\/o\\/(o)~ 
/
~
~/ (o) /(o)~ (o)-/(o)~- -/--~(o) - ~/) ~/)-~/o~/(-/1~-~/(~/)~ //<INPUT HERE>

For example:

/\/o\\/(o)// 
/
//
/// (o) /(o)// (o)-/(o)//- -/--//(o) - ///) ///)-///o///(-/1//-///(///)//         /o\
  -------------

(Try it online!)

Note the space after the <INPUT HERE>.

Explanation:

NOTE! The explanation code cannot be run due to the comments. The comments are enclosed in curly braces. Also, the original code uses a golf where // is replaced with ~. This code is omitted from the explanation.

/\/o\\/(o)/            {replace Jimmy with a Jimmy with curvy arms, because slashes are hard to manipulate in this language}
/ 
/
/                      {remove unneeded spaces after Jimmy, but before the floor}

/
//                     {get rid of the line break

/ (o) /(o)/            {remove all the spaces before both Jimmy and the floor}
/ (o)-/(o)/            {for each floor tile, remove it and one space before Jimmy. This detects whether Jimmy lines up with the floor.}
                       {If Jimmy is before the floor, then there will be extra floor.}
                       {If Jimmy is behind the floor, then there will be extra spaces before Jimmy.}
/- -/--/               {Handle the case where there is a hole beneath Jimmy but he is still well-supported}

/(o) - //              {Handle the case where only Jimmy's head is on the floor. The space at the end of the code is necessary for this.}
/) //                  {The rest of the substitutions clean up the result and handle each of the possible results that could exist at this point}
/)-//
/o//
/(-/1/
/-//
/(//
/)//


              /o\   
               --
 {there is a space right before this comment. The comment is only here to make the space visible and explain itself.}
  • +8 bytes to fix a bug
  • -6 bytes by applying a standard /// golf trick.
— Comrade SparklePony
स्रोत
1
The source code looks like some strange emoji. \\(o)-(o)//
— tsh
2

Haskell, 59 bytes

f a b=sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']<2

Try it online!

The function is called like so: f "/o\\ " " -- "

How it works (for f "/o\\" " -"):

b++cycle" " - Adds an infinite number of spaces after b to ensure that Jimmy is always above a - or (" -" → " - ..."

zip a$b++cycle" " - Zips the two strings together ([('/',' '), ('o','-'), ('\\',' ')])

(p,q)<-zip a$b++cycle - For each pair in the zipped list

[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' '] - Generates a list of 1s, whose length is the number of pairs satisfying the conditions:

elem p"/o\\" - The character in the top string is one of Jimmy's body parts. (Satisfied by all three pairs in this example)

q==' ' - The character in the bottom string is a space. (Satisfied by ('/', ' ') and ('\\', ' '))

So, the pair has to be one where one of Jimmy's body parts is above a space.

Because in this example, two pairs satisfy both conditions, the list is [1,1]

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' '] - Take the sum of those 1s (i.e. the length of the list), which in this example is 2.

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']<2 - Check if the number of body parts above a space is less than 2. In this example, it's not, so Jimmy will fall off. :(

— Leo Tenenbaum
स्रोत
I just thought I would let you know that your answer helped me to shorten my own answer. So thanks!
— Wheat Wizard
2

Kotlin, 60 bytes

fun String.c(b:String)=zip(b){i,j->i>' '&&j>' '}.count{it}>1

Explanation:

fun String.c  # Define an extension function on string, so we don't have to provide a first argument (and we also have string method calls for free)
(b:String)    # Pass the second string as argument
=             # Shorthand syntax for fun body
zip(b)        # Essentially a.zip(b). Creates a List<Pair> by joining both arrays. 
              # Takes care of trailing whitespace, because it will be the size of the smaller array
{i,j->        # Declare a transformer lambda as second function argument
i>' '&&j>' '} # This essentially translates to: If i!=' ' and j=='-'
.count{it}    # Count the true values
>1
— Alex Papageorgiou
स्रोत
Welcome to Code Golf! That's certainly a very nice first answer.
— connectyourcharger
2

///, 57 bytes

/|/\/\///\/o\\/J| J/J*|
/|* /|  -/  | /|*-/|--/!|-/|*/|J|

Try it online!

Append the input to the end of the program in order to run. Returns the empty string if Jimmy falls off the platform, a string of exclamation points otherwise.

  • /|/\/\// replaces | with //, which makes the code both shorter and more readable (| is used to demarcate each replacement)
  • /\/o\\/J| J/J*/ replaces Jimmy with J for brevity and changes the space to the left of him to * to the right of him
  • The next replacement gets rid of newlines.
  • /* /| -/ | // cancels out *s and with the space to the left of the platform. If there are two or more spaces left, Jimmy is falling off to the left, and the platform is deleted. This part also removes any whitespace to the right of the platform.
  • /*-/|--/!/ cancels out *s and with length of the platform. If there are at least two - left, Jimmy isn't falling off to the right, so they are replaced with a !.
  • /-/|*/|J// deletes every remaining character that isn't !
— stellatedHexahedron
स्रोत
1

Retina 0.8.2, 16 bytes

 (.*¶).
$1
¶ ?--

Try it online! Link includes test suite. Explanation:

+`^ (.*¶).
$1

While there is still a space on the first line, and both lines still have more than one character, delete the space and the first character of the next line. Note: This assumes that there is no trailing space after Jimmy. +1 byte needed if trailing space needs to be allowed.

¶ ?--

Check that there are at least two pieces of platform under Jimmy.

— Neil
स्रोत
1

Ruby 2.5.3, 44 bytes

->a,b{a.zip(b).map(&:join).grep(/\S-/).size>1}

Input taken as two arrays. Definitely not the most golf-friendly approach (see G B's answer), but I like any excuse to use the zip function.

— DaveMongoose
स्रोत
1

PowerShell, 63..55 53 bytes

-1 byte thanks to mazzy

param($j,$f)''+($f|% t*y|?{$j[$i++]-gt32})-match'- -'

Try it online!

Takes input as two lines.

Unrolled:

param($j,$f)            #Take $jimmy and $floor
''+                     #Implicitly converts next part to string
($f |% ToCharArray      #Convert $f to a char[] and...
    |?{                 #Only take the chars where...
        $j[$i++]-gt32   #The same indexed char in $j's ASCII # is > ' ' i.e. only get /o\
     }
)-match'- -'            #Arrays.ToString are joined with a space and we need 2 -'s
— Veskah
स्रोत
Huh. I never considered PowerShell a great golfing language, but I guess it's actually not that bad.
— connectyourcharger
@connectyourcharger It can do some pretty neat stuff with the pipeline but there's definitely a few areas where it's a huge pain in the ass.
— Veskah
I never bothered to learn it because of those pain-in-the-ass reasons.
— connectyourcharger
1
— mazzy
1

Python 3.7, 71 56 Bytes

lambda s:sum(j in'/o\\'and p=='-'for j,p in zip(*s))>1

Very simple version and the shortest I could think of using this approach. Input s is a list of two strings, the first one for the Jimmy-row, the second one for the platform. Zip the characters which are above one another and then check whether - is below a part of Jimmy in at least two instances.

EDIT: Reduced by quite a few Bytes thanks to Blue!

— Michael
स्रोत
1
Hi, welcome to Code Golf! Couple things: you might want to specify the input format in your answer (looks like s should be two lists, one for jimmy and one for the platform?). Also, there are a few places you can save bytes: instead of summing a list, you can sum the raw iterator (remove the brackets); instead of checking >=2, check >1; you can sum True and False like 1 and 0, no need for the if-else. Finally, before posting a new answer in the same language, you should look at the previous ones to see if you can improve.
— Blue
@Blue Hi, thanks a lot! And yeah I will keep that in mind in the future. :)
— Michael
1

Chevron, 84 87 bytes

>^__>^j
^i<<0
^i<<^i+1
^h<^i>^j
->+2??^h=/
->-3
>^__>^p
^q<^i|2>^p
->+2??^q<--
><0
><1

This is a fairly new language of my own creation - prototype interpreter, documentation, and example programs can be found at https://github.com/superloach/chevron.

Explanation:

  • >^__>^j - take jimmy as TXT input
  • ^i<<0 - initialise index to 0
  • ^i<<^i+1 - increment index
  • ^h<^i>^j - get character of jimmy at index
  • ->+2??^h=/ - jump out of loop at jimmy's left leg
  • ->-3 - hop back to beginning of loop
  • >^__>^p - take platform as TXT input
  • ^q<^i|2>^p - cut out 3 characters under jimmy
  • ->+2??^q<-- - if 2 dashes under jimmy, jump to truthy exit
  • ><0 - falsy exit
  • ><1 - truthy exit
— Superloach
स्रोत
I am aware that my code fails to handle single-character platform cases - updated version will be edited soon.
— Superloach
0

V, 18 bytes

0vt/"_dj.d3lVkp0#x

Try it online!

Output whitespace only if jimmy fall of the platform. Output something non-whitespace if jimmy stay on the platform.

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