21

0 और 141 (सम्मिलित) के बीच एक पूर्णांक को देखते हुए, सभी 24-घंटे के समय की सूची दें, जिसका घंटा, मिनट और दूसरी इकाइयाँ उस पूर्णांक में जोड़ते हैं।

जोड़ के नियम

संख्याएँ उनकी समय इकाइयों द्वारा जोड़ी जाती हैं, एकल अंकों द्वारा नहीं।

उदाहरण के लिए, 17:43:59 लें

17 + 43 + 59 = 119

याद रखें, वह अंकों का एक उदाहरण है । वास्तव में, आप 119 में प्रवेश करेंगे, और 17:43:59 परिणाम में से एक होगा। आउटपुट को HH: MM: SS या H: MM: SS के रूप में दिया जाना चाहिए।

यह भी ध्यान रखें कि उच्चतम संख्या 141 है, जो 23:59:59 है। यह कोड गोल्फ है, इसलिए सबसे कम राशि जीतती है। परीक्षण और त्रुटि की अनुमति है, लेकिन इस बारे में जाने का एक बेहतर तरीका हो सकता है।

संपादित करें: कृपया निर्दिष्ट करें कि आपके कोड में इनपुट मान कहां है।

code-golf math

— नूह एल
स्रोत

3

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यदि आप में खामियों को दूर करने का मतलब है स्रोत कोड का हिस्सा बना है, तो यह आमतौर पर अस्वीकृत है। सामान्य तौर पर, यह उन डिफॉल्ट्स से चिपके रहने के लिए एक अच्छा विचार है। क्या हमें परिणाम को तार के रूप में प्रदर्शित करना है? यदि हां, तो किन स्वरूपों की अनुमति है?

— डेनिस

क्या सकारात्मक होने के लिए इनपुट नंबर की गारंटी है? कम से कम एक समाधान होगा?

— xnor

मैंने कुछ चीजों को स्पष्ट / उत्तर देने के लिए प्रश्न को थोड़ा संपादित किया है। अगर आपका इरादा मेरे बदलावों से अलग था, तो बेझिझक इसे मैच करने के लिए संपादित करें।

— जियोबिट्स

1

मैंने केवल इसलिए किया क्योंकि यह सामान्य तरीका है जिसे मैं बार (वास्तविक दुनिया में) दिया गया देखता हूं। कोई भी कभी नहीं कहता है कि यह 13: 4: 7 है, लेकिन 5:10:30 लगभग हमेशा स्वीकार्य है। मेरे पास इसे बदलने के साथ कोई समस्या नहीं है।

— जियोबिट्स

3

"कृपया निर्दिष्ट करें कि आपके कोड में इनपुट मूल्य कहां है।" - इनपुट लेने के लिए PPCG पर सम्मेलन तर्कों का उपयोग कर रहा है, साथ ही कुछ अन्य विकल्प भी। कोड गोल्फ के लिए डिफ़ॉल्ट देखें : मेटा पर इनपुट / आउटपुट तरीके ।

— user2428118

8

जेली , 16 30 29 20 बाइट्स

अब सही आउटपुट स्वरूप के साथ! डेनिस को बहुत धन्यवाद इस उत्तर को डीबग करने में उनकी मदद के लिए। गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

संपादित करें: सही आउटपुट प्रारूप का उपयोग करने से +14 बाइट्स। -1 अतिरिक्त जगह को हटाने से बाइट। -3 से परिवर्तित करने से 24,60,60करने के लिए “ð<<‘। से बदलने के +100DḊ€€लिए -6 बाइट्स d⁵।

“ð<<‘Œp’S=¥Ðfd⁵j€”:Y

व्याख्या

“ð<<‘Œp’S=¥Ðfd⁵j€”:Y  Main link. Argument: n

“ð<<‘                 Jelly ord() the string `ð<<` to get [24, 60, 60]. Call this list z.
     Œp               Cartesian product of z's items. 
                        Since each item of z is a literal,
                        Jelly takes the range [1 ... item] for each item.
       ’              Decrements every number in the Cartesian product 
                        to get lowered ranges [0 ... item-1].
        S=¥           Create a dyadic link of `sum is equal to (implicit n)`.
           Ðf         Filter the Cartesian product for items with sum equal to n.
             d⁵       By taking divmod 10 of every number in each item,
                        we get zero padding for single-digit numbers
                        and every double-digit number just turns into a list of its digits.
               j€”:   Join every number with a ':'.
                   Y  Join all of the times with linefeeds for easier reading.

— Sherlock9
स्रोत

8

बैश, 71

8 बाइट्स ने @hvd को धन्यवाद दिया

for t in {0..23}+{00..59}+{00..59};{((${t//+0/+}-$1))||echo ${t//+/:};}

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

— डिजिटल आघात
स्रोत

1

printfयहाँ महंगा है। हो रही द्वारा tसही प्रारूप के करीब है, और बनाने के लिए इसे फिक्सिंग ((t-$1)): काम, आप इसे नीचे करने के लिए 71 प्राप्त कर सकते हैंfor t in {0..23}+{00..59}+{00..59};{((${t//+0/+}-$1))||echo ${t//+/:};}

— HVD

@ एचवीडी गुड गोल्फिंग - धन्यवाद!

— डिजिटल ट्रामा

6

पर्ल 6 , 62 56 बाइट्स

{map *.fmt('%02d',':'),grep $_==*.sum,(^24 X ^60 X ^60)}

बस सभी घंटे, मिनट और सेकंड के क्रॉस उत्पाद में सभी संभावित संयोजनों की जांच करता है।

— शॉन
स्रोत

4

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

def f(n):
 for k in range(86400):t=k//3600,k//60%60,k%60;sum(t)==n!=print('%d:%02d:%02d'%t)

exec(Python 2) या पुनरावर्तन (Python 3) का उपयोग करते हुए छोटे समाधान होते हैं , लेकिन दोनों के लिए अनुचित मात्रा में मेमोरी की आवश्यकता होती है।

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

— डेनिस
स्रोत

4

पॉवरशेल , 87 77 बाइट्स

जॉन एल बेवन के लिए धन्यवाद, 10 बाइट्स बचाए

$d=date;0..86399|%{$d+=1e7l;"$d".Split()[1]}|?{("{0:H+m+s}"-f$d|iex)-in$args}

इसे ऑनलाइन आज़माएं! (यह समय समाप्त हो जाएगा, यह बहुत धीमा है)

व्याख्या

बहुत सरल, वर्तमान से शुरू होकर [datetime], 1 सेकंड 86,399 बार जोड़ें, एक स्ट्रिंग के रूप में प्रारूपित करें, फिर केवल उन लोगों को रखें जहां योग जोड़ता है।

— briantist
स्रोत

FYI करें: आप की जगह ले सकता 10000000के साथ 1e7lकरने के लिए सेव 4 बाइट ... या यहाँ तक कि 1e7एक अतिरिक्त बाइट के लिए (मुझे लगता है कि, मैं शामिल करने के लिए किया था Lपैरामीटर के लाभ के लिए है, लेकिन संदेह है कि आपका दृष्टिकोण से बचा जाता है कि जरूरत है।

— JohnLBevan

1

@ जॉनलोवन धन्यवाद! मैंने 1e7कम से कम 30 मिनट तक संघर्ष किया , और यह Lमेरे द्वारा याद किया गया उपसर्ग था ; मैं इसके बारे में भूल गया और यह पता लगाने का कोई तरीका नहीं निकाल सका कि यह अंतर से कम था। किसने तय किया कि एक [timespan]दुभाषिया [int]और वैसे भी एक दिन के[double] रूप में ?? बिट बहुत शानदार है, हालांकि यह इस पूरी बात उसके पकने धीमा हो जाता है। iex

— ब्रायंटिस्ट

1

कोई चिंता नहीं; मुझे उस पर भी कुछ मदद मिली;): stackoverflow.com/q/41408902/361842

— JohnLBevan

1

@JohnLBevan मैंने शाब्दिक रूप से इस प्रश्न को टिप्पणी से पहले देखा जहां आपने इसे लिंक किया था! अच्छा लगा।

— रिश्वतखोर

1

इसके अलावा iexचाल यहाँ एक टिप से अनुकूलित किया गया था: codegolf.stackexchange.com/a/746/6776

— JohnLevan

3

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

f x=[tail$(':':).tail.show.(+100)=<<t|t<-mapM(\x->[0..x])[23,59,59],sum t==x]

— XNOR
स्रोत

2

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

p x=['0'|x<10]++show x
i=[0..59]
f x=[p h++':':p m++':':p s|h<-[0..23],m<-i,s<-i,h+m+s==x]

HH: MM: SS स्ट्रिंग्स, जैसे f 140-> की सूची लौटाता है ["22:59:59","23:58:59","23:59:58"]।

यह घंटे, मिनट और सेकंड के माध्यम से तीन सरल छोरों है। उन सभी मानों को रखें और प्रारूपित करें जहाँ योग इनपुट संख्या है x।

— nimi
स्रोत

2

पायथ - 30 बाइट्स

हर संभव समय लेता है फिर फ़िल्टर करता है।

mj\:%L"%02d"dfqsTQsM*U24*KU60K

टेस्ट सूट ।

— Maltysen
स्रोत

2

जूलिया 0.5 , 69 बाइट्स

!n=[h+m+s==n&&@printf("%d:%02d:%02d
",h,m,s)for s=0:59,m=0:59,h=0:23]

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

— डेनिस
स्रोत

2

बैच, 168 बाइट्स

@for /l %%t in (0,1,86399)do @call:c %1 %%t
@exit/b
:c
@set/ah=%2/3600,m=%2/60%%60,s=%2%%60,n=%1-h-m-s
@set m=0%m%
@set s=0%s%
@if %n%==0 echo %h%:%m:~-2%:%s:~-2%

एकल-अंक घंटे आउटपुट।

— नील
स्रोत

2

मैथेमेटिका, 79 बाइट्स

Cases[Tuples@{(r=Range)@24-1,x=r@60-1,x},t_/;Tr@t==#:>DateString@TimeObject@t]&

— ngenisis
स्रोत

1

ऑक्टेव, 83 , 87 बाइट्स

@(a){[H,M,S]=ndgrid(0:23,s=0:59,s);printf("%d:%02d:%02d\n",[H(x=H+M+S==a),M(x),S(x)]')}

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

— rahnema1
स्रोत

1

QBIC , 82 72 बाइट्स

:[0,23|[0,59|[0,59|~b+c+d=a|?!b$+@:`+right$(@0`+!c$,2)+A+right$(B+!d$,2)

यह QBasic में एक दुर्भाग्यपूर्ण स्थान को हिट करता है, 0जब आवश्यक हो , तो ट्रिमिंग करना, ट्रिमिंग करना और प्रस्तुत करना बहुत महंगा है।

नमूना उत्पादन:

Command line: 119
1:59:59
2:58:59
2:59:58
3:57:59
[... SNIP 270 lines ...]
23:58:38
23:59:37

~~स्पष्टीकरण~~ मैंने इसके बारे में एक उपन्यास लिखा:

:           Get N, call it 'a'
[0,23|      Loop through the hours; this FOR loop is initialised with 2 parameters
            using a comma to separate FROM and TO, and a '|' to delimit the argument list
[0,59|      Same for the minutes
[0,59|      And the seconds
            QBIC automatically creates variables to use as loop-counters: 
            b, c, d (a was already taken by ':')
~b+c+d=a    IF a == b+c+d
|           THEN
 ?          PRINT
  !         CAST
   b        'b'
    $       To String; casting num to str in QBasic adds a space, this is trimmed in QBIC
+@:`        Create string A$, containing ":"
+right$      This is a QBasic function, but since it's all lowercase (and '$' is 
            not a function in QBIC) it remains unaltered in the resulting QBasic.
(@0`+!c$,2) Pad the minutes by prepending a 0, then taking the rightmost 2 characters.
+A          Remember that semicolon in A$? Add it again
+right$     Same for the seconds
(B+!d$,2)   Reusing the 0-string saves 2 bytes :-)

— steenbergh
स्रोत

QBIC दिलचस्प लग रहा है। क्या आपने इसे # कोड-गोल्फ के लिए बनाया था !? :)

— wasatchwizard

@wasatchwizard Yup :-)

— steenbergh

1

PowerShell , 67 79 बाइट्स (गंदा संस्करण)

चूंकि नियम कहते हैं कि एक निश्चित समय (या बिल्कुल) में पूरा करने के बारे में कुछ नहीं है, और कोई डुप्लिकेट के बारे में कुछ भी नहीं है, यहां एक भयानक समाधान है:

for(){if(("{0:H+m+s}"-f($d=date)|iex)-in$args){"{0:H:mm:ss}"-f$d}}

— JohnLBevan
स्रोत

1

मुझे प्रासंगिक मेटा पोस्ट नहीं मिल रहा है, लेकिन मुझे पूरा यकीन है कि एक सबमिशन को तब तक वैध होना चाहिए, जब तक कि चुनौती से निर्दिष्ट न किया जाए

— Sefa

धन्यवाद @ सिफा ... अगर ऐसा है तो मुझे ब्रेंटिस्ट के स्वच्छ संस्करण की तुलना में कम पात्रों में काम करने के लिए एक अच्छा तरीका नहीं मिल सकता है ... इस उत्तर को हटाने के लिए टेम्प्लेट किया गया, लेकिन मुझे गर्व है कि कैसे यह बुरा है;)

— जॉनलेवन

0

रैकेट 39 बाइट्स

(for*/sum((h 24)(m 60)(s 60))(+ h m s))

Ungolfed:

(for*/sum      ; loop for all combinations; return sum of values for each loop
   ((h 24)     ; h from 0 to 23
    (m 60)     ; m from 0 to 59
    (s 60))    ; s from 0 to 59
  (+ h m s))   ; sum of all 3 variables

— rnso
स्रोत

0

MATL , 29 बाइट्स

24:q60:qt&Z*t!si=Y)'%i:'8:)&V

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

व्याख्या

24:q     % Push [0 1 ... 23]
60:q     % Push [0 1 ... 59]
t        % Duplicate
&Z*      % Cartesian product of the three arrays. This gives a matrix with each
         % on a different row Cartesian tuple
t!       % Push a transposed copy
s        % Sum of each column
i=       % Logical mask of values that equal the input
Y)       % Select rows based on that mask
'%i:'    % Push this string
8:)      % Index (modularly) with [1 2 ... 8]: gives string '%i:%i:%i'
&V       % Convert to string with that format specification. Implicitly display

— लुइस मेंडो
स्रोत

0

जावास्क्रिप्ट, 122 120 बाइट्स

इनपुट के रूप में एक अतिरिक्त खाली स्ट्रिंग लेता है, ~~मुझे लगता है कि आकार की ओर गिनती नहीं है~~। स्ट्रिंग की आरंभीकरण के लिए दो बाइट्स जोड़ने के लिए अद्यतन bytecount (ऐतिहासिक सहित)।

console.log((
//Submission starts at the next line
i=>o=>{for(h=24;h--;)for(m=60;m--;)for(s=60;s--;)if(h+m+s==i)o+=`${h}:0${m}:0${s} `;return o.replace(/0\d{2}/g,d=>+d)}
//End submission
)(prompt("Number:",""))(""))

स्निपेट का विस्तार करें

— user2428118
स्रोत

यदि आपको किसी स्ट्रिंग को खाली करने के लिए आरंभीकृत करने की आवश्यकता है, तो आरंभीकरण की गणना की जानी चाहिए

— edc65

@ edc65 पूरा किया। ·

— कईलर्स

0

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

v=>eval("o=[];z=x=>':'+`0${x}`.slice(-2);for(m=60;m--;)for(s=60;s--;h>=0&h<24&&o.push(h+z(m)+z(s)))h=v-m-s;o")

कम गोल्फ वाला

v=>{
  o=[];
  z=x=>':' + `0${x}`.slice(-2);
  for(m = 60; m--;)
    for(s = 60; s--; )
      h = v - m - s,
      h >= 0 & h < 24 && o.push(h + z(m) + z(s))
  return o
}

परीक्षा

F=
v=>eval("o=[];z=x=>':'+`0${x}`.slice(-2);for(m=60;m--;)for(s=60;s--;h>=0&h<24&&o.push(h+z(m)+z(s)))h=v-m-s;o")

function update() {
  O.textContent=F(+I.value).join`\n`
}

update()

<input id='I' value=119 type=number min=0 max=141 oninput='update()'><pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

0

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

v=>{for (i=86399;i;[a,b,c]=[i/3600|0,i%3600/60|0,i--%60]){v-a-b-c?0:console.log(a+":"+b+":"+c)}}

विस्तारित दृश्य:

v => {
    for (i = 86399; i;
        [a, b, c] = [i / 3600 | 0, i % 3600 / 60 | 0, i-- % 60]) {
        v - a - b - c ? 0 : console.log(a + ":" + b + ":" + c)
    }
}

86399 से 1 तक लूपिंग द्वारा सभी संभव समयों के माध्यम से लूप करें,

पहला अंक प्राप्त करने के लिए 3600 से विभाजित करके पूर्णांक को समय पर बदलें
पूर्णांक मॉड 3600 और फिर 60 से विभाजित करके दूसरा अंक
और अंतिम अंक पूर्णांक मॉड 60 है

यदि इनपुट संख्या में तीन संख्याएँ जोड़ते हैं, तो एक गलत मूल्य वापस करने के लिए इनपुट मान से सभी 3 नंबर घटाएँ। यदि मान गलत है, तो मान को आउटपुट करें।

— Grax32
स्रोत

0

बैश, 78 बाइट्स (बीएसडी उपयोगिता का उपयोग करके) या 79 बाइट्स (गैर-बीएसडी भी)

यह @DigitalTrauma और @ hvd का अच्छा 71-बाइट बैश समाधान से थोड़ा लंबा है, लेकिन मुझे आधार 60 में संख्याओं का उपयोग करने का विचार पसंद आया; अगर कोई इसे थोड़ा और नीचे कर सकता है तो मैं उत्सुक हूं।

बीएसडी-मानक जेट उपयोगिता के साथ:

jot '-wx=`dc<<<60do3^%d+n`;((`dc<<<$x++'$1'-n`))||tr \  :<<<${x:3}' 86400 0|sh

अधिक सार्वभौमिक रूप से उपलब्ध seq उपयोगिता के साथ:

seq '-fx=`dc<<<60do3^%.f+n`;((`dc<<<$x++'$1'-n`))||tr \  :<<<${x:3}' 0 86399|sh

यह विचार 0 से 83699 तक संख्याओं को उत्पन्न करने और उन्हें 60 के बेस में बदलने के लिए dc का उपयोग करना है। dc के बेस -60 आउटपुट में "अंक" 00 से 59 तक 2-अंकीय संख्याएँ हैं, जिसमें रिक्त स्थान "अंक" को अलग करते हैं, इसलिए यह लगभग वांछित प्रारूप में 00 00 00 से 23 59 59 तक सभी वांछित समयों को सूचीबद्ध करता है।

यदि आप सचमुच इसे बाहर ले जाते हैं, हालांकि, 60 ^ 2 से नीचे की संख्या आधार 60 में 3-अंकीय संख्या नहीं है, इसलिए प्रारंभिक 00 या 00 00 गायब है। इस कारण से, मैं वास्तव में 60 ^ 3 से 60 ^ 3 + 83699 तक संख्या उत्पन्न कर रहा हूं; यह सुनिश्चित करता है कि उत्पन्न सभी संख्याएँ आधार ६० में ४ अंकों की लंबी हैं। यह तब तक ठीक है जब तक मैं अंततः अतिरिक्त पहले अंक (०१) को फेंक नहीं देता जिसकी आवश्यकता नहीं है।

इसलिए, एक बार वांछित समय उत्पन्न हो जाने के बाद, मैं बस प्रत्येक चौगुनी को ०१ ०० ०० ०० से ०१ २३ ९ ५ ९ ५ ९ तक ले जाता हूं, अंतिम तीन संख्याओं को जोड़ता हूं और तर्क $ १ को घटाता हूं। यदि वह 0 है, तो मैं 3 अक्षर से ("01" को दूर फेंक) चतुष्कोण में सब कुछ लेता हूं, रिक्त स्थान को कॉलन में परिवर्तित करने के लिए ट्रे का उपयोग करता हूं, और परिणाम प्रिंट करता हूं।

— मिशेल स्पेक्टर
स्रोत

0

PowerShell , 91 97 बाइट्स (इनपुट सहित)

param($x)1..864e3|%{($d=date($_*1e7l))}|?{("{0:H+m+s}"-f$_|iex)-eq$x}|%{"{0:H:mm:ss}"-f$_}

~~param($x)0..23|%{$h=$_;0..59|%{$m=$_;0..59|?{$h+$m+$_-eq$x}|%{"{0:0}:{1:00}:{2:00}"-f$h,$m,$_}}}~~

या

param($x)0..23|%{$h=$_;0..59|?{($s=$x-$h-$_)-le59-and$s-ge0}|%{"{0:0}:{1:00}:{2:00}"-f$h,$_,$s}} <\ S>

विस्तारित और टिप्पणी की गई

param($x)
#loop through the hours
0..23 | %{
    $h=$_
    #loop through the minutes
    0..59 | %{
        $m=$_
        #loop through the seconds
        0..59 | ?{ #filter for those where the sum matches the target
            $h + $m + $_ -eq $x
        } | %{
            #format the result
            "{0:#0}:{1:00}:{2:00}" -f $h, $m, $_
        }
    }
}

NB: @ Briantist के संस्करण से घिरा: /codegolf//a/105163/6776

— JohnLBevan
स्रोत

24 घंटे के समय की रकम

जेली , 16 30 29 20 बाइट्स

बैश, 71

पर्ल 6 , 62 56 बाइट्स

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

पॉवरशेल , 87 77 बाइट्स

व्याख्या

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

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

पायथ - 30 बाइट्स

जूलिया 0.5 , 69 बाइट्स

बैच, 168 बाइट्स

मैथेमेटिका, 79 बाइट्स

ऑक्टेव, 83 , 87 बाइट्स

QBIC , 82 72 बाइट्स

PowerShell , 67 79 बाइट्स (गंदा संस्करण)

रैकेट 39 बाइट्स

MATL , 29 बाइट्स

व्याख्या

जावास्क्रिप्ट, 122 120 बाइट्स

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

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

बैश, 78 बाइट्स (बीएसडी उपयोगिता का उपयोग करके) या 79 बाइट्स (गैर-बीएसडी भी)

PowerShell , 91 97 बाइट्स (इनपुट सहित)