समय निर्धारित करना

27

निम्नलिखित 24-घंटे की घड़ी की कल्पना करें जिसे तीर कुंजी द्वारा नियंत्रित किया जा सकता है:

╔══╗ ┌──┐
║00║:│00│
╚══╝ └──┘
 HH   mm

दो बार ऊपर तीर दबाने से ( ↑↑वर्तमान में केंद्रित घंटा इनपुट बढ़ जाएगा:

╔══╗ ┌──┐
║02║:│00│
╚══╝ └──┘
 HH   mm

दायां तीर ( →) दबाकर दूसरे इनपुट पर ध्यान केंद्रित किया जाएगा।

┌──┐ ╔══╗
│02│:║00║
└──┘ ╚══╝
 HH   mm

तीन बार डाउन एरो दबाने पर ( ↓↓↓) अब इस इनपुट में कमी आएगी।

┌──┐ ╔══╗
│02│:║57║
└──┘ ╚══╝
 HH   mm

कुछ ही समय में:

  • अप एरो ( ↑) वर्तमान में सक्रिय इनपुट को बढ़ाएगा।
  • डाउन एरो ( ↓) सक्रिय इनपुट को कम करेगा।
  • सही तीर ( →) सही इनपुट पर ध्यान केंद्रित करेगा।
  • बायाँ तीर ( ←) बाएँ इनपुट पर फ़ोकस करेगा।
  • अप और डाउन मूवमेंट एक समय इनपुट के लिए अपेक्षित के आसपास लूप करेगा।
  • बाएँ और दाएँ आंदोलन चारों ओर लूप नहीं है।

चुनौती

घड़ी 00:00घंटे इनपुट सक्रिय (पहली योजनाबद्ध देखें) के साथ शुरू होती है । इनपुट आदेशों की एक सूची को देखते हुए, परिणामी समय को HH:mmप्रारूप में आउटपुट करें ।
इनपुट या तो एक स्ट्रिंग या एक सूची (या आपकी भाषा समतुल्य) हो सकती है, जहां विभिन्न इनपुट निर्देश नीचे दिए गए विकल्पों में से एक हो सकते हैं:

  • ↑↓←→
  • udlr
  • ^v<>
  • यदि आपके प्रोग्राम में GUI है तो वास्तविक एरो की दबाएं

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

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

↑↑→↓↓↓ = 02:57
↓→↑←↑→↓ = 00:00
↓→→↓ = 23:59
←←←←→↑ = 00:01
↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓→↓ = 23:59
code-golf  date 
— लीख
स्रोत
1
@JonathanFrech दिए गए विकल्पों में से एक, किसी भी चार अद्वितीय मूल्यों (उदाहरण के लिए 0123) को चुनना, कुछ भाषाओं में चुनौती को आसान बना देगा, जबकि दूसरों को लाभ नहीं पहुंचाएगा।
— लीख
1
@LuisfelipeDejesusMunoz हाँ, यह वास्तव में इनपुट नियमों के तहत लिखा गया है।
— लीख
3
मुझे लगता है कि अगर इसे सेकंड शामिल किया जाता तो यह और अधिक चुनौतीपूर्ण होता। इसके पीछे और भी तर्क होंगे, जिनमें से एक इस समय फ़ोकस में है
— जो किंग
3
कोनमी कोड को संभालने के लिए एक विशेष नियम को याद करना।
— coredump
1
@ कॉर्डम्प ने इसे माना, लेकिन यह संभवतः अधिकांश भाषाओं में उत्तर के मूल से अधिक स्थान लेगा।
— लीख

जवाबों:

39

चीनी में गूगल क्रोम 67 पर HTML (सरलीकृत), 39 बाइट्स

<input type=time value=00:00 autofocus>
स्निपेट का विस्तार करें

स्क्रीनशॉट

Chrome विभिन्न भाषा में अलग-अलग UI घटक दिखाता है। यहां तक ​​कि एक साधारण समय इनपुट: एएम / पीएम दिखाया जाएगा यदि आप अंग्रेजी (यूएस) का उपयोग कर रहे हैं। यदि आप अपने Chrome की भाषा को बदलकर यह परीक्षण करना चाहते हैं। इसे वापस बदलने के लिए बड़े पैमाने पर मत करो।

— TSH
स्रोत
2
dudee !! हाहा मुझे लगता है कि वैध नहीं है
— लुइस फेलिप डी जीसस मुनोज
2
दो बार सही AM/PM
— जो किंग
1
@JoKing मुझे लगता है कि यह लोकेल / सेटिंग्स पर निर्भर है?
— लीख
1
@JoKing यह स्थानीय निर्भर है। हो सकता है कि आपकी Chrome की भाषा को चीनी सरलीकृत करने के लिए कोई परिवर्तन किया गया हो? (इसे वापस बदलने के लिए बड़े पैमाने पर मत करो।)
— tsh
1
यह फ़ायरफ़ॉक्स 61.0.1
— फ्रांसिस्को हैन
12

सी (जीसीसी) , 117 107 बाइट्स

t,i,m[8];e(char*_){for(*m=i=2[m]=0;t=*_++;t<63?i=t%4:(i[m]+=t&8?1:'w'));printf("%02d:%02d",*m%24,2[m]%60);}

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

— जोनाथन फ्रेच
स्रोत
4
अच्छा चर नामकरण।
— लीख
# सी (जीसीसी) , 107 बाइट्स <! - भाषा-ऑल: लैंग-सी -> t,i,m[8];e(char*_){for(*m=i=2[m]=0;t=*_++;t<63?i=t%4:(i[m]+=t&8?1:119));printf("%02d:%02d",*m%24,2[m]%60);} इसे ऑनलाइन आज़माएं!
— l4m2
6

स्टैक्स , 36 35 33 32 बाइट्स

áXò↑─↨√▓|êóÇiU&≡Q#┤Æ⌡⌠╟C▐╜√⌡∟▄╩╠

इसे चलाएं और डीबग करें

उपयोग करता है lrud।

स्पष्टीकरण:

'l/{'r/Bs$2lmM{${:14-m|+i36*24+%2|zm':* Full program,
'l/                                     Split the string on "l"
   {        m                           Map over the resulting array
    'r/                                   Split at "r"
       B                                  Uncons left, first on TOS (top of stack)
        s                                 Swap to get tail to top
         $                                Flatten; this removes multiple 'r's
          2l                              Listify two items, BOS (bottom of stack) is first element
             M                          Transpose: get [hour commands, minute commands]
              {                    m    Map:
               $                          Flatten
                {    m                    Map over single commands:
                 :1                         Number of set bits: 5 for 'u', 3 for 'd'
                   4-                       Subtract 4: u -> 1, d -> -1
                      |+                  Sum
                        i                 Iteration index: hours -> 0, minutes -> 1
                         36*24+           Multiply by 36, add 24: 0 -> 24, 1 -> 60
                               %          Modulo, this does -5 % 60 = 55
                                2|z       Stringify, left-padding with "0" to length 2
                                    ':* Join on ":"
                                        Implicit output
— wastl
स्रोत
5

सी # (.NET कोर) , 149 132 बाइट्स

s=>{var p=0;int[]h={0,0};foreach(var c in s)h[p=c<63?c/2%2:p]+=c>62?c>95?-1:1:0;return$"{(h[0]%24+24)%24:D2}:{(h[1]%60+60)%60:D2}";}

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

का उपयोग कर ^v<>।

इसने मुझे एहसास दिलाया कि C # में modulo ऑपरेटर अपेक्षा के अनुरूप काम नहीं करता है, क्योंकि C # में -1 % 60 = -1, इसलिए मुझे अंत में उस अजीब ऑपरेशन को करने की आवश्यकता है।

— चार्ली
स्रोत
(एच [१]% ६० + ६०)% ६० (एच [१] +६०)% ६० के साथ प्रतिस्थापित नहीं किया जा सकता है?
— IanF1
2
@ IanF1 नहीं आप नहीं कर सकते। क्या होगा यदि उपयोगकर्ता 100 बार डाउन बटन दबाए? या 1000 गुना?
— चार्ली
स्पष्ट करने के लिए धन्यवाद :) यह मेरे लिए आश्चर्य की बात है कि यह तरीका मक्खी पर मॉडुलो को लागू करने से कम है (-1 के स्थान पर 59 के साथ)।
— IanF1
5

लुआ (लव 2 डी फ्रेमवर्क), 311 308 बाइट्स

l,b,d,t,f,a=love,{24,60},{1,-1},{0,0},1,{"left","right","up","down"}function c(n,i)t[f]=(n+d[i])%b[f]end function l.draw()h,m=t[1],t[2]l.graphics.print((h<10 and 0 ..h or h)..":"..(m<10 and 0 ..m or m),0,0)end function l.keypressed(k)for i,n in pairs(a)do f=k==n and(i>2 and(c(t[f],i-2)or f)or i)or f end end

Unscrumbeled संस्करण:

--initialize all needed values
l,b,d,t,f,a=love,{24,60},{1,-1},{0,0},1,{"left","right","up","down"}

--increase the numbers depending on the focus and up or down
function c(n,i)
  t[f]=(n+d[i])%b[f]
end 

--draw the time to the screen
function l.draw()
  h,m=t[1],t[2]
  l.graphics.print((h<10 and 0 ..h or h)..":"..(m<10 and 0 ..m or m),0,0)
end

--get the keys and check if it is an arrow key
function l.keypressed(k)
  for i,n in pairs(a)do
    f=k==n and(i>2 and(c(t[f],i-2)or f)or i)or f 
  end 
end

शायद अभी भी 100% पढ़ने में आसान नहीं है क्योंकि सभी ifs एक ट्रिनिकल स्टेटमेंट (..और .. या) के साथ परस्पर जुड़े हुए हैं :)

यदि प्यार के साथ एक main.lua में शुरू किया गया है तो यह एक विंडो को पॉप करेगा और आप संख्याओं को बदलने के लिए एरोकी दबा सकते हैं

— Lycea
स्रोत
क्या आप पठनीयता के लिए विस्तारित संस्करण भी पोस्ट कर सकते हैं
— आआआआ कहते हैं कि मोनिका
यकीन है, मैं एक विस्तारित संस्करण जोड़ा कोई समस्या नहीं :)
— लाइकिया
4

MATL , 57 56 55 बाइट्स

1Oi9\"@5<?y@3-ZS*+}wx7@-X^w]]wx&Zjh24 60h\'%02d:%02d'YD

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

जटिल संख्याओं का उपयोग करके घंटे और मिनटों का प्रतिनिधित्व करता है, वास्तविक भाग घंटे और काल्पनिक भाग मिनट के साथ।

टिप्पणियों के साथ:

1     % Push 1 on the stack
      % represents which timer box we're in, starts at hour box
      % imaginary number j would represent minutes box
O     % Push initial hour and minutes 0+0j
i9\   % Fetch input, mod each character's ASCII value by 9.
      % Gives 4 1 8 6 for ^ v > < respectively
"     % iterate through (modded) input
  @5<?     % Push current input, see if it's < 5 
           % if so, it's an up or down time change
    y        % so copy out the box indicator (1 or j)
    @3-      % Subtract 3 from the current input
    ZS       % Take the result's sign (-1 for v, 1 for ^)
    *        % Multiply indicator with that
    +        % Add the result to the time value
  }        % else, it's a right or left arrow
    wx       % so bring out the box indicator and delete it
    7@-      % Subtract current input from 7. 1 for < and -1 for >
    X^       % Take the square root of that. 1 for < and j for >
    w        % switch stack to bring time value on top again
  ]       % end if
]     % end loop
wx    % bring box indicator out, delete it
&Zj   % split the complex time value to real and imaginary
h     % then concatenate them into an array
24 60h\ % mod hour and minute values by 24 and 60 respectively
'%02d:%02d'YD % sprintf the time array with 0-padding
— sundar - मोनिका को बहाल करना
स्रोत
4

PHP , 145 134 133 बाइट्स

(-11 बाइट्स द्वारा अधिक गोल्फिंग)

( डेविस लूप विधि का उपयोग करके -1 बाइट )

<?for($h=$m=0,$a=h;$c=$argv[++$i];)$c<l?$$a--:($c>r?$$a++:$a=$c<r?h:m);$h%=24;$m%=60;printf('%02d:%02d',$h<0?$h+24:$h,$m<0?$m+60:$m);

इसे चलाने के लिए:

php -n -d error_reporting=0 <filename> <command_1> <command_2> ... <command_n>

उदाहरण:

php -n -d error_reporting=0 time_setter.php u u r d d d l d

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

टिप्पणियाँ:

  • कुछ बाइट्स को बचाने के लिए, मैंने स्ट्रिंग आवरण के रूप में सिंगल / डबल कोटेशन के बिना स्ट्रिंग्स का उपयोग किया है। इस प्रकार, error_reporting=0विकल्प का उपयोग आउटपुट चेतावनियों को नहीं करने के लिए किया जाता है।
  • इनपुट आदेश: u d l r
— Night2
स्रोत
128 बाइट्स; -6: इसे ऑनलाइन आज़माएं! (अच्छा समाधान, btw :)
— डेब्यू
@ डेविड: धन्यवाद, लेकिन आपके अपडेट में दो मुद्दे हैं। पहली बात यह है कि $ h सेट नहीं है, इसलिए इसे कम करना शुरू करने में विफल रहता है: इसे ऑनलाइन आज़माएं!
— नाइट 2
@ डेविड: और दूसरा मुद्दा तब होता है जब हम घंटे / मिनट को 24/60 बार से अधिक या नीचे स्विच करते हैं: इसे ऑनलाइन आज़माएं!
— नाइट 2
@ डेविड: लेकिन आपके पाश विधि के लिए धन्यवाद, मैं 1 और बाइट को कम कर सकता हूं: इसे ऑनलाइन आज़माएं!
— रात 2
आह, ठीक है, खेद है कि यह पूरी तरह से काम नहीं किया :)
— 9
4

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

उपयोग करके वर्णों की एक सरणी के रूप में इनपुट लेता है <>^v।

a=>(a.map(z=>z<"^"?a=z<">":a?x+=z<"v"||23:y+=z<"v"||59,x=y=0),g=n=>`0${n}`.slice(-2))(x%24)+`:`+g(y%60)

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

— झबरा
स्रोत
3

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

f=u 0 0
k _ _ _ _ _ h m[]=z h++':':z m
k a b c d e h m(q:s)=case q of{'^'->e(a h)(b m)s;'v'->e(c h)(d m)s;'>'->v h m s;'<'->u h m s}
u=k(o(+)24)id(o(-)24)id u
v=k id(o(+)60)id(o(-)60)v
o f m x=mod(f x 1)m
z n|n<10='0':show n
z n=show n

fमुख्य कार्य है, और इसका प्रकार है String -> String:

*Main> f "^^>vvv"
"02:57"
*Main> f "v>^<^>v"
"00:00"
*Main> f "v>>v"
"23:59"
*Main> f "<<<<>^"
"00:01"
*Main> f "vvvvvvvvvvvvvvvvvvvvvvvvv>v"
"23:59"

अनिवार्य रूप से uऔर vप्रकार के पारस्परिक रूप से पुनरावर्ती कार्य हैं Integer -> Integer -> String -> String। वे सेट पर घंटे, मिनट और पात्रों की एक सूची लेते हैं {v,^,<,>}, और समय स्ट्रिंग लौटाते हैं। uयह मानकर चलता है कि यदि uसूची के प्रमुख में है {v,^}, और vयदि सूची का प्रमुख है , तो घंटे डायल को हाइलाइट किया जाता है {<,>}। vसमान है, लेकिन मिनट डायल के लिए।

बाकी सब कुछ सिर्फ पात्रों को बचा रहा है।

— AlexJ136
स्रोत
3

लूआ , 132 बाइट्स

loadstring's,t,m=1,{0,0},{24,60}for c in(...):gmatch"."do t[s]=(t[s]+(("d u"):find(c)or 2)-2)%m[s]s=("lr"):find(c)or s end return t'

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

व्याख्या

यह एक अनाम फ़ंक्शन है (इसका उपयोग करने का एक तरीका लिंक पर दिखाया गया है)।

s=1 -- s will control the selection (1 is hour and 2 min)
t={0,0} -- is the time itself
m={24,60} -- is the maximum for each 'box' (hour or min)
-- I've actually used Lua's multiple variable assignment: s,t,m=1,{0,0},{24,60}

for c in (...):gmatch(".") do -- go through each character of the input
  t[s] = (t[s] + (("d u"):find(c) or 2)-2) % m[s] -- set the current 'box' as
          t[s] +   -- itself plus ...
                  ("d u"):find(c) or 2   -- it's index on the string "d u" (that means it's going to be 1 or 3)
                                         -- or 2 if it wasn't found (if the current character doesn't sum or subtract from the box)
                                       -2   -- this adjusts the result 1, 2 or 3 to being -1, 0 or 1
                                            -- making the inputs 'd' and 'u' as -1 and +1 respectively, and an input different from both as 0
         (                               ) % m[s]   -- modulo of the maximum of the selected 'box'

  s=("lr"):find(c) or s
    ("lr"):find(c)   -- if the current input character is l or r, then set 's' (the 'box' selection) to being 1 or 2.
                   or s   -- else let it as is
end
return t -- returns 't', a table with hour and minutes respectively
— Visckmart
स्रोत
आउटपुट HH:mmतालिका के बजाय प्रारूप में होना चाहिए
— जो किंग
2

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

मेरा मानना ​​है कि O%5;4ṣ3œṡ€4Z%3’§§%"“ð<‘DŻ€ṫ€-j”:32 के लिए काम करना चाहिए, लेकिन œṡ लगता है कि वर्तमान में एक बग है ।

O%5;4ṣ3i€4$œṖ"$Z%3’§§%"“ð<‘DŻ€ṫ€-j”:

STDOUT के परिणाम को मुद्रित करने वाला एक पूरा कार्यक्रम (एक विवादास्पद लिंक के रूप में यह वास्तव में पूर्णांक (एकल अंक वाले) और पात्रों () की मिश्रित सूची देता है :।

udlrइनपुट के लिए विकल्प का उपयोग करता है ।

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें ।

कैसे?

O%5;4ṣ3i€4$œṖ"$Z%3’§§%"“ð<‘DŻ€ṫ€-j”: - Link: list of characters (in 'udlr')
O                                    - to ordinals
 %5                                  - modulo five  ...maps u:2, d:0, l:3, r:4
   ;4                                - concatenate a 4 (to always end up with both hrs & mins - even when no r is ever pressed)
     ṣ3                              - split at threes (the l presses)
       i€4$œṖ"$                      - a replacement for œṡ€4 (split each at first occurrence of)...
              $                      - | last two links as a monad:
          $                          - |   last two links as a monad:
         4                           - |     literal four
       i€                            - |     for €ach get first index of (4) else yield 0
             "                       - |   zip with:
           œṖ                        - |     partition at indices
               Z                     - transpose (to get a list of two lists of lists)
                %3                   - modulo by three. To replace any 4(r) with 1
                                     -  ...while keeping any 0(d) as 0, or 2(u) as 2
                  ’                  - decrement. All r are now 0, d are -1 and u are 1
                   §                 - sum each
                    §                - sum each. Now we have the total increase value as
                                     -    ...integers for each of hrs and mins
                       “ð<‘          - code-page indices list = [24,60]
                      "              - zip with:
                     %               -   modulo
                           D         - to decimal lists
                            Ż€       - prepend each with a zero (to cater for values less than ten)
                              ṫ€-    - tail each from index -1. Keeps rightmost two digits of each only)
                                  ”: - literal character ':'
                                 j   - join
                                     - as full program implicit print (smashes the digits and characters together)
— जोनाथन एलन
स्रोत
2

QBasic , 229 बाइट्स

एक स्क्रिप्ट जो किस्ट्रोक्स के रूप में इनपुट लेती है और कंसोल को आउटपुट करती है।

नोट: टर्मिनल "सिंटैक्स हाइलाइटिंग के लिए ही शामिल है, और बायटेकाउंट में योगदान नहीं करते हैं 

z$=CHR$(0)
DO
x=0
y=0
SELECT CASE INKEY$
CASE z$+"K"
r=0
CASE z$+"M"
r=1
CASE z$+"H"
x=1
y=1
CASE z$+"P"
x=23
y=59
END SELECT
IF r THEN m=(m+y)MOD 60ELSE h=(h+x)MOD 24
CLS
?RIGHT$("00000"+LTRIM$(STR$(h*1000+m)),5)
LOCATE 1,3
?":"
LOOP

टिप्पणी की गई

z$=CHR$(0)                                      ''  Set var to null char
DO                                              ''
    x=0                                         ''  Set Hours Shift to 0 
    y=0                                         ''  Set Minutes Shift to 0 
    SELECT CASE INKEY$                          ''  Take keystroke input
        CASE z$+"K"                             ''  If is Left Arrow
            r=0                                 ''    Bool to modify right (minutes) 
        CASE z$+"M"                             ''  If is Right Arrow
            r=1                                 ''    Bool to modify left (hours)
        CASE z$+"H"                             ''  If is Up Arrow
            x=1                                 ''    Set Hours Shift to 1 
            y=1                                 ''    Set Minutes Shift to 1
        CASE z$+"P"                             ''  If is Down Arrow
            x=23                                ''    Set Hours Shift to 23 
            y=59                                ''    Set Minutes Shift to 23 
    END SELECT                                  ''
    IF r THEN m=(m+y)MOD 60ELSE h=(h+x)MOD 24   ''  Shift Minutes If `r=1` Else Shift Hours
    CLS                                         ''  Clear Screen
    ?RIGHT$("00000"+LTRIM$(STR$(h*1000+m)),5)   ''  Use math to concat Hours and Minutes 
                                                ''  then Convert to String and prepend 0s 
                                                ''  to a length of 5
    LOCATE 1,3                                  ''  Cursor to the the third digit
    ?":"                                        ''  Overwrite that digit with a `:`
LOOP                                            ''  Loop
— टेलर स्कॉट
स्रोत
1
ऐसा नहीं होना चाहिए (m+y)?
— नील
नोट में, नहीं करना चाहिए करता जा कर ?
— जोनाथन फ्रेच
@JonathanFrech - हां यह होना चाहिए। मेरे व्याकरण को जाँच में रखने के लिए धन्यवाद
— टेलर स्कॉट
क्षमा करें, मुझे लगा कि mकिसी कारण से मिनटों के लिए था ... मुझे लगता है कि आपका टिप्पणी संस्करण अधिक पठनीय है।
— नील
2

पॉवरशेल, 109 103 बाइट्स

-6 बाइट धन्यवाद AdmBorkBork

$t=0,0
$args|%{$t[+$i]+=. @{l={$i=0};r={$i=1};u={1};d={119}}.$_}
"{0:00}:{1:00}"-f($t[0]%24),($t[1]%60)

टेस्ट स्क्रिप्ट:

$f = {

$t=0,0
$args|%{$t[+$i]+=. @{l={$i=0};r={$i=1};u={1};d={119}}.$_}
"{0:00}:{1:00}"-f($t[0]%24),($t[1]%60)

}

@(
    ,('02:57',('u','u','r','d','d','d'))
    ,('00:00',('d','r','u','l','u','r','d'))
    ,('23:59',('d','r','r','d'))
    ,('00:01',('l','l','l','l','r','u'))
    ,('23:59',('d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','r','d'))
) | % {
    $e, $c = $_
    $r = &$f @c
    "$($r-eq$e): $r"
}

आउटपुट:

True: 02:57
True: 00:00
True: 23:59
True: 00:01
True: 23:59

व्याख्या

मूल विचार एक का उपयोग करना है [hashtable], जो keysनियंत्रण आदेश हैं और valuesस्क्रिप्टब्लॉक हैं। कोड तर्कों से प्रत्येक कमांड के लिए स्क्रिप्टब्लॉक निष्पादित करता है।

— Mazzy
स्रोत
1
आप कुछ बाइट्स को बचाने के लिए $i=0अपने ऐरे इंडेक्स को डालकर छुटकारा पा सकते हैं $t[+$i]। इसे ऑनलाइन आज़माएं!
— AdmBorkBork
1

perl -F // -E, 72 बाइट्स

$x=H;/u/?$$x++:/d/?$$x--:($x=/l/?H:M)for@F;printf"%02d:%02d",$H%24,$M%60
1

अजगर, 120 बाइट्स

o,i=[0,0],0
for s in list(input()):i=(i+(s=='r')-(s=='l')>=1);o[i]+=(s=='u')-(s=='d')
print'%02d:%02d'%(o[0]%24,o[1]%60)
— आआआआ कहती है मोनिका को बहाल करो
स्रोत
यह एक चर में स्निपेट लेने वाले इनपुट की तरह दिखता है। एक सामान्य नियम के रूप में, हमें या तो एक पूर्ण कार्यक्रम (प्रोग्राम तर्क या मानक इनपुट से इनपुट लेना) या एक फ़ंक्शन (फ़ंक्शन मापदंडों से इनपुट लेना) प्रस्तुत करने की आवश्यकता होती है।
— OOBalance
1
इसके अलावा, जब कोई इनपुट, कहना, ldया रेंज (0,1) छोड़ने का rruकारण बनता है , तो इसे दीवार में नहीं चलाया जाएगा iऔर o[i]बाद में एक्सेस किया जाएगा?
— OOBalance
@OOBalance ओह मुझे याद दिलाने के लिए धन्यवाद कि आपको फंक्शन चाहिए या unput()। आवश्यकताओं से मुझे लगा कि L और R क्रियाएँ कभी नहीं टिकी होंगी (यानी नहीं LL)
— आआआआ कहती हैं मोनिका
@aaaaaa कोई भी लूपिंग साधन lllसमान नहीं है r। बीत रहा है llया rrमान्य इनपुट है, यह परीक्षण मामलों में भी है, उदाहरण के लिए तीसरा देखते हैं।
— लीख
इस जवाब में वर्तमान में आउटपुट के बजाय तीसरे परीक्षण मामले पर एक IndexError है 23:59। इसे ऑनलाइन आज़माएं!
— 0 '
1

आर, 368 355 बाइट्स

f=function(){C=as.character
i=ifelse
p=paste0
r=1:10
h=C(0:23);m=C(0:59)
h[r]=p(0,h[r])
m[r]=p(0,m[r])
x=y=z=1
while(T){print(p(h[x],":",m[y]))
v=1
n="[UDLRS]"
while(!grepl(n,v))v=toupper(readline(n))
if(v=="L")z=1 else if(v=="R")z=0
if(v=="S")T=F
if(v=="U")if(z)x=i(x==24,1,x+1)else y=i(y==60,1,y+1)
if(v=="D")if(z)x=i(x==1,24,x-1)else y=i(y==1,60,y-1)}}

निश्चित रूप से सबसे अच्छा तरीका नहीं है, लेकिन काम करता है।

कार्यक्षमता: रन फ़ंक्शन, प्रत्येक अक्षर को (in / de) क्रीज पर ले जाएं या बाएं / दाएं ले जाएं, "s" टाइप करने से "गेम" समाप्त होता है। पकड़ यह है कि यह एक बार में एक और केवल एक अक्षर को स्वीकार करेगा।

-13 बाइट्स ने एक पंक्ति में कुछ मानों को समेकित किया, ब्रेक का उपयोग करने के बजाय T के रूप में T को ओवरवोट किया, समाप्त करने के लिए कई रिक्त स्थान पाए, और इसके बजाय एक चर में संग्रहीत स्ट्रिंग

f=function(){C=as.character                             # Abbreviate functions
i=ifelse
p=paste0
r=1:10                                                  # Initialize and format values
h=C(0:23);m=C(0:59)
h[r]=p(0,h[r])
m[r]=p(0,m[r])
x=y=z=1
while(T){print(p(h[x],":",m[y]))                        # Begin while loop and print time
v=1                                                     # Initial value reset each iteration to retrieve a new direction
n="[UDLRS]"                                             # Used for verification and request
while(!grepl(n,v))v=toupper(readline(n))                # Will only accept proper directions or stopping rule
if(v=="L")z=1 else if(v=="R")z=0                        # Evaluate for hour or minute
if(v=="S")T=F                                           # Stopping rule, overwrite True to False
if(v=="U")if(z)x=i(x==24,1,x+1)else y=i(y==60,1,y+1)    # Rules for Up
if(v=="D")if(z)x=i(x==1,24,x-1)else y=i(y==1,60,y-1)}}  # Rules for Down

मैं आर स्ट्रिंग और / या वेक्टर को स्वीकार करने के लिए एक वैकल्पिक प्रारूप भी संपादित कर रहा हूं, अगले सप्ताह पोस्ट करूंगा।

— Sumner18
स्रोत
1

SmileBASIC, 123 बाइट्स

@L
B=BUTTON(2)D=(B==1)-(B==2)S=S+!S*(B>7)-S*(B==4)H=(H+D*!S+24)MOD 24WAIT
M=(M+D*S+60)MOD 60?FORMAT$("%02D:%02D",H,M)GOTO@L

BUTTON() एक पूर्णांक देता है जहां प्रत्येक बिट एक बटन का प्रतिनिधित्व करता है

1 = up
2 = down
4 = left
8 = right
...

BUTTON(2) केवल वही बटन लौटाता है जो सिर्फ दबाया गया था (आयोजित नहीं किया जा रहा)

WAITआवश्यक है क्योंकि BUTTONकेवल एक बार प्रति फ्रेम (एक सेकंड का 1/60) अपडेट होता है। अन्यथा एक ही बटन प्रेस कई बार पता लगाया जाएगा।

यह निश्चित रूप से कम हो सकता है

— 12Me21
स्रोत
0

05AB1E , 38 37 बाइट्स

'l¡ε'r¡}0ζćs˜‚€S„udS1®‚:OŽ9¦2ä%T‰J':ý

udlrनिर्देशों के लिए उपयोग करता है , लेकिन ^v<>एक ही बाइट-काउंट के लिए भी उपयोग कर सकता है (वर्ण ↑↓←→05AB1E के कोडपेज का हिस्सा नहीं हैं, इसलिए उन का उपयोग करके बाइट-काउंट को बहुत बढ़ा दिया जाएगा, क्योंकि एन्कोडिंग को ASCII में बदल दिया जाना चाहिए)।

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

स्पष्टीकरण:

'l¡            '# Split the (implicit) input on "l"
                #  i.e. "lllrurulddd" → ["","","","ruru","ddd"]
   ε   }        # Map each item to:
    'r¡        '#  Split the item on "r"
                #   i.e. ["","","","ruru","ddd"] → [[""],[""],[""],["","u","u"],["ddd"]]
        0ζ      # Zip/transpose; swapping rows/columns, with "0" as filler
                #  i.e. [[""],[""],[""],["","u","u"],["ddd"]]
                #   → [["","","","","ddd"],["0","0","0","u","0"],["0","0","0","u","0"]]
ć               # Head extracted: pop and push the remainder and head-item to the stack
                #  i.e. [["","","","","ddd"],["0","0","0","u","0"],["0","0","0","u","0"]]
                #   → [["0","0","0","u","0"],["0","0","0","u","0"]] and ["","","","","ddd"]
 s              # Swap to get the remainder
  ˜             # Flatten it
                #  i.e. [["0","0","0","u","0"],["0","0","0","u","0"]]
                #   → ["0","0","0","u","0","0","0","0","u","0"]
   ‚            # Pair the head and remainder back together
                #  i.e. ["","","","","ddd"] and ["0","0","0","u","0","0","0","0","u","0"]
                #   → [["","","","","ddd"],["0","0","0","u","0","0","0","0","u","0"]]
    €S          # Convert each item to a list of characters
                # (implicitly flattens and removes empty strings)
                #  i.e. [["","","","","ddd"],["0","0","0","u","0","0","0","0","u","0"]]
                #   → [["d","d","d"],["0","0","0","u","0","0","0","0","u","0"]]
      „udS1®‚:  # Replace all "u" with "1" and all "d" with "-1"
                #  i.e. [["d","d","d"],["0","0","0","u","0","0","0","0","u","0"]]
                #   → [["-1","-1","-1"],["0","0","0","1","0","0","0","0","1","0"]]
              O # Then take the sum of each inner list
                #  i.e. [["-1","-1","-1"],["0","0","0","1","0","0","0","0","1","0"]]
                #   → [-3,2]
Ž9¦             # Push compressed integer 2460
   2ä           # Split into two parts: [24,60]
     %          # Modulo the two lists
                #  i.e. [-3,2] and [24,60] → [21,2]
      T‰        # Divmod each with 10
                #  i.e. [21,2] → [[2,1],[0,2]]
        J       # Join each inner list together
                #  i.e. [[2,1],[0,2]] → ["21","02"]
         ':ý   '# Join the list with ":" delimiter
                #  i.e. ["21","02"] → "21:02"
                # (and output the result implicitly)

मेरा 05AB1E टिप देखें (अनुभाग में बड़े पूर्णांकों को कैसे संपीड़ित करें? ) यह समझने के लिए कि क्यों Ž9¦है 2460।

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