92

एक प्रोग्राम लिखें जो एकल पंक्ति स्ट्रिंग लेता है जिसे आप मान सकते हैं कि इसमें केवल वर्ण होंगे /\_‾। (यह आगे और पीछे की ओर स्लैश है, रेखांकित करें और ओवरलाइन करें । ओवरलाइन की~ जगह आप उपयोग कर सकते हैं , यदि आपको ज़रूरत है क्योंकि ओवरलाइन सुविधाजनक ASCII नहीं है।)

उदाहरण के लिए, एक संभावित इनपुट है:

__/‾‾\/\_/‾

आपके प्रोग्राम को एक सत्य या मिथ्या मूल्य के उत्पादन की आवश्यकता है, जो इस बात पर निर्भर करता है कि स्ट्रिंग के बाएं किनारे "जुड़ा हुआ है", इसलिए बोलने के लिए, पात्रों की पंक्तियों के माध्यम से स्ट्रिंग के दाहिने किनारे पर। इसलिए, यदि कर्निंग थोड़ा कम था, तो एक ठोस काली (यद्यपि गांठ) होगी, जो बाएं किनारे से दाहिनी ओर, स्ट्रिंग या सुतली के अटूट टुकड़े की तरह होती है।

उपरोक्त उदाहरण के लिए आउटपुट सही होगा क्योंकि किनारे जुड़े हुए हैं:

कनेक्शन पर स्पष्ट होने के लिए:

/ इसके निचले बाएँ और ऊपर दाईं ओर जोड़ता है
\ इसके शीर्ष बाएँ और नीचे दाईं ओर जोड़ता है
_ इसके नीचे बाईं ओर और नीचे दाईं ओर जोड़ता है
‾(या ~) इसके शीर्ष बाएँ और दाएँ दाएँ पर जोड़ता है

इसके अलावा:

इससे कोई फर्क नहीं पड़ता कि स्ट्रिंग के किनारों को ऊपर या नीचे से शुरू किया गया है, यह केवल मायने रखता है कि वे स्ट्रिंग की पूरी लंबाई के माध्यम से क्षैतिज रूप से कनेक्ट होते हैं।
आप मान सकते हैं कि इनपुट स्ट्रिंग गैर-रिक्त है, और निश्चित रूप से सिर्फ एक पंक्ति है।

यहाँ कुछ और उदाहरण दिए गए हैं 1 (सत्य) यदि वे जुड़े हुए हैं या 0 (मिथ्या) नहीं तो:

__/‾‾\/\_/‾
1

_
1

\
1

/
1

‾
1

___
1

\/
1

/\/
1

/\/\
1

‾‾‾
1

\\
0

‾‾
1

_‾
0

‾_
0

\_____/
1

\/\\/\\___
0

\/\__/‾‾\
1

______/\_____
1

‾‾‾‾‾‾\\_____
0

‾‾‾‾‾‾\______
1

_____/‾‾‾‾‾
1

\___/‾‾‾\___/‾‾‾
1

\_/_\_
0

\_/\_
1

/\/\/\/\/\/\/\/\/\/\/\/
1

____________________
1

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
1

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾/
0

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\
1

/\‾/\‾___/\_\/__\/\‾‾
0

सबसे छोटा कोड विजेता है।

code-golf string decision-problem

— असतत खेल
स्रोत

37

PPCG में आपका स्वागत है! अच्छी पहली चुनौती।

— AdmBorkBork

1

क्या आपकी चुनौती में निर्दिष्ट वर्ण केवल वही हैं जो स्ट्रिंग में दिखाई देंगे?

— अज्ञानता

@EmbodimentofIgnorance हाँ, केवल 4.

— असतत खेल

30

प्रतीक्षा करें कि आप इसमें से एक भाषा बना सकते हैं

— डेलीथ

2

@ अर्नुलड नहीं, मैं वास्तव में जुड़ा हुआ और असम्बद्ध के लिए मिथ्या के लिए केवल सत्य मानता हूं। (जब तक इस तरह के प्रश्न के लिए एक अदला-बदली की अनुमति सामान्य नहीं है?)

— असतत खेल

34

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

-1 बाइट के लिए @EriktheOutgolfer का धन्यवाद

की ~बजाय उम्मीद करें ‾। रिटर्न या । $0$ $1$

O*Ɲ:⁽8ƇḂẠ

इसे ऑनलाइन आज़माएं! , ट्रू टेस्ट सूट , फाल्सी टेस्ट सूट

इस सूत्र का उपयोग करना (लेकिन अन्यथा 11-बाइट संस्करण के समान है):

n = ⌊ \frac{x^{y}}{15145} ⌋

$n=\left\lfloor\frac{x^y}{15145}\right\rfloor$

यदि विषम है, या अमान्य है यदि सम है तो संक्रमण मान्य है। $n$ $n$

टिप्पणी की गई

O*Ɲ:⁽8ƇḂẠ     - main link, taking a string          e.g. "\_/"
O             - get ASCII codes                     -->  [92, 95, 47]
 *Ɲ           - exponentiation on all pairs         -->  [92**95, 95**47]
   :⁽8Ƈ       - integer division by 15145           -->  [23964828…8421, 59257069…0485]
       Ḃ      - least significant bit (i.e. parity) -->  [1, 1]
        Ạ     - all values equal to 1?              -->  1

जेली , 14 12 11 बाइट्स

‾इनपुट स्ट्रिंग में वर्ण का समर्थन (और अपेक्षा) करता है । रिटर्न या । $0$ $1$

O*Ɲ%276%7ỊẠ

इसे ऑनलाइन आज़माएं! , ट्रू टेस्ट सूट , फाल्सी टेस्ट सूट

कैसे?

ASCII कोड और लगातार दो वर्णों को देखते हुए , हम एक फ़ंक्शन चाहते हैं जो यह जाँचता है कि क्या वे एक वैध संक्रमण बनाते हैं। $x$ $y$

हमें एक गैर-कम्यूटेटिव ऑपरेशन की आवश्यकता है, क्योंकि वर्ण उलट जाने पर परिणाम बदल सकता है। उदाहरण के लिए, _/मान्य है लेकिन /_नहीं है।

घातांक का उपयोग करना, एक संभावित सूत्र ¹ है:

n = (x^{y} mod 276) mod 7

$n=(x^y \bmod 276)\bmod 7$

यदि , या अमान्य है, तो संक्रमण मान्य है । $n\le1$ $n>1$

 chars |    x |    y | (x**y)%276 | %7 | valid
-------+------+------+------------+----+-------
   __  |   95 |   95 |      71    |  1 |  yes
   _/  |   95 |   47 |     119    |  0 |  yes
   _‾  |   95 | 8254 |     265    |  6 |   no
   _\  |   95 |   92 |     265    |  6 |   no
   /_  |   47 |   95 |      47    |  5 |   no
   //  |   47 |   47 |      47    |  5 |   no
   /‾  |   47 | 8254 |       1    |  1 |  yes
   /\  |   47 |   92 |       1    |  1 |  yes
   ‾_  | 8254 |   95 |     136    |  3 |   no
   ‾/  | 8254 |   47 |      88    |  4 |   no
   ‾‾  | 8254 | 8254 |     196    |  0 |  yes
   ‾\  | 8254 |   92 |     196    |  0 |  yes
   \_  |   92 |   95 |      92    |  1 |  yes
   \/  |   92 |   47 |      92    |  1 |  yes
   \‾  |   92 | 8254 |     184    |  2 |   no
   \\  |   92 |   92 |     184    |  2 |   no

_{1. Node.js में ब्रूट-बल खोज के साथ मिला (BigInts का उपयोग करके)}

टिप्पणी की गई

O*Ɲ%276%7ỊẠ   - main link, taking a string          e.g. "\_/"
O             - get ASCII codes                     -->  [92, 95, 47]
 *Ɲ           - exponentiation on all pairs         -->  [92**95, 95**47]
   %276       - modulo 276                          -->  [92, 119]
       %7     - modulo 7                            -->  [1, 0]
         Ị    - ≤1?                                 -->  [1, 1]
          Ạ   - all values equal to 1?              -->  1

— Arnauld
स्रोत

2

लुकअप टेबल विधि ने कई समस्याओं को जीत लिया है

— क्यूर

9 बाइट्स : के ⁽"Oरूप में ही है 9580।

— २१:३२ पर आउटगोल्फ

@EriktheOutgolfer धन्यवाद :) हो सकता है कि इस टिप में दी गई स्क्रिप्ट को इस प्रारूप का समर्थन करने के लिए अपडेट किया जाना चाहिए (जब यह प्रासंगिक हो)।

— अरनौलड

1

वास्तव में, जोनाथन एलन बना दिया है @Arnauld इस ।

— को आउटगोल्फ

16

रूबी-एन , 30 बाइट्स

p !/[_\\][\\‾]|[\/‾][_\/]/

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

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

— histocrat
स्रोत

5

के ~बजाय का उपयोग करके आप 4 बाइट्स बचा सकते हैं ‾। मुझे यकीन नहीं है कि यह इस चुनौती के लिए मायने रखता है, क्योंकि चरित्र की गिनती समान है।

— १32

क्या आपको /वर्ग कोष्ठक के भीतर होने पर भी भागने की आवश्यकता है ?

— सोलोमन उको

14

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

भोला रास्ता।

s=>!/\/\/|\\\\|_~|~_|~\/|_\\|\/_|\\~/.test(s)

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

— Arnauld
स्रोत

1

तो यह सभी अमान्य युग्मों की जाँच कर रहा है, सुनिश्चित करें कि वे स्ट्रिंग में मौजूद नहीं हैं? होशियार।

— असतत खेल

@DiscreteGames हाँ, बिल्कुल। (सिवाय इसके कि मैं उनमें से 2 को भूल गया। अब तय हो गया।)

— अर्नुलद

35 बाइट्स: s=>!/[~\/][\/_]|[_\\][\\~]/.test(s)। यह जाँच करता है कि क्या \/या ~अंत में है \/या नहीं _। और फिर, यह करता है, तो जाँच \\या _में खत्म हो \\या ~।

— इस्माईल मिगुएल

@IsmaelMiguel यह एक अलग उत्तर के रूप में पोस्ट किया जा सकता है, लेकिन मैं इसे संदर्भ के लिए अपरिवर्तित छोड़ दूंगा, क्योंकि यह सबसे सरल (जैसा कि 'कम से कम जटिल') नियमित अभिव्यक्ति समस्या को हल करता है।

— अरनुलद

आप इसे एक विकल्प के रूप में पोस्ट कर सकते हैं, लेकिन निश्चित उत्तर नहीं।

— इस्माइल मिगुएल

10

आर , 89 87 81 78 बाइट्स

-2 बाइट्स @Giuseppe की बदौलत

-6 बाइट्स @ धन्यवाद कैनेडी को

-3 बाइट्स की जगह 1:length(y)के साथ seq(a=y), जहां aके लिए कम हैalong.with

y=utf8ToInt(scan(,''));all(!diff(cumprod(c(1,y>93)*2-1)[seq(a=y)]*(y%%2*2-1)))

का उपयोग करता है \ / _ ~। यह शायद एक रेगीक्स आधारित समाधान जितना छोटा नहीं है, लेकिन मैं सभी के लिए कुछ अलग करने की कोशिश कर रहा हूं।

utf8ToInt('\\/_~')
# [1]  92  47  95 126

93 से कम वर्ण राज्य को ऊपर से नीचे (या इसके विपरीत) पर स्विच करते हैं, और जैसे -1कि अन्य लोग कुछ भी नहीं करते हैं और व्यवहार करते हैं जैसे कि 1, cumprod शुरुआत के संबंध में राज्य को ट्रैक करता है। सम संख्याएँ ऊपर की ओर हैं (साथ में -1), विषम संख्या नीचे की स्थिति ( 1) में हैं। यदि स्ट्रिंग को ट्रैक की स्थिति से ऊपर / नीचे की स्थिति से गुणा किया गया है, तो उसे बदलना नहीं चाहिए, यह हमेशा शुरुआती स्थिति ( -1, या 1) होगी

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

— हारून हेमन
स्रोत

2

यह काफी चतुर है, और चीजों को करने का एक अनूठा आर तरीका है! मेरा मानना है कि आप 2 बाइट्स को बचाने के लिए ()आस-पास y%%2को हटा सकते हैं , क्योंकि विशेष ऑपरेटरों %(any)%में एक उच्च वरीयता है।

— ग्यूसेप

3

83 बाइट्स के लिए टियो के बारे में कैसे ? तार्किक के लिए अंतर्निहित जबरदस्ती का लाभ उठाता है!

— निक केनेडी

9

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

f=lambda s:s==''or s[:2]in"__/~~\/\_"*f(s[1:])

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

पुष्टि करता है कि प्रत्येक आसन्न जोड़ी पात्रों की जाँच करके जोड़ती है कि वे लगातार दिखाई देते हैं __/~~\/\_। इस स्ट्रिंग को उच्च / निम्न स्थिति के त्रिगुणों पर De_Bruijn_fterence के रूप में देखा जा सकता है । $2^3=8$

मैंने चरित्र युग्मों की जांच करने के लिए अन्य कम विनम्र तरीकों की कोशिश की, लेकिन वे सभी लंबे समय तक इस तरह के सभी कानूनी जोड़े को हार्डकोड करते रहे।

— XNOR
स्रोत

8

सी (जीसीसी) , 93 बाइट्स

w,o,r;k(char*_){for(r=0;w=*_,o=*++_;)r|=w-126&&w>47?w-95&&w-92?0:o>47&&o-95:o-92&&o<126;_=r;}

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

— जोनाथन फ्रेच
स्रोत

3

मैं सराहना करता हूं w,o,r;k।

— बजे फल

6

चिप `-z` , 17 बाइट्स

FZ!C~aS
A}^]--^~t

इसे ऑनलाइन आज़माएं! (TIO में -vआउटपुट को समझना आसान बनाना शामिल है।)

_/~\सेट की उम्मीद है । या तो \x00(मिथ्या) या \x01(सत्य) लौटाता है ।

मेरे उत्तर की रणनीति निम्नलिखित जानकारी का उपयोग करती है:

Symbol  Binary
   _    0101 1111
   /    0010 1111
   ~    0111 1110
   \    0101 1100
          ^   ^ ^
        HGFE DCBA

A: यह बिट स्थिति तब होती है 1जब प्रतीक के बाईं ओर कम होता है, और 0जब यह उच्च
Fहोता है: यह बिट स्थिति तब होता है 0जब प्रतीक के दाईं ओर कम होता है, और 1जब यह उच्च
Cहोता है: यह बिट स्थिति के लिए होता है हमेशा रहें1

इस जानकारी का उपयोग करते हुए, मुझे बस यह जांचने की आवश्यकता है कि Fप्रत्येक चरित्र not Aअगले से मेल खाता है । xorइसे पूरा करने के लिए एक गेट एक सुविधाजनक तरीका है।

निम्न कोड ऐसा करता है, लेकिन प्रत्येक युग्मन के लिए आउटपुट देता है (प्लस 1शुरू में एक अतिरिक्त ) (7 बाइट्स):

FZ!
A}a

हम पहली विफलता पर रोकना चाहते हैं, और यह भी प्रिंट करते हैं कि क्या हमने स्ट्रिंग के भीतर रुका हुआ है, या शून्य टर्मिनेटर पर (हम भी -zहमें एक शून्य टर्मिनेटर देने के लिए जोड़ते हैं )। हम यह not Cसंकेत देने के लिए उपयोग कर सकते हैं कि हम कहाँ रुके हैं, और इससे हमें यह कार्यक्रम (13 बाइट्स) मिलता है:

FZ!C~a
A}^]~t

लेकिन हमारे पास अभी भी "अग्रणी शून्य" (जैसे \_/\देता है 00 00 00 00 01) है, इसलिए यह शीर्ष पर दिए गए उत्तर में बदल जाता है।

— Phlarx
स्रोत

अच्छा, मैंने इस पैटर्न पर गौर किया लेकिन इसका फायदा उठाने के लिए अच्छी भाषा नहीं जानता था।

— हिस्टोक्रैट

6

05AB1E , 29 14 9 बाइट्स

ÇümŽb‘÷ÈP

पोर्ट @Arnauld जेली जवाब है , तो उसे भी उखाड़ना सुनिश्चित करें!

के साथ इनपुट करें ‾।

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

मूल 29 बाइट्स उत्तर:

„_~SD2×s:Çü-т+•6_üê{â†•ƵΔвåO_

के ~बजाय के साथ इनपुट ‾।

यह मेरे सिर में छोटा लग रहा था .. ~~इसे यहाँ से नीचे गिराने की कोशिश करेंगे।~~

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

स्पष्टीकरण: "

„_~S                          # Push the characters ["_","~"]
    D2×                       # Duplicate it, and increase each to size 2: ["__","~~"]
       s:                     # Swap and replace all "__" with "_" and all "~~" with "~"
                              #  in the (implicit) input-string
         Ç                    # Convert the remaining characters to unicode values
          ü-                  # Calculate the difference between each pair
            т+                # Add 100 to each
              •6_üê{â†•       # Push compressed integer 1781179816800959
                       ƵΔ     # Push compressed integer 180
                         в    # Convert the larger integer to Base-180 as list: 
                              #  [52,66,69,100,103,131,179]
                          å   # Check for each if it's in the difference-list
                              # (1 if present; 0 if not)
                           O  # Sum the truthy values
                            _ # Check if this sum is exactly 0 (1 if 0; 0 otherwise)
                              # (and output this result implicitly)

मेरा यह 05AB1E टिप देखें (वर्गों कितना बड़ा पूर्णांक comrpess के लिए? और कैसे पूर्णांक सूचियों संपीड़ित करने के लिए? ) को समझने के लिए क्यों •6_üê{â†•है 1781179816800959, ƵΔहै 180और •6_üê{â†•ƵΔвहै [52,66,69,100,103,131,179]।

अतिरिक्त स्पष्टीकरण:

16 ( ) संभावित जोड़े हैं जिन्हें हमें सत्यापित करना है। यदि हम प्रत्येक चरित्र को उसके यूनिकोड मान में परिवर्तित करते हैं, और अंतरों की गणना करते हैं, तो हमें ये अंतर मिलेंगे । क्योंकि 05AB1E में संकुचित पूर्णांक सूची में केवल सकारात्मक पूर्णांक होना चाहिए, मैं प्रत्येक में 100 जोड़ता हूं । अमान्य जोड़े और उनके संबंधित मूल्य तब हैं :; , , , , , , , जिसके कारण मैं इन मूल्यों से युक्त मेरे कोड में संकुचित पूर्णांक सूची है। चूंकि और मैं (या 100 जोड़ने के बाद) में परिणाम और पसंद करूंगा , मैं सबसे पहले किसी भी बगल के डुप्लिकेट को हटाता हूं और $2^4$ ["/_", 52]["\~", 66]["_~", 69]["//", 100]["\\", 100]["_\", 103]["~_", 131]["~/", 179]
__~~//\\0100~_ इनपुट-स्ट्रिंग में, युग्म-अंतरों की गणना और पुष्टि करने से पहले।

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

1

अब 9 बाइट्स ।

— अरनौलड

@Arnauld ओह अच्छा!

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

यह स्पष्टीकरण एक स्ट्रिंग के रूप में काम करेगा।

— संयोजक

@connectyourcharger तुम्हारा क्या मतलब है?

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

6

पायथन 3 , 79 70 63 बाइट्स

16 बाइट्स अर्नुल्ड और जो किंग को धन्यवाद, धन्यवाद!

p=lambda s:len(s)<2or((ord(s[-2])%13>5)^ord(s[-1])%2)&p(s[:-1])

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

पायथन 3 , 67 60 बाइट्स ~ के बजाय 67

p=lambda s:len(s)<2or(~(ord(s[-2])//7^ord(s[-1]))&p(s[:-1]))

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

— जोआचिम वर्थिंगटन
स्रोत

2

अच्छा पहला जवाब! आप कुछ सफेद जगह को हटाकर 6 बाइट्स बचा सकते हैं। (आप एक TIO लिंक, BTW जोड़ना चाह सकते हैं।)

— Arnauld

1

धन्यवाद! मुझे इन सभी ट्रिक्स को सीखने में मज़ा आ रहा है

— जोकिम वर्थिंगटन

4

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

lambda s,d={'‾':'\‾','_':'/_','/':'\‾','\\':'/_'}:len(s)<2or all([s[i+1] in d[s[i]]for i in range(len(s)-1)if s[i]in d])

— हेनरी टी
स्रोत

4

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

यह वेरिएंट ~ओवरलाइन के बजाय उपयोग करता है । यह सभी आठ वैध जोड़े लेता है और जाँचता है कि क्या स्ट्रिंग में केवल वे ही हैं:

f(a:b:x)=[a,b]`elem`words"__ _/ /~ ~~ ~\\ \\_ \\/ /\\"&&f(b:x)
f _=1>0

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

Ungolfed:

validate :: String -> Bool
validate xs = all valid $ zip xs (tail xs)
  where
    valid (a,b) = [a,b] `elem` starts
    starts      = words "__ _/ /~ ~~ ~\\ \\_ \\/ /\\"

— जीटा
स्रोत

4

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

{!/< \\\ \~ ~/ // _~ ~_ _\ /_>/}

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

एक रेगेक्स समाधान जो बस जांचता है कि स्ट्रिंग में कोई अमान्य अनुक्रम नहीं है।

स्पष्टीकरण:

{                              }   # Anonymous code block
  /<                         >/    # Find the longest sequence from
     \\\                           # \\
         \~                        # \‾
            ~/                     # ‾/
               //                  # //
                  _~               # _‾
                     ~_            # ‾_
                        _\         # _\
                           /_      # /_
 !                                 # And logically negate the match

— मजाक कर रहा है
स्रोत

4

आर , 43 चार्ट, 47 बाइट्स

यह वही रेगेक्स है जो अन्य उत्तरों का उपयोग करता है, लेकिन आर के लिए अनुकूलित है।

!grepl('[/‾][/_]|[\\\\_][\\\\‾]',scan(,''))

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

और अनिवार्य xkcd ।

— सीटी हॉल
स्रोत

1

आप 43 बाइट्स, 43 चार्ट प्राप्त करने के ~स्थान पर उपयोग कर सकते हैं ‾।

— ग्यूसेप

2

सच है, लेकिन यह ओवरबार के साथ अधिक मजेदार है। :)

— सीटी हॉल

4

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

: x = swap '~ = + ;
: f 1 tuck ?do over i + >r i 1- c@ r> c@ dup 92 x swap dup 47 x <> + loop 0> ;

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

व्याख्या

स्ट्रिंग के माध्यम से जाओ और निर्धारित करें कि क्या प्रत्येक वर्ण उसी स्थिति (ऊपर या नीचे) पर शुरू होता है जो समाप्त होने से पहले होता है। यदि वे मेल नहीं खाते हैं तो एक काउंटर से 1 घटाएं। अंत में, यदि काउंटर बदल गया है, तो स्ट्रिंग एक स्ट्रिंग नहीं है।

यदि चार्ट /(47) या ~(126) है तो अंतिम स्थिति उच्च है । अन्यथा कम है

यदि चार्ट \(92) या ~(126) है तो स्टार्ट पोजिशन उच्च है । अन्यथा कम है

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

\ x is basically just extracting some common logic out into a function to save a few bytes
\ it checks if the first number is equal to the second number
\ or the third number is equal to 126   
: x                \ start a new word definition
  = swap           \ check if the first two numbers are equal then swap with the third
  '~ =             \ checks if the third number is equal to 126
  +                \ adds results together (cheaper version of or)
;                  \ end the word definition

: f                \ start a new word definition
  1 tuck           \ set up parameters for a loop (and create a bool/counter)
  ?do              \ start counted loop from 1 to string-length -1, 
                   \ ?do will skip if loop start and end are the same
    over i +       \ copy the string address and add the loop index to get the char address
    >r i           \ place char address on return stack and place a copy back on the stack
    1- c@          \ subtract 1 to get previous char address and grab ascii from memory
    r> c@          \ move char address back from return stack, then grab from memory
    dup 92 x       \ get the "output" position of the prev character
    swap dup 47 x  \ get the input position of the current character
    <> +           \ check if they aren't equal and add the result to the counter
                   \ the counter won't change if they're equal
  loop             \ end the loop
  0>               \ check if counter is less than 1 (any of the "links" was not valid)
;                  \ end word definition

— reffu
स्रोत

3

पायथन 3 , 80 78 बाइट्स

मैं वास्तव में कई अजगर कोड गोल्फ नहीं करता हूं, लेकिन मुझे लगा कि मैं इसे आजमा सकता हूं

-2 बाइट्स: एहसास नहीं (कोई ()) सभी के समान है (नहीं ()) और आर-स्ट्रिंग में नहीं जा सकता है

def f(x):*l,=map(r'_/\~'.find,x);return 1-any((i^j//2)%2for i,j in zip(l,l[1:]))

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

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

मैं नई :=अभिव्यक्ति असाइनमेंट आज़माना चाहता था

lambda x:all((i^j//2)%2for i,j in zip(l:=[*map(r'\~_/'.find,x)],l[1:]))

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

— Kroppeb
स्रोत

3

जेली , 13 12 11 बाइट्स

O*Ɲ%⁽wḃ%5ỊẠ

वर्णों की एक सूची को स्वीकार करने वाला एक विवादास्पद लिंक, विकल्प के ~स्थान पर उपयोग करता है ‾।

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें (... जहां मैंने 8 फाल्स वालों को अंत में रखने के लिए फिर से लिखा है)

यह सूत्र हाथ से घूमकर पाया गया: p (जैसा कि नीचे दिए गए थे)

इस एक के लिए मैं भी चरित्र के अध्यादेशों के सभी 16 जोड़े को एक घातांक के रूप में माना जाता है और एक बड़े मोडुलो की तलाश करता हूं जो तीन बाइट्स में फिट होगा, उसके बाद एक बाइट मोडुलो (1,2,3,4,5,6,7,8) , 9,10,16,256) जिसने 16 को विभाजित किया है कि सभी स्वीकार्य परिणाम या तो 1 या 0 ("तुच्छ") थे, क्योंकि मुझे पता Ịहै कि <5मेरे पिछले समाधान की तुलना में कम है , जो सभी स्वीकार्य परिणामों की तुलना में कम था सभी अस्वीकार्य हैं।

O*Ɲ%⁽wḃ%5ỊẠ - Link: list of characters
O           - ordinals
  Ɲ         - for each pair of neighbours:
 *          -   exponentiate
    ⁽wḃ     - 30982
   %        - modulo (vectorises)
        5   - five
       %    - modulo (vectorises)
         Ị  - insignificant? (abs(x) <=1) (vectorises)
          Ạ - all truthy?

संभावित पड़ोसी पात्र और उनका आंतरिक मूल्यांकन:

(Ɲ)         (O)            (*%⁽wḃ)        (%5)      (Ị)
pair   a,b=ordinals   c=exp(a,b)%30982   d=c%5   abs(d)<=1
__       95,  95         28471             1         1
_/       95,  47         29591             1         1
/~       47, 126         19335             0         1
/\       47,  92          9755             0         1
~~      126, 126         28000             0         1
~\      126,  92         26740             0         1
\_       92,  95          9220             0         1
\/       92,  47         13280             0         1
~_      126,  95          3024             4         0
~/      126,  47         12698             3         0
\~       92, 126         27084             4         0
\\       92,  92         17088             3         0
_~       95, 126         28169             4         0
_\       95,  92          4993             3         0
/_       47,  95         22767             2         0
//       47,  47          7857             2         0

पिछला @ 12:

O*Ɲ%⁽?K%⁴<8Ạ

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

पिछला @ 13:

O%7ḅ6$Ɲ%⁵%8ỊẠ

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

— जोनाथन एलन
स्रोत

किसी कारण से, मैंने सोचा कि Ịपरीक्षण के abs(x)<1बजाय abs(x)≤1। यह काफी अधिक अवसर प्रदान करता है। :) (मैं 11 बाइट्स के साथ-साथ अब के लिए भी अटका हुआ हूं।)

— अर्नुलड

मुझे लगता है कि Ịबहुत काम आता है।

— जोनाथन एलन

3

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

;सीमांकक के रूप में उपयोग करके अंतिम सीमांकक हटाया जा सकता है

$_=!m;[/~][_/]|[\\_][~\\]

TIO

26 बाइट्स

— नहुएल फौलीउल
स्रोत

3

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

=SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,"_\",),"_‾",),"‾_",),"‾/",),"/_",),"//",),"\‾",),"\\",)=A1

किसी भी अमान्य जोड़े को निकालता है, फिर trueमूल स्ट्रिंग में यह परिणाम होने पर वापस लौटें ।

— Wernisch
स्रोत

3

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

g=tail>>=zip
h=all(`elem`g"__/~~\\/\\_").g

यह समाधान उपयोग करता है ~, और कॉल करने के लिए फ़ंक्शन h है (यानी, h stringउत्तर देता है)

समाधान एक फ़ंक्शन जी का उपयोग करता है जो एक सूची दी गई है, सूची पर आसन्न मूल्यों के सभी tuples लौटाता है।

तब हम अनुमत पड़ोसियों (में g"__/~~\\/\\_") की सूची और इनपुट सूची में सभी पड़ोसी जोड़े की सूची उत्पन्न करने के लिए जी का उपयोग करते हैं । फिर हम जांचते हैं कि प्रत्येक पड़ोसी जोड़ी एक स्वीकृत जोड़ी है।

— गर्वित हेकलर
स्रोत

3

सी (जीसीसी) , 41 36 बाइट्स

f(char*_){_=!_[1]||*_/32+*++_&f(_);}

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

-5 को पीटर कॉर्ड्स के&1 एक विचार से शुरू करना समाप्त कर दिया ; कोष्ठकों को हटाने के लिए ऑपरेटरों (पूर्वता) को बदल दिया

उपयोग करता है ~। पहले दो वर्णों के बाइनरी अभ्यावेदन के पहले और छठे बिट्स की जाँच करता है:

और पुनरावर्ती स्ट्रिंग का पता लगाता है।

(*_ / 32) & 1केवल उन वर्णों के लिए सत्य है जो उच्च अंत करते हैं, जबकि *_ & 1केवल उन वर्णों के लिए सत्य है जो निम्न प्रारंभ करते हैं। (x&1) ^ (y&1) == (x+y)&1। XOR ऐड-विथ-कैरी है, और कैरी सबसे कम बिट को परेशान नहीं करता है। 1से आता है f(_), वापसी मान यदि स्ट्रिंग के बाकी रेशेदार था।

— attinat
स्रोत

5 से दाईं ओर नीचे की ओर 6 वीं बिट चलती है। तो आप बिट्स 0 और 5 या पहले और छठे बिट्स की जाँच कर रहे हैं। (यह वास्तव में एक अच्छी चाल है, BTW, अच्छी तरह से किया गया है। c&32यह उन वर्णों के लिए सच है जो उच्च अंत करते हैं, जबकि c&1केवल उन वर्णों के लिए सच है जो कम शुरू करते हैं।)

— पीटर कॉर्डेस

मुझे पता है कि नियमों को केवल कम से कम एक कार्यान्वयन पर काम करने की आवश्यकता होती है, लेकिन फिर भी यह इंगित करने के लायक है कि *_ ^ *++_अपरिभाषित व्यवहार: ^एक अनुक्रम बिंदु नहीं है, इसलिए कोई अनुक्रम-पहले संबंध की गारंटी नहीं है कि वे अलग-अलग वर्ण प्राप्त करते हैं। बेशक, यह भी याद आ रही है return, इसलिए यह केवल gcc -O0वहीं काम करता है जहां फ़ंक्शन बॉडी एक स्टेटमेंट-एक्सप्रेशन है।

— पीटर कॉर्डेस

ओह, तुम बिट्स के बारे में सही हो। पकड़ने के लिए धन्यवाद कि

— attinat

1

&1दो बार करना बेमानी है। (x^y)&1 == (x&1) ^ (y&1)। लेकिन सी ऑपरेटर पूर्वता को देखते हुए जहां (जहां अंकगणित ऑपरेटरों की &तुलना में ^+ और - समान प्राथमिकता है) की तुलना में उच्च प्राथमिकता है , हमें ()2 बाइट निकालने के लिए 2 बाइट्स जोड़ने की आवश्यकता होगी &1, क्योंकि (x&1) ^ yयह समकक्ष नहीं है। लेकिन हो सकता है कि पैरेंस के इस्तेमाल से कुछ और बचत के अवसर खुल जाएं। सौभाग्य से इस के एक x86 मशीन-कोड संस्करण के लिए कोई समस्या नहीं है, जहां बिट हेरफेर बहुत कॉम्पैक्ट है ...

— पीटर कॉर्ड्स

इस एल्गोरिथ्म का उपयोग करके मेरे x86 मशीन कोड उत्तर , 13 बाइट्स समाप्त ।

— पीटर कॉर्ड्स

2

बैश, 30 बाइट्स

grep -E '//|\\\\|_~|~_|~/|_\\|/_|\\~'

इनपुट STDIN है। यदि मान्य है, तो 0 से बाहर निकलें कोड अमान्य है।

— vityavv
स्रोत

1

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

	INPUT '/_' | '_\' | '\\' | '//' | '~/' | '\~' @OUTPUT
END

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

सत्य के लिए कुछ भी नहीं है और एक सकारात्मक पूर्णांक (गलत तरीके से स्ट्रिंग में पहले विराम की स्थिति को दर्शाता है)।

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

1

चारकोल , 32 18 बाइट्स

⌊⭆θ∨¬κ⁼№_/ι№\_§θ⊖κ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

  θ                 Input string
 ⭆                  Map over characters and convert to string
     κ              Current index
    ¬               Logical Not (i.e. is zero)
   ∨                Logical Or
          ι         Current character
       №            Count (i.e. contained in)
        _/          Literal _/ (i.e. begins at bottom)
      ⁼             Equals
               θ    Input string
              §     Indexed by
                 κ  Current index
                ⊖   Decremented (i.e. previous character)
           №        Count (i.e. contained in)
            \_      Literal \_ (i.e. ended at bottom)
⌊                   Minimum (i.e. if all true)
                    Implicitly print

— नील
स्रोत

1

x86 मशीन कोड, 13 बाइट्स।

(या 11 बाइट्स एकल-वर्ण स्ट्रिंग्स को संभालने के बिना जो तुच्छ रूप से कठोर हैं।)

@ एटीनैट के सी उत्तर से बिट-पोजिशन चेक का उपयोग करता है

समान मशीन कोड 16, 32 और 64-बिट मोड में काम करता है। स्रोत 64-बिट मोड के लिए एनएएसएम है।

nasm -felf64 -l/dev/stdout  listing
    17   addr                  global string_connected
    18           code          string_connected:
    19           bytes         ;;; input: char *RSI, transitions to check=RCX
    20                         ;;; output: AL=non-zero => connected.  AL=zero disconnected
    21                         .loop:                      ; do {
    22 00000000 AC                 lodsb                   ;   al = *p++
    23 00000001 E309               jrcxz  .early_exit        ; transitions=0 special case.  Checking before the loop would require extra code to set AL.
    24 00000003 C0E805             shr    al, 5
    25 00000006 3206               xor    al, [rsi]          ; compare with next char
    26 00000008 2401               and    al, 1
    27 0000000A E0F4               loopne .loop            ; }while(--rcx && al&1);
    28                         .early_exit:
    29 0000000C C3                 ret

X86-64 unsigned char string_connected(int dummy_rdi, const char *s, int dummy_rdx, size_t transitions);सिस्टम V कॉलिंग कन्वेंशन के साथ C से कॉल करने योग्य। boolइसलिए नहीं कि संक्रमण = 0 मामला ASCII कोड देता है, न कि 1।

RCX = len = strlen(s) - 1। यानी वर्ण-सीमाओं की संख्या = स्पष्ट-लंबाई वाली स्ट्रिंग में जांच करने के लिए संक्रमण।

के लिए transitions > 0, 0 (बेमेल) या 1 (जुड़ा हुआ) रिटर्न देता है और तदनुसार ZF सेट करता है। के लिए transitions == 0, स्ट्रिंग का एकल बाइट लौटाता है (जो गैर-शून्य है और इस प्रकार सत्य भी है)। यदि उस विशेष मामले के लिए नहीं, तो हम जल्दी निकलने वाले JRCXZ को छोड़ सकते हैं। यह केवल लूप के अंदर है क्योंकि एएल गैर-शून्य है।

बिट-पोजिशन लॉजिक इस अवलोकन पर आधारित है कि ASCII कोड का बिट 0 आपको शुरुआती ऊंचाई बताता है, और बिट 5 आपको अंतिम ऊंचाई बताता है।

;;;  _ 1011111
;;;  \ 1011100
;;;  /  101111
;;;  ~ 1111110
;;;     ^    ^

    ; end condition (c>>5) & 1 =>  0 = low
    ; start cond: c&1 => 0 = high
    ; (prev>>5)&1 == curr&1  means we have a discontinuity
    ; ((prev>>5) ^ curr) & 1 == 0  means we have a discontinuity

टेस्ट हार्नेस (अटिनाट के टीआईओ लिंक से संशोधित, सी अनुक्रम-बिंदु यूबी को उस सी संदर्भ फ़ंक्शन में सावधान करें)। इसे ऑनलाइन आज़माएं! । यह फ़ंक्शन सभी 30 मामलों के लिए सही है। (एकल चरित्र वाले मामलों में जहां रिटर्न वैल्यू मेल नहीं खाती है: दोनों उस मामले में विभिन्न गैर-शून्य मानों के साथ सत्य हैं।)

— पीटर कॉर्डेस
स्रोत

1

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

A1इनपुट के रूप में सेल

=1---SUMPRODUCT(--ISNUMBER(FIND({"//","/_","\~","\\","~/","~_","_\","_~"},A1)))

— remoel
स्रोत

0

डार्ट , 94 बाइट्स

f(s)=>!(r'//,\\,~/,_\,~_,_~,/_,\~'.split(',').map((t)=>s.contains(t)).fold(false,(p,e)=>p|e));

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

— Elcan
स्रोत

0

सी ++, 132 110 बाइट्स

-22 बाइट्स ASCII- केवल के लिए धन्यवाद

int f(char*s){int t[128];t[95]=0;t[47]=1;t[92]=2;t[126]=3;for(;*++s;)if(t[s[-1]]%2^t[*s]/2)return 0;return 1;}

यह जानने के लिए कि शुरुआत और अंत ऊपर या नीचे हैं, एक बिटमास्क का उपयोग करता है

— HatsuPointerKun
स्रोत

हम्म। C संस्करण को गोल्फर के रूप में पोर्ट नहीं किया जाएगा: P

— ASCII-only

114

— एएससीआईआई-केवल

110

— ASCII- केवल

0

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

C`[_\\][\\~]|[~\/][_\/]
^0

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

~इसके बजाय उपयोग करता है ‾, क्योंकि इससे टाइप करना आसान हो गया है।

— सारा जे
स्रोत

0

रेगेक्स, 34 बाइट्स

मैं एक भाषा के रूप में Regex का उपयोग करने पर नियम नहीं खोज सका। कृपया मुझे बताएं कि क्या मुझे इसे समायोजित करने की आवश्यकता है।

^(‾+|(‾*\\)?(_*\/‾*\\)*_*(\/‾*)?)$

इसे यहाँ आज़माएँ: https://regex101.com/r/s9kyPm/1/tests

— हाथ-ए-खाना
स्रोत

2

यह 34 बाइट्स हैं, 24 नहीं, है ना?

— सारा जे

ठीक है, वास्तव में 42 बाइट्स, लेकिन आप बदल सकते हैं ‾करने के लिए~

— जो राजा

0

एपीएल + विन, 58 बाइट्स

m ⍳ 2 2← '_ / \ ~' ←s ⊤, 1 (1 + )s) = + / (((/ m [0;]), m [1;]) = m [0;]; ⊤ 1 ↑ मीटर [1;]

स्ट्रिंग के इनपुट के लिए संकेत, सूचकांक मूल 0 और ऊपरी चरित्र के लिए ~ का उपयोग करता है

इसे ऑनलाइन आज़माएं! दरियाल क्लासिक के सौजन्य से

— ग्राहम
स्रोत

क्या यह स्ट्रिंग स्ट्रिंग के रूप में काम करेगा?

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

टिप्पणी की गई

जेली , 14 12 11 बाइट्स

कैसे?

टिप्पणी की गई

रूबी-एन , 30 बाइट्स

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

आर , 89 87 81 78 बाइट्स

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

सी (जीसीसी) , 93 बाइट्स

चिप -z , 17 बाइट्स

05AB1E , 29 14 9 बाइट्स

मूल 29 बाइट्स उत्तर:

पायथन 3 , 79 70 63 बाइट्स

पायथन 3 , 67 60 बाइट्स ~ के बजाय 67

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

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

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

स्पष्टीकरण:

आर , 43 चार्ट, 47 बाइट्स

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

व्याख्या

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

पायथन 3 , 80 78 बाइट्स

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

जेली , 13 12 11 बाइट्स

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

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

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

सी (जीसीसी) , 41 36 बाइट्स

बैश, 30 बाइट्स

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

चारकोल , 32 18 बाइट्स

x86 मशीन कोड, 13 बाइट्स।

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

डार्ट , 94 बाइट्स

सी ++, 132 110 बाइट्स

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

रेगेक्स, 34 बाइट्स

एपीएल + विन, 58 बाइट्स

चिप `-z` , 17 बाइट्स