गरबे किए हुए फोन नंबर

19

आप जानते हैं कि आपको ध्वनि मेल संदेश कैसे मिलता है और व्यक्ति का कनेक्शन महान नहीं था, और आप यह पता लगाने की कोशिश कर रहे हैं कि उन्हें कैसे वापस बुलाया जाए, लेकिन आपको यकीन नहीं है कि "5" या "8" वे थे कहा हुआ?

यही चुनौती है।

अच्छी खबर यह है कि फोन करने वाले ने अपना नंबर दो बार पढ़ा, लेकिन यह दोनों जगहों पर है।

आपके कार्यक्रम को इस तरह इनपुट लेना चाहिए:

5551231234 / 5551231234

जहां पहले दस अंकों में पहली बार फोन नंबर को वॉइस मेल में और दूसरे सेट को दूसरी बार कहा जाता है। केवल ... यह इस तरह दिखाई देगा:

555?ABC1_36? / 55?522_1?234
  • एक प्रश्न चिह्न के बाद एक अंक का मतलब है कि उस अंक के लिए सबसे अच्छा अनुमान है (उदाहरण के लिए "5?" का अर्थ है "शायद एक 5, दोहराने के साथ तुलना करें")।
  • एक अंडरस्कोर एक ज्ञात लापता अंक को इंगित करता है, कुछ स्थैतिक द्वारा फुज्जीदार होता है जो कि सभी में विघटित हो जाता है।
  • पत्र बस यही हैं: पत्र। उन्हें अपने संबंधित अंकों के रूप में समझो
    • ABC -> 2, DEF -> 3, GHI -> 4, JKL -> 5, MNO -> 6, PQRS -> 7, TUV -> 8, WXYZ -> 9
    • सभी नमूना इनपुट अपरकेस का उपयोग करते हैं (आप सुरक्षित रूप से एक टॉपर () कॉल को छोड़ सकते हैं)
    • यदि आपकी भाषा निचले मामले में बेहतर काम करती है, तो आप स्वतंत्र रूप से इनपुट के लिए लोअरकेस का उपयोग कर सकते हैं और टोलॉवर () कॉल को छोड़ सकते हैं। बस अपने उत्तर में ध्यान दें।

आप अतिरिक्त रूप से निम्नलिखित निर्णय कॉल मान सकते हैं:

5? / _     -> 5  //5 is the best guess we have, use it
5? / 5?    -> 5  //uncertain, but matching
5? / 4?    -> ?  //conflict
 5 / 4     -> ?  //conflict
5? / 4     -> 4  //solid information overrides possible value
 5 / 4?    -> 5  //solid information overrides possible value
 _ / _     -> ?  //no information available

इसके अतिरिक्त आप यह मान सकते हैं कि सभी इनपुट में दस अंकों के फोन नंबर होंगे, न कि प्रश्न चिह्न सहित। ऐसे इनपुट जो दस अंकों के नहीं हैं (उदाहरण के लिए 1234567 / 1234567) या तो अनचाहे (फालसे आउटपुट) के रूप में माने जा सकते हैं या एक त्रुटि फेंक सकते हैं।

इनपुट

पात्रों की एक पंक्ति 0-9A-Z _?/, जैसा कि ऊपर वर्णित है।

उत्पादन

यदि यह एक वैध दस अंकों वाले फोन नंबर पर पार्स किया जा सकता है, तो फोन नंबर को आउटपुट करें। अन्यथा त्रुटि संकेत के कुछ रूप आउटपुट (जैसे -1, गलत, या एक खाली लाइन)।

सबसे छोटी जीत, हमेशा की तरह।

नमूना इनपुट:

1234567890 / 1234567890
1234567890? / 1234567890
123456789_ / 1234567890
1234567890? / 123456789_
1234567890 / 1234567890?
1234567890 / 123456789_
123456789_ / 1234567890?
1234567890? / 1234567890?
1234567890? / 1234567891?
123456789_ / 123456789_
555CALLUS1 / 5552255871
404_12?6039 / 4041?1560_9
_GETREVENGE / 16?36?_2838_
1?691460_50 / 16_14609?50
61?08977211 / 612?897725?1
40?0INSTA__ / 8?00_NSTI?LL
3985_534?10 / 39?8?5053_10
7__7294?737 / 7797299?_37
28?897_384?1 / _8?89763861
271168090_ / 27116800?09
6802?148343 / 67?01148343
94_11628?2?6? / 9491162_47?
17?4285_689 / 1__26?52689
6_311?95_38 / 6731194?7?38
380?7DRAGON / 3807378?5?66
4?647_93236 / 5646?6?9__36
365?268898_ / 366267?7?984
GRATEDBATE / IRATEDBATE
5307_079?93 / ____8_____
535_3_0255 / 52?5_3_024?5
55_____088 / 54?2397207?7?
6_48398_95 / _946?398?6_5?
_0_312_3_1 / 81?53123?1?71
____1_____ / 64?255?508?61
8427820607 / 6?424?8?__6?07
50_3707__6 / 52?8375?74?56
615___8255 / 62?526?983?2?1?
__652618__ / 8365261__0
149___933_ / 1_9677?92?31
___7?281562 / 3438?28154?2
5?7?7?___8?3?7?4 / 57_855837_
605_272481 / 605427__81
86?569__731 / 88560?0?7721
1__91654?15 / 17?9?9165715
800NWABODE / 80069ABI?DE
8___9017_0 / 8_2494?12?9_
_024?5?91?470 / 304?17908?7_
42510704_2 / 4_51070492
9338737_89 / 93_873PLUS
327762_401 / 327_MASH01
33093_2058 / 3309_12058
4061_33578 / 40619_3578
559_383197 / 559938_197
94_9746084 / 9459746_84
1_37655238 / 163POLKA_T
_672FRIZZY / 767237499_
8_76318872 / TIP63188_2
51_8404321 / 5178404_21
358_030314 / 358603_314
2597_85802 / 25979_5802
77141_1408 / 7714_91408
330858_457 / 330_586457
4686079_39 / 46_6079239
86457508_6 / 8_45750826
523226626_ / _23BANNANA
_ISSY_ISSY / 44__9548?79?
6?00B_YJILT / 800289KILL?
2?52803___0 / 1526?0390?61?
FI?ND___T?HE / EAS?T?EREGGS?
0_231?95_38 / 0723194?7?38
0?647_39236 / 0646?6?3__36
025?267798_ / 06?6265?9?984
0061_33578 / _0619_3578

मैंने केवल यह सुनिश्चित किया है कि हर संभावित किनारे का मामला (पहले 11 प्रविष्टियाँ) कवर किया गया है, लेकिन इसके अलावा, यह बहुत अधिक यादृच्छिक है।

अपडेट करें

तल पर चार प्रविष्टियाँ अग्रणी शून्य (जोनाथन एलन के सुझाव पर) के साथ जोड़ी गईं।

नमूना इनपुट के लिए सही आउटपुट:

https://pastebin.com/gbCnRdLV

जोनाथन एलन के प्रवेश से आउटपुट के आधार पर (स्वरूपित आउटपुट आदर्श था)।

code-golf  cipher 
— Draco18s
स्रोत
क्या हमें इनपुट्स को एक स्ट्रिंग के रूप में लेना है " / ", जिसे हमने अलग किया है , या क्या हम उन्हें दो मानक इनपुट के रूप में ले सकते हैं?
— L3viathan
@ L3viathan मैंने मूल रूप से एक स्ट्रिंग लेने के रूप में विचार की कल्पना की थी।
— ड्रेको
7
@ Draco18s सिंगल स्ट्रिंग चुनौती के लिए कुछ भी नहीं लाती है
— f'nɪt Aprk
1
@ f @n thetɪk सैंडबॉक्स में किसी ने कुछ नहीं कहा, लेकिन मेरे पास इनपुट जोड़े का उपयोग करने के खिलाफ कुछ भी नहीं है । यह सिर्फ वह तरीका था जिससे मैंने मूल रूप से कल्पना की थी।
— ड्रेको १।
1
कौन अपने फोन नंबर के लिए अक्षरों का उपयोग कर एक ध्वनि मेल छोड़ देता है ?!
— जोनाथन एलन

जवाबों:

3

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

+4 बाइट्स - मुझे लगता है कि इसे शायद सभी मामलों में एक जैसा व्यवहार करना चाहिए, इसलिए मैंने कीपैड लुकअप पूर्णांक को डिजिट-वर्णों में वापस बदल दिया है +49Ọ।

”?e‘ḣ@µ”_eḤ‘ẋ@
;Ṃµ68DṬ+3RØAṁẇ@€FT+49Ọȯµ€Fṡ2i”?Ḃ$ÐḟÇ€
ḟ⁶ṣ”/Ç€ZLÐṂ€Q€LỊ$ÐfF€Ḣ€ḟ”_µL⁼⁵ȧ

एक फ़ंक्शन जो निर्दिष्ट प्रारूप में स्ट्रिंग लेता है और अमान्य होने पर वर्ण या शून्य की सूची के रूप में फोन नंबर देता है। एक कार्यक्रम के रूप में यह मुद्रित किया जाता है जैसे कि यह एक स्ट्रिंग था।

जिस तरह से यह काम करता है वे संख्या को अधिक बार दोहरा सकते हैं
(जैसे "123456789_ / 123456789_ / 1234567890")
... या यहां तक ​​कि इसे केवल एक बार कहें, और परिभाषित तर्क लागू होगा।

इसे ऑनलाइन आज़माएं! , या सभी नमूना इनपुट देखें ।

कैसे?

”?e‘ḣ@µ”_eḤ‘ẋ@ - Link 1, helper to vary the length of a 2-slice: list s
”?             - literal '?'
  e            - exists in s                   (1 or 0)
   ‘           - increment                     (2 or 1)
    ḣ@         - head with reversed @rguments  (s or s[:1] - removes 2nd value if not '?')
      µ        - monadic chain separation, call that t
       ”_      - literal '_'
         e     - exists in t                   (1 or 0)
          Ḥ    - double                        (2 or 0)
           ‘   - increment                     (3 or 1)
            ẋ@ - repeat t that many times      (t*3 or t - [`_`]->['_','_','_'])

;Ṃµ68DṬ+3RØAṁẇ@€FT+49Ọȯµ€Fṡ2i”?Ḃ$ÐḟÇ€ - Link 2, reformat a phone number: char list of [0-9][A-Z], p
;                                     - concatenate p with
 Ṃ                                    - minimum of p - (?<_<0<1<...<9<A<...<Z - never "?" however, since it only follows a digit.)
                                      -   - this is simply to make a 2-slice with the last character on the left, as used at the very end of this link.
  µ                                   - monadic chain separation call that q
                       µ€             - monadic chain separation, for €ach v in q do:
   68                                 -   literal 68
     D                                -   cast to a decimal list -  [6,8]
      Ṭ                               -   untruth                -  [0,0,0,0,0,1,0,1]
       +3                             -   add 3                  -  [3,3,3,3,3,4,3,4]
         R                            -   range                  -  [[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3,4],[1,2,3],[1,2,34]]
          ØA                          -   uppercase alphabet     -  ABCDEFGHIJKLMNOPQRSTUVWXYZ
            ṁ                         -   mould like the range ^ -  [ABC,DEF,GHI,JKL,MNO,PQRS,TUV,WXYZ]
             ẇ@€                      -   sublist v exists in that? for €ach, with reversed @rguments
                F                     -   flatten        (e.g. 'E' -> [0,1,0,0,0,0,0,0]; '4' -> [0,0,0,0,0,0,0,0]
                 T                    -   truthy indexes (e.g. 'E' -> [2]; '4' -> [])
                  +49                 - add 49
                     Ọ                - cast to character
                      ȯ               -   or             (e.g. 'E' -> [3]; '4' -> '4')
                         F           - flatten
                          ṡ2          - all slices of length 2
                                 Ðḟ   - filter discard if:
                                $     -   last two links as a monad:
                            i         -     first index of
                             ”?       -     literal '?'   (first index returns 0 if none exists)
                               Ḃ      -   mod 2 (so this filter discards pairs starting with '?')
                                   Ç€ - call the last link (1) as a monad for €ach slice

ḟ⁶ṣ”/Ç€ZLÐṂ€Q€LỊ$ÐfF€Ḣ€ḟ”_µL⁼⁵ȧ - Main link: string (or char list) s
ḟ                               - filter discard any:
 ⁶                              - literal ' '
  ṣ                             - split on:
   ”/                           - literal '/'
     Ç€                         - call the last link (2) as a monad for €ach
       Z                        - transpose
         ÐṂ€                    - filter, for €ach, keep items with minimal:
        L                       -   length
            Q€                  - de-duplicate €ach
                 Ðf             - filter keep items with:
                $               - last two links as a monad:
              L                 -   length
               Ị                -   insignificant? (=1 effectively here)
                   F€           - flatten €ach
                     Ḣ€         - head €ach
                       ḟ        - filter discard any of:
                        ”_      -   literal '_'
                          µ     - monadic chain separation, call that r
                           L    - length(r)
                             ⁵  - literal 10
                            ⁼   - equal?
                              ȧ - and r (0 if r did not result in a 10-digit list, else r)
— जोनाथन एलन
स्रोत
ऐसा लगता है कि कोई त्रुटि हो सकती है, 55_____088 / 54?2397207?7?इसे हल करना चाहिए 5523972088: सभी लापता अंक मौजूद हैं और दाईं ओर अनिश्चित अंक बाईं ओर उपलब्ध हैं। हालांकि सभी सरलीकृत मामले चलते हैं।
— ड्रेको
आह, मैंने जो कुछ सोचा था उसे हटा दिया, यह एक अनावश्यक फिल्टर था, यह नहीं था। फिक्सिंग ...
— जोनाथन एलन
पहले वहाँ गया था - और यह गोल्फ नहीं था! ;)
— ड्रेको
Ooof जो मुझे थोड़ी देर लगी (मुझे यह परीक्षण करते समय एक अलग बग मिला), इसे वापस उसी बाइट काउंट पर मिला जैसे कि फ़िल्टर को वापस जोड़ते समय इसे ठीक करना (हालांकि www)।
— जोनाथन एलन
@ Draco18s - क्या सब कुछ आपको अच्छा लगता है? प्रश्न में परीक्षण मामलों के लिए अपेक्षित आउटपुट देना अच्छा हो सकता है, या शायद अमान्य लोगों को अलग करना।
— जोनाथन एलन
5

पायथन 3, 549 530 509 453 449 410 406 394 393 391 बाइट्स

मुझे यकीन है कि इसमें सुधार किया जा सकता है, लेकिन यह एक शुरुआत है:

def f(e,z,q="?",u=str.isnumeric):
 if e+z in(e,z):return""
 o,O,t,T,*x=e[0],e[1:2],z[0],z[1:2],e[1:],z[1:]
 if"?"in o+t:return f([e,x[0]][o==q],z)
 if u(o):
  if u(t):return t+f(*x)if O==q!=T else o+f(*x)if o==t or T==q!=O else 1
  return o+f(*x)
 if u(t):return t+f(*x)
def g(s):
 for a,b in zip(map(chr,range(65,91)),"2223334445556667777888999"):s=s.replace(a,b)
 return f(*s.split(" / "))

मैं str.translateअक्षरों के लिए उपयोग कर रहा हूँ , और एक रैपर फ़ंक्शन gको उस प्रारूप में इनपुट बनाने के लिए जिसमें मैं उन्हें चाहता हूं। वास्तविक कार्य fपुनरावर्ती है, और अस्पष्ट आदानों के लिए विफल हो जाएगा। मेरे पास अभी भी बहुत सारे सुधार हैं, हालांकि मुझे यकीन है कि सुधार के लिए बहुत सारे कमरे हैं।

सुधार:

  • स्थितियों को मिलाकर 19 बाइट्स बचाए
  • टर्नरीज़ के साथ 21 बाइट्स बचाए
  • मैनुअल शब्दकोश के बजाय एक शब्दकोश समझ का उपयोग कर 56 बाइट्स को बचाया, @TuukkaX के लिए धन्यवाद
  • @ TuskaX के सुधार के साथ @ovs द्वारा सुझाई गई विधि पर स्विच करके 4 बाइट्स को बचाया
  • @ovs (और अंतिम हटाने योग्य व्हाट्सएप हटाया) से सुधार के साथ 38 बाइट्स को बचाया
  • str.isnumericएक कीवर्ड तर्क में परिभाषित करके 4 बाइट्स को बचाया
  • संयुक्त तुलना ऑपरेटरों (जैसे T==q!=O) के साथ 12 बाइट्स बचाया
  • बदल कर 1 बाइट बचाया not(e or z)में e+z in(e,z)।
  • अक्सर इस्तेमाल होने वाली बचत करके 2 बाइट्स बचाए (E,Z)
— L3viathan
स्रोत
इसमें एक शब्दकोश की समझ शामिल है जिसमें शीर्ष पंक्ति चूक नहीं है। मुझे 3 के दृश्यों से नफरत है, लेकिन उन्हें गणित से बदला जा सकता है।
— यति
— ovs
@ नोव्स नाइस। वर्णमाला को map(chr,range(65,91))हालांकि बदला जा सकता है ।
— यति
2
पुन: प्रतिष्ठा को माफ करने के लिए इस समुदाय को विकि बनाना, सर्वसम्मति नहीं होगी , बस इस तरह की सहायता को स्वीकार करें, और इसे क्रेडिट करें जैसे कि आपके पास है।
— जोनाथन एलन
1
मैं हर बार शपथ लेता हूं कि मैं यहां वापस आऊंगा। यह जवाब छोटा है: D
— Draco18s
3

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

संपादित करें: नकली उत्पादन नियम का पालन करने के लिए +10 +9 बाइट्स

सिंटैक्स में दो इनपुट स्ट्रिंग्स को ले जाता है (a)(b)। falseया तो या एक स्ट्रिंग अनुमान लगाया फोन नंबर का प्रतिनिधित्व करता है।

a=>b=>!(s=(F=a=>a.match(/(.\??)|_/g).map(([x,y])=>(x<=9?++x:parseInt(x,36)*.32-(x>'Y'))|(x!='_'&!y)*16))(a).map((x,i)=>(x=(d=x^(y=F(b)[i]),x>y)?x:y)&&(d&16|!(d%x))?--x&15:a).join``)[10]&&s

यह काम किस प्रकार करता है

चरण # 1 - इनपुट स्ट्रिंग को पार्स करना

हम पहले F()फ़ंक्शन को परिभाषित करते हैं जो निम्नलिखित नियमों को लागू करके पूर्णांक की एक सरणी में एक स्ट्रिंग का अनुवाद करता है:

  • अंडरस्कोर 0 में परिवर्तित हो जाता है
  • एक अंक N या एक समतुल्य अक्षर (N + 1) या 16 में बदल जाता है (उदाहरण के लिए "2" → 19, "R" → 24)
  • अंक एन या एक समकक्ष पत्र जिसके बाद एक पूछताछ चिह्न N + 1 में बदल जाता है (उदाहरण के लिए "2?" → "," R? "→ 8)

जिसकी व्याख्या अन्य तरीके से इस प्रकार की जा सकती है:

  • ० → अज्ञात
  • [ १ .. १० ] → अविश्वसनीय
  • [ १ [ .. २६ ] → विश्वसनीय

हम लागू F()दोनों को aऔर b। यह हमें दो संभावित व्याख्याओं के अनुरूप फोन नंबर में प्रत्येक अंक के लिए पूर्णांक (x, y) की एक जोड़ी देता है ।

चरण # 2 - अंकों का अनुमान लगाना

प्रत्येक जोड़ी (x, y) के लिए , हम गणना करते हैं:

  • d = x XOR y
  • x = MAX (x, y) → विश्वसनीय मान हमेशा अविश्वसनीय लोगों को पसंद किए जाते हैं

यदि x == 0 , इसका मतलब है कि दोनों इनपुट अंडरस्कोर वर्ण हैं। तो, अंक इस मामले में अज्ञात है।

यदि x! = 0 , हम निम्न स्थितियों में से किसी एक के सत्य होने पर अंक को सुरक्षित रूप से निकाल सकते हैं:

condition       | interpretation
----------------+------------------------------------------------------
(d AND 16) != 0 | one input is unreliable and the other one is reliable
d == 0          | both inputs are identical
d == x          | one input is an underscore

अंतिम दो स्थितियों को मिला दिया जा सकता है !(d % x)। इसलिए अंतिम सूत्र:

x && (d & 16 || !(d % x))

यदि सही है, तो हम गणना (x - 1) और 15 द्वारा अनुमानित संख्या को x वापस बदल देते हैं ।

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

(केवल 50 पहले वाले क्योंकि कंसोल स्निपेट अधिक आउटपुट इतिहास का समर्थन नहीं कर सकता है।)

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

— Arnauld
स्रोत
1234567890? / 1234567890?को हल करना चाहिए 1234567890। अभी आपका कोड आउटपुट 123456789?जो इनपुट की तुलना में कम जानकारीपूर्ण है। Assume: 5? / 5? -> 5 //uncertain, but matching
— ड्रेको
@ Draco18s मेरे कहे के विपरीत, मैंने 51 परीक्षण मामलों को शामिल किया । तो पहले वाले को गिरा दिया गया और सब कुछ एक पंक्ति से स्थानांतरित हो गया। (अब तय किया। इस बारे में क्षमा करें।)
— अरनौल्ड
आह। फिर भी, यह उन परीक्षण-मामलों के लिए किसी प्रकार के फाल्सी या त्रुटि मूल्य का उत्पादन करना चाहिए। लेकिन अन्यथा अच्छा लग रहा है।
— ड्रेको १।
2

पर्ल 5 , 211 बाइट्स

... बिना इंडेंटेशन और \ n नईलाइन्स के 

@i=map{y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/22233344455566677778889999/;$_}split' / ',shift;
print map{
  $_=join'',map{s,(\d\??|_),,;$1}@i;
  /((\d)\??\2\??|(\d)\??_|_(\d)\??|(\d)\d\?|\d\?(\d))$/;$2//$3//$4//$5//$6//'?'
}1..10

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

— केजेटिल एस।
स्रोत
ऐसा लगता है कि इसकी वापसी "सबसे अच्छा यह कर सकती है" ( 83652618?0) के बजाय किसी प्रकार के फाल्सी या त्रुटि मूल्य के साथ हो सकती है।
— ड्रेको
अगर मैं गलत नहीं हूँ तो पहेली क्या थी। हेडिंग के तहत मामलों को देखें "आप अतिरिक्त रूप से निम्नलिखित निर्णय कॉल को मान सकते हैं"। या नहीं?
— Kjetil S.
क्षमा करें, आपके उत्तर की सूचना कभी नहीं मिली (कोई उल्लेख नहीं)। निर्णय कॉल के लिए मैंने जो अनुभाग किया है वह ?यह दर्शाता है कि लापता जानकारी को हल करने का कोई तरीका नहीं है, जो तब आउटपुट अनुभाग के माध्यम से गिरना चाहिए:...Otherwise output some form of error indication (e.g. -1, false, or an empty line).
— Draco18s
2

रेटिना, 150 140 136 बाइट्स

क्रिति लिथोस के लिए कुछ बाइट्स का धन्यवाद

T`?L`#22233344455566677778889
./.

(?<=(\d)(\w#?){9}).#|.#(?=(\w#?){9}(\d)(?!#))
$1$4
#

_(?=.{9}(.))|(?<=(.).{9})_
$1$2
^(\d*)\1$|.*
$1

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

स्पष्टीकरण:

पहली पंक्ति ?इनपुट में #सभी और सभी अक्षरों को उनके संख्यात्मक समकक्षों में बदल देती है। फिर हम रिक्त स्थान को हटाते हैं और /इनपुट से। अगली दो पंक्तियाँ "अनुमान बनाम निश्चितता" मामलों का ध्यान रखती हैं (उदाहरण के 5? \ 4लिए प्रतिस्थापित किया जाएगा 4 \ 4)। सभी #एस को हटाने के बाद , पंक्तियाँ 8 और 9 "संख्या बनाम _" मामलों से निपटती हैं ( _ \ 3बन जाती हैं 3 \ 3)। फिर, यदि दोनों स्ट्रिंग मैच के बीच में हैं, तो हम पहले 10 अंक रखते हैं। अन्यथा, फ़ोन नंबर अमान्य है इसलिए हम सब कुछ हटा देते हैं।

वैकल्पिक 160-बाइट समाधान जो मनमानी लंबाई (और समान आकार) के फोन नंबरों के लिए काम करता है: टीआईओ

— गणित के दीवाने
स्रोत
आप 1 बाइट को बचाने के (/|_)लिए बदल सकते हैं [/_]। इसके अलावा मुझे लगता है कि आप उपयोग कर सकते हैं ;के बजाय xइतना है कि [^x]हो सकता है\w
— Kritixi lithos
1

PHP, 251 236 बाइट्स

for(;a&$c=preg_replace(["#[^_?](?!\?)#","#_#"],["$0k","?<"],join("-",$argv))[++$i];)${$k+="-"==$c}.=$c<_&$c>=A?0|(ord($c)-($c>W)-($c>P)-59)/3:$c;for(;$c=${1}[$k+1];)echo($n=${1}[$k])==($m=${2}[$k++])|($b=${2}[$k++])!=$c?$c>$b?$n:$m:"?";

कमांड लाइन से इनपुट लेता है; इसे ऑनलाइन चलाएं -nrया प्रयास करें ।

टूट - फूट

# A: transform input
                                    # 2. replace single chars with two-character chunk and make sortable:
                                    #   replace "_" with "?<", append "k" to everything else not followed by "?"
for(;a&$c=preg_replace(["#[^_?](?!\?)#","#_#"],["$0k","?<"],join("-",$argv))[++$i];)    # (unknown "<" < unsure "?" < certain "k")
${$k+="-"==$c}.=                # if "-", next argument
        $c<_&$c>=A              # if letter
            ?0|(ord($c)-($c>W)-($c>P)-59)/3 # then translate to digit
            :$c                             # else don´t
    ;
# B: evaluate
for(;$c=${1}[$k+1];)            # loop through arguments: $c=command 2
    echo
        ($n=${1}[$k])                   # $n=digit 2
        ==                          # if digits are equal
        ($m=${2}[$k++])                 # $m=digit 3
        |
        ($b=${2}[$k++])             # $b=command 3
        !=$c                        # or "commands" are not
            ?$c>$b?$n:$m            # then get the one with the more definitive "command"
            :"?"                    # else conflict/unknown
    ;

golfings

  • preg_replace पहला: -8 बाइट्स
  • join: -2
  • $$kइसके बजाय $t[$k]: -5
— टाइटस
स्रोत
1

PHP, 200 + 8 बाइट्स

Arnaulds समाधान से प्रेरित है ।

for($s=join($argv);$c=ord($s[$i++]);$i+=$x)$t[]=$c>90?63:15&($c<65?$c:($c-($c>80)-($c>87)-59)/3)|16*$x="?"==$s[$i];for(;$p++<10;)echo chr(($e=$t[$p]^$d=$t[$p+10])&48|!(15&$e)?min($t[$p],$d)&15|48:63);

कमांड लाइन तर्कों से इनपुट लेता है; इसे ऑनलाइन चलाएं -nrया प्रयास करें ।

त्रुटि आउटपुट प्रतिबंध का अनुपालन करने के लिए संशोधन: ( Xअपूर्ण संख्या के लिए प्रिंट करें ):

  • निकालें |48(-3 बाइट्स)
  • की जगह echo chr(...);के साथ $r.=...;echo$r>1e10?X:$r;(+11 बाइट्स)

टूट - फूट

for($s=join($argv);$c=ord($s[$i++]);    # loop through characters of arguments
    $i+=$x)                             # skip "?"
$t[]=
    $c>90                               # if "_"
        ?63                             # then 32+16+15
        :                               # else
            15&(                            # lower 4 bits of
            $c<65                               # if digit
            ?$c                                 # then digit
            :($c-($c>80)-($c>87)-59)/3          # else letter mapped to digit
        )
        |16*$x="?"==$s[$i]                  # if next char is "?", add 16
;
for(;$p++<10;)echo chr( # loop through translated arguments
    (
        $e=$t[$p]^      # 2. $e=difference
        $d=$t[$p+10]    # 1. $d=char from 2nd argument
    )&48                # if certainties differ
    |!(15&$e)           #    or digits do not
    ?min($t[$p],$d)&15|48   # then pick the more definite digit (15|48 -> "?")
    :63             # else "?"
);

golfings

  • काम के आसपास preg_replace_callback(-10 बाइट्स)
  • 10 अंकों के इनपुट (-9) पर भरोसा करें
  • और अतिरिक्त गोल्फिंग (-8)
  • हटाए गए joinसीमांकक (-7)
  • स्थानांतरित $xसमाप्त करने के लिए काम (-2)
— टाइटस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.