搭配醒目的时钟

14

介绍：

在家里，我们有一个时钟，每小时都会敲定一个既定数量的时钟，但也每半小时敲一次。因此，从0:01到12:00（包括12:00）按以下顺序进行：

1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12

挑战：

给定一个整数n，输出一个总罢工等于的时间范围列表n。此外，请务必在该时间范围之前至少1分钟开始，并在此时间范围之后至少1分钟（最多29分钟）结束。
例如，如果输入为n=8，则输出可能为：

[00:59-03:01, 01:29-03:31, 02:59-04:01, 05:29-06:31, 06:29-07:01, 06:59-07:31, 07:59-08:01]

对于这些时间范围，它们的总和如下8：

[1+1+2+1+3, 1+2+1+3+1, 3+1+4, 1+6+1, 1+7, 7+1, 8]

挑战规则：

  • 输出灵活。您可以输出为时间（或日期/日期时间）对象，时间戳记，字符串（带或不带前导零），带.29/ .31/ .59/的小数.01（即0.29-3.01代替00:29-03:01）等。只要清楚，它就在时间范围的前后。
    此外，您可以自己选择金额。在我的所有示例中，我使用1分钟，但您也可以选择5分钟，15分钟等。这也意味着您可以使用.4/ .6/ .9/ .1（即0.4-3.1代替00:24-03:06）。该列表也很灵活。可以是列表/集合，数组，分隔符分隔的字符串，每行打印到STDOUT等，
    请说明您做出的输出选择。注意：不允许您输出上述时间范围的总和，此处仅作说明。您必须输出时间范围，包括之前和之后的时间。
  • 罢工确实从12:00到结束00:30。因此，如果n=14两个时间范围分别是11:29-00:31和11:59-01:01。
  • 输入将在范围内1 <= n <= 90，其中90是所有可能的警示的总和。
  • 您返回的时间范围可以是任何顺序。

通用规则：

  • 这是代码高尔夫球，因此最短答案以字节为单位。
    不要让代码高尔夫球语言阻止您使用非代码高尔夫球语言发布答案。尝试针对“任何”编程语言提出尽可能简短的答案。
  • 标准规则适用于您的答案，因此您可以使用STDIN / STDOUT，具有正确参数的函数/方法和返回类型的完整程序。你的来电。
  • 默认漏洞是禁止的。
  • 如果可能的话，请添加一个带有测试代码的链接。
  • 另外，如有必要，请添加说明。

测试用例：

（全部使用时间范围和前导零之前/之后的1分钟）

Input: 8
Ouput:
[00:59-03:01, 01:29-03:31, 02:59-04:01, 05:29-06:31, 06:29-07:01, 06:59-07:31, 07:59-08:01]

Input: 14
Output:
[00:29-04:01, 00:59-04:31, 02:59-05:01, 04:29-06:31, 05:59-07:01, 11:29-00:31, 11:59-01:01]

Input: 90
Output:
[00:29-00:01, 00:59-00:31, 01:29-01:01, 01:59-01:31, 02:29-02:01, 02:59-02:31, 03:29-03:01, 03:59-03:31, 04:29-04:01, 04:59-04:31, 05:29-05:01, 05:59-05:31, 06:29-06:01, 06:59-06:31, 07:29-07:01, 07:59-07:31, 08:29-08:01, 08:59-08:31, 09:29-09:01, 09:59-09:31, 10:29-10:01, 10:59-10:31, 11:29-11:01, 11:59-11:31]

Input: 1
Output:
[00:29-00:31, 00:59-01:01, 01:29-01:31, 02:29-02:31, 03:29-03:31, 04:29-04:31, 05:29-05:31, 06:29-06:31, 07:29-07:31, 08:29-08:31, 09:29-09:31, 10:29-10:31, 11:29-11:31]

Input: 2
Output:
[00:29-01:01, 00:59-01:31, 01:59-02:01]
code-golf  arithmetic  date  clock 
— 凯文·克鲁伊森
source
1
我会选择最灵活的方式。只要结果数字介于两个振铃时间之间，这将包括十进制小时数。
— 亚当
@Adám猜猜你是对的。我已经相应地编辑了答案。您应该至少有1分钟，最多不超过29分钟，因此.4/ .6/ .9/ .1是允许的（就像您说的那样是6分钟：:24/ :36/ :54/ :06）。
— 凯文·克鲁伊森
1
也许提到时间对可能以任何顺序返回？
— 阿达姆（Adám）'18年
好吧，n在0..90，我不知道计算n次点击的时间是多少：12小时？他们是24小时吗？是48小时？返回时间是否超过格式0..24：0..60？
— RosLuP
@RosLuP时间范围是常规的模拟时钟，因此从00:01到12:00。因此，它应该是0..12：0..60，而不是0..24：0..60。这如何消除任何混乱。
— 凯文·克鲁伊森

Answers:

3

APL（Dyalog Classic），34字节SBCS

∪12|.4 .1∘+¨.5×⍸⎕=⍉∘.-⍨+\,⍪⍨1,⍪⍳12

在线尝试！

该解决方案使用⎕io←1（基于1的索引）。

从右到左：

⍳12 是 1 2 3...12

⍪ 将其变成一个高而细的12x1矩阵

1, 在左侧添加一列1

⍪⍨ 垂直连接同一矩阵，因此现在是24x2矩阵

, 以行优先顺序展平矩阵，它变成大小为48的向量： 1 1 1 2 1 3...1 12 1 1 1 2...1 12

+\ 部分和： 1 2 3 5 6 9...

∘.-⍨ 每对元素之间的差异（48x48矩阵）

⍉ 转置

⎕=评估输入（⎕）出现的任何地方都为1的48x48布尔矩阵

⍸ 1所在的坐标对

.5× 将它们减半

.4 .1∘+¨ 每对的第一个坐标加0.4并向第二个坐标加0.1

12| 模12

∪ 独特

— ngn
source
.1输出中表示的时间间隔是多少？另外，很好的答案。
— 暴民埃里克（Erik the Outgolfer）'18年
2
哦，这就是使它变成34字节的原因，也许想要链接到它或写<sup>SBCS</sup>像Adám的答案一样。
— 暴民埃里克（Erik the Outgolfer）'18年
@EriktheOutgolfer该问题显式允许.1 / .4 / .6 / .9而不是：01 /：29 /：31 /：59。我不需要此答案的特殊编码，它在Dyalog Classic中具有自己的单字节编码。
— ngn
⍸不在Dyalog Classic中。是的，我确实知道这是明确允许的，我只想知道0.1输出中有多少分钟;）
— Egg the Outgolfer
@EriktheOutgolfer添加了“ SBCS”，谢谢；.1×60分钟为6分钟
— ngn
5

JavaScript（ES6），104个字节

以H.MM,H.MM格式打印时间间隔。

F=(n,f=0,s=n,t=f++)=>t<f+23?F(n,f,s-=t&1||t/2%12+1,++t,s||alert([f/2%12+.01,-~t/2%12+.01])):f<24&&F(n,f)

在线尝试！

使用与以下非递归版本基本相同的算法。

非递归版本，117字节

以H.MM,H.MM格式输出以空格分隔的时间间隔字符串。

n=>[...Array(24)].map((_,f,a)=>a.map(_=>(s-=t++&1||t/2%12+.5)||(r+=[-~f/2%12+.01,-~t/2%12+.01]+' '),s=n,t=f),r='')&&r

测试用例

显示代码段

已评论

n =>                           // n = input
  [...Array(24)].map((_, f, a) // FOR f = 0 TO 23:
    => a.map(_ =>              //   FOR t = f TO f + 23:
      (                        //     update s
        s -=                   //       by subtracting:
          t++ & 1 ||           //         - 1 if t is odd (half hour)
          t / 2 % 12 + .5      //         - the current hour if t is even
      ) || (                   //     if s is equal to zero:
        r += [                 //       update the result string by appending:
          -~f / 2 % 12 + .01   //         - the formatted 'from' time
          ,                    //         - a comma
          -~t / 2 % 12 + .01   //         - the formatted 'to' time
        ] + ' '                //       and a padding space
      ),                       //     inner map() initialization:
      s = n,                   //     - s = target number of strikes
      t = f                    //     - 'to' time = 'from' time
    ),                         //   end of inner map()
    r = ''                     //   start with r = empty string
  )                            // end of outer map()
  && r                         // return r
— Arnauld
source
4

APL（Dyalog Unicode），62 59字节 SBCS

完整的程序主体。提示输入n。使用十进制小时数打印包含两个元素的列表。

∪(⎕=∊l+/¨⊂48⍴∊1,¨⍳12)/(¯.1 .1+⊃,⊢/)¨⊃,/(l←⍳48),/¨⊂.5×48⍴⍳24

在线尝试！

⍳24 ɩ 1…24

48⍴ 周期性[R ESHAPE到长度48，即1 ... 12,1 ... 12

.5× 乘以一半

⊂ 封闭（将整个数组用作每个左参数的右参数）

(… ),/¨ 对于以下每个，返回该长度的所有子列表：

 ⍳48 nd 1…48

 l← 存储在l（用于升 engths）

现在，我们为每个可能的行程长度提供了所有可能的时间运行清单。

,/ 串联（减少串联）子列表

⊃ 披露（因为减少的排名从1降低到0）

(… )¨ 对每个应用以下功能：

 ⊢/ 最后一个（减少右照明）元素（结束时间）

 ⊃, 在第一个元素之前（开始时间）

 ¯.1 .1+ 给那些增加负十分之一

(…通过以下方式)/ 过滤这些首尾对：

 ⍳12 ɩ1 …12

 1,¨1在每个 前面

 ∊ ε NLIST（扁平化）

 48⍴ 周期性ř ESHAPE到长度48，即1,1,1,2 ... 1,11,1,12

 ⊂ 封闭（将整个数组用作每个左参数的右参数）

 l+/¨ 对于l（1…48）中的每一个，返回该长度的所有子列表的和

 ∊ ε NLIST（扁平化）

⎕= 比较数字输入

∪ 仅返回唯一元素（开始-结束对）

— 亚当
source
0.1 0.5可以成为.1 .5
— Kritixi Lithos
@Cowsquack是的，我也注意到了。谢谢，不过。
— 阿达姆
3

Python 3中，118个 116字节

lambda n:[(a/2+.4,b%24/2+.1)for a in range(24)for b in range(48)if sum((sum(zip([1]*12,range(1,13)),())*2)[a:b])==n]

在线尝试！

时间范围表示为(t1, t2)，t1与t2表示小时，之后小数。偏移为.1或6分钟。

— ovs
source
1

批次，196个字节

@for /l %%i in (0,1,23)do @set s=%1&for /l %%j in (0,1,23)do @call:c %%i %%j
:c
@set/at=%2+%1,s-=t%%2*(t/2%%12)+1,h=%1/2,i=%1%%2*30+15,t=-~t%%24/2,u=-~t%%2*30+15
@if %s%==0 echo %h%:%i% %t%:%u%

说明：t在半小时的时间，开始0了00:30。打击的在时间t数量为然后1，1，1，2，1，3等等减法1给出了序列0，0，0，1，0，2等，它们是用零交织的整数。这然后可以通过序列的逐项乘积来获得0，0，1，1，2，2等与序列0，1，0，1，0，1等使用模和（整数）分割这两个序列被容易地计算。

然后，它仍然循环遍历所有23个可能的开始时间，然后采取所有24次敲击时间，并从输入中减去敲击次数，打印结果为零时的时间。

该代码在循环后通过，但不会造成伤害，因为输入不能超过90。

— 尼尔
source
1

APL NARS，559个字节

∇r←l w;t;i;j;c;k;m;p
p←{0=2∣¯1+⍵:.01+2÷⍨¯1+⍵⋄¯0.19+2÷⍨¯1+⍵}
m←{0=2∣¯1+⍵:¯.41+2÷⍨¯1+⍵⋄¯0.21+2÷⍨¯1+⍵}
   r←⍬⋄i←0⋄t←∊(¯1+⍳13),¨13⍴1⋄t←t,2↓t⋄k←⍴t
A: j←i+←1⋄→0×⍳i≥k⋄c←0
B: c+←j⊃t⋄:if(c=w)∧(0≤(m i))∧(24≥(p j))⋄r←r,⊂(m i),(p j)⋄:endif⋄→A×⍳c≥w⋄j+←1⋄→B×⍳j≤k⋄→A
∇
∇r←g w;v;i;k;m
   v←{12≤⌊⍵:⍵-12⋄⍵}
   i←1⋄k←⍴w⋄r←⍬
A: →0×⍳i>k⋄r←r,⊂v¨i⊃w⋄i+←1⋄→A
∇   
h←g∘l

h（n）或l（n）返回0到24小时内具有n个时钟脉冲的所有代表性间隔。h（n）的时钟格式为0..11.0..59; 而是l（n）的时钟格式为0..23.0..59测试

  h 8
    0.59 3.01  1.29 3.31  2.59 4.01  5.29 6.31  6.29 7.01  6.59 7.31  
    7.59 8.01  0.59 3.01  1.29 3.31  2.59 4.01  5.29 6.31  6.29 7.01  
    6.59 7.31  7.59 8.01 
  h 14
    0.29 4.01  0.59 4.31  2.59 5.01  4.29 6.31  5.59 7.01  11.29 0.31  
    11.59 1.01  0.29 4.01  0.59 4.31  2.59 5.01 4.29 6.31  5.59 7.01 
  h 90
    0.29 0.01  0.59 0.31  1.29 1.01  1.59 1.31  2.29 2.01  2.59 2.31  
    3.29 3.01  3.59 3.31  4.29 4.01  4.59 4.31  5.29 5.01  5.59 5.31  
    6.29 6.01  6.59 6.31  7.29 7.01  7.59 7.31  8.29 8.01  8.59 8.31  
    9.29 9.01  9.59 9.31  10.29 10.01  10.59 10.31  11.29 11.01  11.59 11.31    
  h 1
    0.29 0.31  0.59 1.01  1.29 1.31  2.29 2.31  3.29 3.31  4.29 4.31  
    5.29 5.31  6.29 6.31  7.29 7.31  8.29 8.31  9.29 9.31  10.29 10.31  
    11.29 11.31  0.29 0.31  0.59 1.01  1.29 1.31  2.29 2.31  3.29 3.31  
    4.29 4.31  5.29 5.31  6.29 6.31  7.29 7.31  8.29 8.31  9.29 9.31  
    10.29 10.31  11.29 11.31 
  h 2
    0.29 1.01  0.59 1.31  1.59 2.01  0.29 1.01  0.59 1.31  1.59 2.01 
  l 2
    0.29 1.01  0.59 1.31  1.59 2.01  12.29 13.01  12.59 13.31  13.59 14.01
— 罗斯鲁普
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.