अपना फोन उठाओ! कंप रहा है!

14

आपको अभी हाल ही में एक नया फ़ोन मिला है, लेकिन आप इसे कंपन करने के तरीके को पसंद नहीं करते हैं, आपने तय किया है कि आप अपना कंपन पैटर्न बनाना चाहते हैं। इसलिए, आपने एक प्रोग्राम लिखा है जहां आपने कीवर्ड का उपयोग किया है long, shortऔर pauseइन कीवर्ड के अनुसार अपने फोन को वाइब्रेट करने के लिए।

कार्य

एक छोटा सा प्रोग्राम है जो की एक स्ट्रिंग को स्वीकार करता है बनाएं long, short, और pauseऔर एक अन्य स्ट्रिंग हिल एक फोन की ध्वन्यात्मक ध्वनि का प्रतिनिधित्व आउटपुट;Rrrr - Rr

longध्वनियाँ Rrrr
shortध्वनियाँ हैं Rr
(आवरण मामले)
pauseएक डैश है जो -
सभी ध्वनियों को आसपास के रिक्त स्थान के साथ डैश द्वारा सीमांकित किया जाता है' - '

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

इनपुट:    long long short long short
आउटपुट:Rrrr - Rrrr - Rr - Rrrr - Rr

इनपुट:   long long long short short short
आउटपुट:Rrrr - Rrrr - Rrrr - Rr - Rr - Rr

इनपुट:   short short short pause short short short
आउटपुट:Rr - Rr - Rr - - - Rr - Rr - Rr

इनपुट:   long short short long long pause short short
आउटपुट:Rrrr - Rr - Rr - Rrrr - Rrrr - - - Rr - Rr

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

code-golf  string 
— tisaconundrum
स्रोत
5
एक व्यक्तिपरक मानदंड नहीं है? मैं खाली स्ट्रिंग का उपयोग करना चाहूंगा, यह मेरे लिए एक हिल फोन की तरह लगता है।
6
आपका "लगता है" नियम बहुत ज्यादा अस्पष्ट है। मेरा सुझाव है कि बस सटीक तार की आवश्यकता होगी। कोड गोल्फ में सटीक मानदंड की आवश्यकता होती है, ताकि हम इस बात पर तर्क के बिना कोड को अनुकूलित कर सकें कि क्या सुधार वैध है।
— xnor
4
क्या हमें ध्वनियों का परिसीमन करना है -? यह आपके उदाहरण में मामला है, लेकिन कहीं भी निर्दिष्ट नहीं है।
— JAD
12
सभी उदाहरण एक कैपिटल लोअर का उपयोग करते हैं, उसके बाद एक निचले अक्षर की प्रतियां। क्या यह एक नियम है?
— xnor
3
इसे फिर से खोलने से पहले क्या किया जाना चाहिए: 1) सटीक स्ट्रिंग्स (या स्ट्रिंग्स के सेट ) निर्दिष्ट करें जिन्हें हमें उपयोग करना होगा, जिसमें केस की सीमाएं भी शामिल हैं, 2) स्पष्ट करें कि क्या इनपुट और / या आउटपुट शब्दों या सरणियों का एक सरणी हो सकता है वर्ण, 3) एक स्ट्रिंग के रूप में आउटपुट करते समय उपयोग किए जाने वाले सटीक विभाजक को निर्दिष्ट करें।
— झबरा

जवाबों:

12

Pyke , 22 20 बाइट्स

cFh.o6.&\R*\-|l4)J" -

यहाँ यह कोशिश करो!

c                      -  split(input, " ")
 Fh.o6.&\R*\-|l4)      -  for i in ^:
  h                    -        ^[0]
   .o                  -       ord(^)
     6.&               -      ^ & 6
        \R*            -     ^
           \-|         -    ^ or "-"
              l4       -   ^.title()
                 J" -  - " - ".join(^)

इस जवाब की जड़ के परिवर्तन है ["long", "short", "pause"]में [4, 2, 0]। इसे प्रत्येक शब्द के पहले अक्षर का कोड बिंदु मिलता है और ANDइसे 6 के साथ। भाग्यशाली संयोग से यह उन मूल्यों में बदल जाता है जिन्हें हम खोज रहे हैं। (मैंने इसे खोजने से पहले कुछ अन्य लंबे समाधानों के माध्यम से खोज की)। एक बार जब हम ऐसा कर लेते हैं, तो हम ["RRRR", "RR", ""]अपने इंट को गुणा करके उस सूची की सूची को और बदल सकते हैं, "R"जिसके बाद इसे बदल देते हैं ["RRRR", "RR", "-"]और अंत में इसे प्राप्त करने के लिए केसिंग करते हैं ["Rrrr", "Rr", "-"]। हम फिर परिणामी सूची से जुड़ते हैं" - "

— नीला
स्रोत
परिवर्तन के साथ इसके बारे में जाने का अच्छा तरीका!
— टिसकोनमुद्रम
समाधान बेतुके रूप से पायथ में समान है: j" - "m|*\M.&Chd6\-c:-)
— श्री एक्सकोडर
इसके अलावा ओपी उदाहरणों के लिए जगह जोड़ता है लेकिन उन्हें निर्दिष्ट नहीं करता है, मैंने उस पर स्पष्टीकरण के लिए कहा है।
— जोनाथन एलन
@JonathanAllan बाइट्स \xefऔर \xa6कर रहे हैं .oऔर .&क्रमशः। यह एक पिछड़ा संगत परिवर्तन है जहां यदि उच्च बिट सेट है, तो यह इसे पुराने 2 बाइट कमांड की तरह चलाता है। मैं इसे पाठक के लिए आसान बनाने के लिए इसे लिख रहा हूं और क्योंकि Pyke तकनीकी रूप से अब किसी कोड पृष्ठ का उपयोग नहीं करता है और मैं यादृच्छिक बाइट्स सम्मिलित नहीं करना चाहता जो काम नहीं करते हैं
— Blue
11

हास्केल , 71 66 59 बाइट्स

g 'o'="Rr"
g 'n'="rr"
g 'p'="-"
g ' '=" - "
g _=""
f=(g=<<)

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

ओह ठीक है, =<<कॉन्टेक्ट मैप है।

इस तथ्य का लाभ उठाता है कि "long"और "short"दोनों के पास पत्र है o।

— betaveros
स्रोत
आपको f=बिना असाइनमेंट के पॉइंट-फ्री फ़ंक्शंस के लिए 2 बाइट्स का भुगतान करने की आवश्यकता नहीं है
— पोस्ट रॉक गार्फ हंटर
आप एक पूरे बाइट को लैम्ब्डाबेस से लैम्बडाबोट हैस्केल पर ले जाकर बचा सकते हैं:(>>=(\case 'o'->"Rr";'n'->"rr";'p'->"-";' '->" - ";_->""))
— ब्लैककैप
7

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

s=>s.split` `.map(x=>x<'m'?'Rrrr':x<'q'?'-':'Rr').join` - `


let f =

s=>s.split` `.map(x=>x<'m'?'Rrrr':x<'q'?'-':'Rr').join` - `

console.log(f("long long short long short")); // => Rrrr - Rrrr - Rr - Rrrr - Rr
console.log(f("long long long short short short")); // => Rrrr - Rrrr - Rrrr - Rr - Rr - Rr
console.log(f("short short short pause short short short")); // => Rr - Rr - Rr - - - Rr - Rr - Rr
console.log(f("long short short long long pause short short")); // => Rrrr - Rr - Rr - Rrrr - Rrrr - - - Rr - Rr
स्निपेट का विस्तार करें

— जोहान कार्लसन
स्रोत
7

05AB1E , 33 27 25 21 बाइट्स

#εÇн6&'m×™'-)éθ}… - ý

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

व्याख्या

#                       # split input on spaces
 ε             }        # apply to each
  Çн                    # get the character code of the head
    6&                  # AND with 6
      'm×               # repeat "m" this many times
         ™              # title case
          '-)           # wrap in a list with "-"
             éθ         # get the longest string       
                … - ý   # join to string using " - " as separator

मैलाडीफ़िश के पाइके उत्तरAND 6 से चाल का उपयोग करके 3 बाइट्स सहेजे गए

— Emigna
स्रोत
6

पायथन 2 , 76 69 64 बाइट्स

lambda s:' - '.join('Rrrr'[:ord(b[0])&6]or'-'for b in s.split())

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

alternates:

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

lambda s:' - '.join(['Rrrr','-','Rr'][ord(b[1])%3]for b in s.split())

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

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

lambda s:' - '.join('-Rrrr'['o'in b:8-ord(b[1])%9]for b in s.split())

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

— TFeld
स्रोत
4

आर , 77 बाइट्स

cat(c('Rrrr','Rr','-')[match(scan(,''),c('long','short','pause'))],sep=' - ')

STDIN के माध्यम से इनपुट लेता है, जाँच करता है कि इनपुट से मेल खाता है long, shortया pauseऔर स्वैप के लिए मैच Rrrr, Rrया -क्रमशः।

यह तब -विभाजक के रूप में रिक्त स्थान के साथ गद्देदार के साथ मुद्रित किया जाता है, वांछित आउटपुट से मेल खाता है।

— JAD
स्रोत
आप मैच से% में स्विच करके 2 बाइट्स बचा सकते हैं:scan(,'') %in% c('long','short','pause')
— YCR
@ आप मुझे नहीं लगता कि यह काम करेगा। a %in% bजाँच करता है कि क्या प्रविष्टियाँ aमौजूद हैं b, जबकि match(a, b)मैचों के वास्तविक सूचकांकों को लौटाता है। चूँकि हम यह मान सकते हैं कि इनपुट वैध है, इसलिए एस का %in%एक वेक्टर वापस आ जाएगा TRUE।
— JAD
सच, सच मैंने इसे सी ('लंबी', 'शॉर्ट', 'पॉज़') के साथ परीक्षण किया है।
— YCR
ऐसा इसलिए है क्योंकि जब आप एक बूलियन वेक्टर खिलाते हैं [, तो इसकी व्याख्या की जाती है [which(bool) == TRUE], जो आपके उदाहरण में होगी [c(1,2,3)], जो सही आउटपुट देने के लिए होती है।
— JAD
इसके बजाय sep=' - 'आप s=' - '2 बाइट्स कम उपयोग कर सकते हैं
— Rift
4

रोड़ा , 73 57 47 46 40 44 बाइट्स

f&a{a~=*`s\w+|l;Rr;ong;rr;p\w+;-; ; - `/";"}

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

नियम परिवर्तन के कारण +4 बाइट्स ( Rrrrकिसी भी 4 अक्षर संस्करण के बजाय उपयोग करना चाहिए )।

पिछला कोड:

{[[split()|["Bzzz"]if[_="long"]else["Bz"]if[_1="short"]else["-"]]&" - "]}
— fergusq
स्रोत
उपयोग करना Mmmऔर Mm1 बाइट छोटा है।
— ATaco
@ATaco इस सवाल में कहा गया है कि "लंबी ध्वनियां 4 वर्णों की लंबी होनी चाहिए, और छोटी ध्वनियों की लंबाई 2 वर्णों वाली होनी चाहिए" ।
— fergusq
ATaco, कृपया ध्यान दें कि मानदंड को प्रश्न में आगे निर्दिष्ट किया गया है।
— टिस्काकुंड्रम
4

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

-2 बाइट्स Scepheo को धन्यवाद!
Cyte के लिए -1 बाइट धन्यवाद!

एक इनपुट के रूप में एक पूर्ण समाप्त ** चार या समकक्ष लेता है।

f(char**a){for(;*a;*++a&&printf(" - "))printf(**a&6?**a&1?"Rr":"Rrrr":"-");}

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

स्पष्टीकरण: 

f(char**a){
  // While the string at the current position is not NULL
  for(;*a;
    // Advances the pointer to the next string
    // Then if the current string is not NULL, prints a delimiter
    *++a&&printf(" - ")
  )
    /* 
      If the 1st char of the string is not a 'p'
        If the 1st char is not a 'l'
          Prints "Rr"
        Else
          Prints "Rrrr"
      Else:
        Prints "-"
     */
    printf(**a&6?**a&1?"Rr":"Rrrr":"-");
}
— scottinet
स्रोत
2
मुझे लगता है कि आप को जोड़ सकते हैं a++,*aमें *++aदो बाइट्स बचाने के लिए, और प्रयोग करने में अस्पष्ट "ध्वनि" परिभाषा का लाभ लेने के *aबजाय "Rrrr"एक और चार बाइट्स को बचाने के लिए।
— Scepheo
आपका दूसरा सुझाव प्रतिभाशाली है!
— स्कूटनीट
1
क्या आप अल्पविराम से अलग होने के बजाय शरीर के लिए लूप के वेतन वृद्धि के हिस्से को स्थानांतरित कर सकते हैं?
— साइओस
यह वास्तव में एक बाइट बचाता है। अच्छी पकड़!
— स्कूटनीट
3

बैच, 88 बाइट्स

@set/ps=
@set s=%s: = - %
@set s=%s:long=Rrrr%
@set s=%s:short=Rr%
@echo %s:pause=-%

STDIN पर इनपुट लेता है। दुर्भाग्य से लूप ओवरहेड की लागत 26 बाइट्स होती है, इसलिए यह सिर्फ उबाऊ प्रतिस्थापन है।

— नील
स्रोत
2
@
— स्टीफन
@ स्टीफन हां, मुझे नोटिफिकेशन मिला ...
— नील
अच्छा! बस दो बातें, हालांकि: मुझे लगता है कि इस सवाल का जवाब गिना 84 बाइट्स लंबे, 88. इसके अलावा नहीं, ओपी की जगह है होना करने के लिए Mmmmऔर Mmसाथ Rrrrऔर Rr, यह अच्छा होगा यदि आपका जवाब ग अद्यतन करने के लिए:
— माथिउस Avellar
क्या मंच के रूप में बैच? मुझे संदेह है कि MS-DOS 6.22 बढ़ाया कमांड मोड में XP क्या करता है।
— TOOGAM
@TOOGAM हाँ, जब मैं कहता हूँ बैच मैं आमतौर पर Windows NT के CMD.EXE संस्करण का मतलब है।
— नील
2

PHP, 113 बाइट्स

<?$s=[];for($i=1;$i<$argc;$i++){$c=$argv[$i][0];$s[]=($c<'m')?'Rrrr':(($c<'q')?'-':'Rr');}echo implode(' - ',$s);

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

कोड गोल्फ में पहला प्रयास, इसलिए शायद बहुत सारे अनुकूलन उपलब्ध हैं!

— crazyloonybin
स्रोत
2

विम (52 बाइट्स)

:s/long/Rrrr/ge|s/short/Rr/ge|s/pause/-/ge|s/ / - /gदर्ज

शायद कम किया जा सकता है ...

— डेविड हेमैन
स्रोत
आदेशों को एक साथ इस तरह से रोकना ट्रेन को रोक देता है यदि उनमें से कोई IE में त्रुटि करता है यदि दिए गए स्ट्रिंग में कोई ठहराव या कुछ नहीं है, तो असफल होने के बाद के प्रतिस्थापन काम नहीं करेंगे। आप या तो उन्हें अलग लाइनों पर विभाजित कर सकते हैं या eअंत में एक झंडा लगा सकते हैं
— nmjcman101
त्रुटि ठीक की। मुझे अभी भी लगता है कि इसे गति देने के लिए कोई रास्ता होना चाहिए, लेकिन एक और तरीका है जिसके बारे में मैंने सोचा था (एक डैश में "ठहराव" को मोड़ने के s/[^ -]/r/बाद, प्रत्येक स्थान के बाद पहले R को बड़ा करें, चार-r को टू-आर ट्रिम करें) लंबे समय तक बाहर आया।
— डेविड हेमैन
1

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

=REPLACE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,"long","- Bzzz"),"short","- Bz"),"pause","- -"),1,2,"")

उदाहरण के अनुसार, इनपुट SPACEअलग स्ट्रिंग है, जैसा कि आउटपुट है।

प्रश्न स्वयं एक SPACEआवश्यकता का उल्लेख नहीं करता है , थोड़ा कम 97 बाइट समाधान के लिए अनुमति देता है :

=REPLACE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,"long","-Bzzz"),"short","-Bz"),"pause","--"),1,1,"")
— Wernisch
स्रोत
1

ऑटो इट , 145 बाइट्स

EXECUTE(STRINGREPLACE('MSGBOX(0,0,STRINGSTRIPWS(====INPUTBOX(0,0),"PAUSE",""),"LONG","Rrrr"),"SHORT","Rr")," "," - "),4))',"=","STRINGREPLACE("))

(AutoIt कोड गोल्फ के लिए वास्तव में बुरा विकल्प है, इसे यथासंभव छोटा बनाने की पूरी कोशिश की)

— अलगीरदास बटुक
स्रोत
साइट पर आपका स्वागत है! :)
— जेम्स
1

ऐलिस , 37 बाइट्स

/ lRnrhR
\""orgrp-""!yi'."?-e"ySNo?@/

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

व्याख्या

यह कार्यक्रम निम्नलिखित विकल्प बनाता है:

  • l, h→R
  • o, n, g→r
  • p → -
  • अंतरिक्ष → अंतरिक्ष
  • बाकी सब → कुछ भी नहीं
"longhp "!i.?eyN?"RrrrR- "y' " - "So@

"longhp "    Push this string
!            Immediately move to tape
i            Take input string
.            Duplicate
?ey          Remove all instances of the characters "longhp " from copy
N            Remove the remaining characters from the original, leaving only "longhp "
?"RrrrR- "y  Replace the characters in "longhp " with the corresponding characters in "RrrrR- "
' " - "S     Replace all spaces with " - "
o            Output
@            Terminate
— Nitrodon
स्रोत
1

सेड, 50 बाइट्स

से इनपुट करता है stdin, प्रिंट करता हैstdout

s/l\w*/Rrrr -/g
s/s\w*/Rr -/g
s/p\w*/- -/g
s/ -$//

संपादित करें - 2 बाइट्स सहेजे गए

सैड, 40 बाइट्स

नाइट्रोडॉन के जवाब से विचार की नकल करना

s/[srtaue]//g
y/lhongp/RRrrr-/
s/ / - /g

संपादित करें: एक और 2 बाइट्स को बचाया

— जॉन गोवर्स
स्रोत
0

पारदोक (v0.2.10), 21 बाइट्स (CP-1252)

Wμ‹6&'r\°"-":Ãu}« rTc

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

स्टैक पर एक स्ट्रिंग लेता है और स्टैक पर एक स्ट्रिंग में परिणाम होता है। एसटीडीआईएन iसे पढ़े जाने वाले एक पूर्ण कार्यक्रम में बदलने का नाटक करें।

पाइके उत्तर और बाकी सभी की &6तरह उपयोग करता है, लेकिन प्रत्येक शोर के बाद एक टोकन जोड़कर , पिछले एक को हटाकर, और फिर इन टोकन को रिक्त स्थान से जोड़कर टोकन को थोड़ा अलग ढंग से जोड़ देता है । से जुड़ने पर एक बाइट बचाने के लिए लगता है ।"-"" - "

स्पष्टीकरण:

W                     .. Break into words
 μ             }      .. Map over this block:
  ‹                   .. Take the first character
   6&                 .. Binary AND with 6, to get 4, 2, or 0
     'r               .. Character "r"
       \              .. Swap top two of stack
        °             .. Replicate, to get "rrrr", "rr", or ""
         "-"          .. Push string "-"
            :         .. Duplicate on stack
             Ã        .. Compute the max...
              u       .. ... underneath the top of the stack (so, of the
                      .. second and third elements on the stack, i.e. the
                      .. string of "r"s and "-")
                      .. The mappped block ends here; we now have
                      .. something like ["rrrr", "-", "-", "-", "rr", "-"]
                «     .. Take all but the last
                  r   .. Join with spaces (this built-in's name is two
                      .. characters, the first of which is a space)
                   Tc .. Title-case

v0.2.11 के \°साथ xऔर "-"साथ दो शेविंग बाइट्स का समर्थन करेगा '-।

— betaveros
स्रोत
0

रूबी , 67 बाइट्स

p ARGV[0].split(' ').map{|w|w<'m'?'Rrrr':w<'q'?'-':'Rr'}.join ' - '

यह जोहान कार्ल्ससन का जावास्क्रिप्ट समाधान रूबी के लिए रखा गया है। यदि आपको यह उत्तर पसंद है, तो आपको जोहान के उत्तर को बढ़ा देना चाहिए।

मुख्य विचार 'short'शब्दों के बीच अंतर करने के लिए शब्द के तार आदि की तुलना किसी एक वर्ण से करना है।

| Word  | < 'm' | < 'q' | Output |
|-------|-------|-------|--------|
| short | false | false | 'Rr'   |
| long  | true  | N/A   | 'Rrrr' |
| pause | false | true  | '-'    |

या, वर्णमाला क्रम में:

  • लंबा
  • म
  • ठहराव
  • क्ष
  • कम

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

— alexanderbird
स्रोत
0

रूबी , 78 बाइट्स

p ARGV[0].chars.map{|c|{p:'-',o:'Rr',g:'rr',' '.to_sym=>' - '}[c.to_sym]}.join

इनपुट के केवल महत्वपूर्ण हिस्से हैं p, o, g, और अंतरिक्ष ... बाकी की उपेक्षा।

  • short हो जाता है o
  • long हो जाता है og
  • pause हो जाता है p

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

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