我的微波炉应该运行多长时间？

33

我饿了。让我们微波一下。给定1到4位之间的数字输入，输出微波炉应运行的秒数。

细节

技巧是弄清楚用户输入的是秒还是秒和分钟的组合。一个和十个位置应解释为秒，成百上千个位置应解释为分钟。例如，该值1234应解释为12分钟34秒，并且9876应为98分钟76秒。键入130和90都将导致90秒的烹饪时间。

以下是一些其他输入和输出：

1 = 1
11 = 11
111 = 71
1111 = 671
9 = 9
99 = 99
999 = 639
9999 = 6039

规则

这是代码高尔夫球，因此以字节为单位的最短程序获胜。不允许出现标准漏洞。给定从1到9999的任何整数输入时，获胜作品必须返回正确答案。

code-golf number

— 安德鲁·布雷扎（AndrewBrēza）
source

@WheatWizard，我很高兴编辑问题。您对我在“详细信息”部分应该说的内容有何建议？也许我可以使这句话更清楚：“一个和十个位应解释为秒，而成百上千个位应解释为分钟。”

— 安德鲁·布雷扎（AndrewBrēza）'17

@WheatWizard我刚刚添加了更多细节，如果您认为我应该添加更多信息，请告诉我。

— 安德鲁·布雷萨（AndrewBrēza）'17

输入有效9876吗？

— 安德鲁·布雷萨（AndrewBrēza）'17

1

奇怪，我正准备挑战这个确切的挑战哈哈

— FlipTack

输出将用于190什么？

— OldBunny2800

Answers:

21

Python 2，19个字节

lambda t:t-t/100*40

在线尝试！

— ovs
source

9

Japt，6个字节

ìL ì60

在线测试！ ìL转换为100，再ì60转换回60 floor(n/100)*60 + n%100。也可以使用小时（10000 -> 3600，小时中的秒数）。

— ETH生产
source

1

正是我所拥有的:)

— 毛茸茸的

7

C，C ++，Java，C＃，D：36个字节

D：35个字节

C：28个字节

第一次我有那么短的答案！

int r(int i){return i/100*60+i%100;}

由于golfy模板系统，D可以进行特殊的优化：

T r(T)(T i){return i/100*60+i%100;}

C具有隐式int的特殊优化：

r(i){return i/100*60+i%100;}

测试代码

在C中（必须包含stdio.h）：

int main() {
    int testArr[] = {1,11,111,1111,9,99,999,9999};
    for(int i=0;i<8; ++i) {
        printf("%d = %d\n",testArr[i],r(testArr[i]));
    }
    return 0;
}

在C ++中（必须包含iostream）：

int main() {
    std::initializer_list<int> testList{
        1,11,111,1111,9,99,999,9999
    };

    for (auto x : testList) {
        std::cout << r(x) << '\n';
    }
}

在线尝试！

在Java中：

public class MainApp {

    int r(int i){return i/100*60+i%100;}

    public static void main(String[]a) {
        MainApp m = new MainApp();
        int testArr[] = new int[]{
                1,11,111,1111,9,99,999,9999
        };

        for (int v : testArr) {
            System.out.println(v + " = " + m.r(v));
        }
    }
}

在线尝试！

在C＃中

class Program {
    int r(int i){return i/100*60+i%100;}
    static void Main(string[] args) {
        var p = new Program();
        int[] testArr = new int[8]
        {
            1,11,111,1111,9,99,999,9999
        };
        foreach(int a in testArr) {
            Console.WriteLine(a + " = " + p.r(a));
        }
    }
}

在D中（必须要导入std.stdio）（确切地说，我不知道如何在D中使用数组）：

void main() {
    int[] arr = [1,11,111,1111,9,9,999,9999];
    for(int i = 0; i < arr.length; i++)
        writeln(arr[i]," = ",r(arr[i]));
}

— HatsuPointerKun
source

D测试代码是该TIO的页脚：tio.run/…，我看到您已经学习了模板系统:)。（有一个foreach在d，我只是忘了怎么伤心地使用它）

— 扎卡里

可以使用C89隐式整数将C压缩为28个字节。

— pizzapant184 '17

您应该将所有这些发布为单独的答案。

— MD XF

6

腐霉菌-9 8个字节

将输入转换为基数100，然后将其解释为基数60。

ijQ*TT60

测试套件。

— 马尔蒂森
source

6

TI-Basic（83系列），8字节

Ans-40int(sub(Ans

需要操作系统版本1.15或更高版本。

— 米莎·拉夫罗夫（Misha Lavrov）
source

6

直流，10字节

?9A~r60*+p

在线尝试！

说明：在dc上，当您按sth键时。在堆栈上

?         # read and push the input number on the stack
9A        # push 100: 9 * 10^1 + A[10] * 10^0 :D
~         # divide 2nd nr. by the top nr., push quotient, then remainder
r60*      # swap top 2 nr., then multiply the top by 60
+p        # add top 2 nr., then print result

— Seshoumara
source

5

Bash bc + sed，30 28字节

-2个字节感谢@seshoumara。

bc<<<0`sed 's/..\?$/*60+&/'`

在线尝试！

接受来自stdin的输入。尝试采用更具创意的方法：*60+在最后1或2位数字前插入，并0在开头加上a ，以说明只有1或2位数字的输入。然后将结果传递给bc。

— 贾斯汀·马里纳（Justin Mariner）
source

1

如果删除-r并使用\?，则可以减少2个字节。

— seshoumara

3

C（gcc），50个字节

t;f(){scanf("%d",&t);printf("%d",t%100+t/100*60);}

在线尝试！

— 腹肌
source

2

28个字节：f(t){return t%100+t/100*60;}。允许函数将输入作为参数并通过其返回值输出。

— Steadybox '17

25个字节 f(i,x){x=i/100*60+i%100;}

— Giacomo Garabello，

21字节 f(i,x){x=i-i/100*40;}

— Kevin Cruijssen

3

Perl 5、15 + 1（-p）字节

/..$/;$_-=40*$`

-l开关不计入，因为测试可读性

— 纳韦尔·福耶勒
source

3

Java 8，13字节

n->n-n/100*40

@ovs的惊人Python 2公式端口。

在这里尝试。

— 凯文·克鲁伊森
source

2

JavaScript，21字节

a=>(a/100^0)*60+a%100

在线尝试！

使用ovs的技巧保存4个字节-a-（a / 100 ^ 0）* 40

— IanF1

1

@ IanF1。谢谢，但是我认为这实际上是在窃取他们的想法。

是啊，你说得对。太热情了，对不起。

— IanF1

3

@ThePirateBay那么您真的不辜负您的名字

— 吗

2

J，12个字节

-40*&<.%&100

这是ovs用J表示的Python 2解决方案。它由一个钩子和一个fork组成：

┌─┬───────────────────────┐
│-│┌──┬────────┬─────────┐│
│ ││40│┌─┬─┬──┐│┌─┬─┬───┐││
│ ││  ││*│&│<.│││%│&│100│││
│ ││  │└─┴─┴──┘│└─┴─┴───┘││
│ │└──┴────────┴─────────┘│
└─┴───────────────────────┘

       %&100  - divides the number by 100
   *&<.       - finds the floor of the left argument and multiplies it to the left arg.
 40           - 
-             - subtracts the result of the above fork from the input

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source

1

与相同的字节数60#.0 100#:]。

— FrownyFrog

@FrownyFrog-您的解决方案看起来更漂亮，欢呼！

— 加伦·伊凡诺夫

2

批次，23个字节

@cmd/cset/a%1-%1/100*40

— 尼尔
source

2

Haskell，18个字节

f t=t-t`div`100*40

在线尝试！

阿诺莎港口。

无点解决方案，21字节

(-)<*>(*40).(`div`40)

— 全人类
source

2

迷宫，19字节

?:_100%}#00/_60*{+!

在线尝试！

说明

?      Read input.
:      Duplicate.
_100%  Mod 100.
}      Move off to auxiliary stack.
#00/   Divide by 100, using the stack depth to get a 1, instead of _1.
_60*   Multiply by 60.
{+     Retrieve the earlier result and add it.
!      Print.

IP随后陷入僵局并开始向后移动。当达到时，/它将尝试除以零，从而终止程序。

— 马丁·恩德
source

2

果冻，5个字节

作为单声道链接（感谢单挑，老兄！）：

b³ḅ60

在线尝试！

...或作为完整程序：

bȷ2ḅ60

可以轻松地将其移植到05AB1E，因此：

05AB1E，5个字节

тв60β

在线尝试！

只需将输入整数转换为基数100，然后将结果从基数60转换为整数。因此，它等效于输入％100 + 60 *⌊输入/100⌋

— Xcoder先生
source

作为一个函数，5个字节

— caird coinheringaahing

@cairdcoinheringaahing我认为您的意思是这个，但无论如何还是要

— 多加注意

2

Excel VBA，29字节

匿名VBE立即窗口功能，该功能从范围获取输入[A1]并输出到VBE立即窗口。

?[A1]Mod 1E2+60*[Int(A1/100)]

— 泰勒·斯科特
source

2

APL（Dyalog），11 10字节

60⊥0 100⊤⊢

在线尝试！

怎么样？

0 100⊤-以100为底进行编码，在第二个LSB处停止，有效产生n ÷ 100, n % 100。

60⊥ -以60为底进行解码

— 乌里尔
source

2

PARI / GP，16字节

直截了当：

n->n\100*60+n%100

不幸的是，这种不错的方法太久了，无法使用：

n->[60,1]*divrem(n,100)

— 查尔斯
source

2

Pushy，10 9字节

凯文（Kevin）用我自己的语言超过我……（使用ovs的回答方法）

2dH/40*-#

在线尝试！

10字节

sjvj60*^+#

在线尝试！

s             \ Split input into digits
 jvj          \ Join the first two and the last two
    60*       \ Multiply the first by 60
       ^+     \ Add the values
         #    \ Print

11字节

再增加一个字节，我们可以使用以下Input % 100 + 60 * ⌊Input / 100⌋方法：

H2d%}/60*+#

在线尝试！

— FlipTack
source

1

9个字节通过创建的端口@ovs'的Python 2答案：2dH/40*-#。以前从未用Pushy编程过，但是似乎是一种很酷的语言。:)

— Kevin Cruijssen

1

@KevinCruijssen，它是一种基于通用堆栈的语言，我想它带给桌面的唯一一点不同是双重堆栈...但是，谢谢你，感谢高尔夫:)

— FlipTack

1

05AB1E，9个字节

т÷60*¹т%+

在线尝试！

说明：

т÷60*¹т%+

т         // Push number 100
 ÷        // Integer division with the input
  60      // Push number 60
    *     // Multiply with the previous result
     ¹    // Push input
      т   // Push 100 again
       %  // Modulo
        + // Add the first and the second result

基本转换可能有一些技巧，可以在05AB1E中实现，但我找不到。

1

bash，20个字节

echo $[$1-$1/100*40]

— 纳韦尔·福耶勒
source

1

视网膜，11字节

.{100}
60$*

在线尝试！

一元的输入和输出。为了方便起见，测试套件会从和转换为十进制。

一元中仅执行最多两位数的这种基数转换非常简单。我们只匹配100 1s的运行，并用60 1s 替换它们。剩下的任何内容都将对应于十进制表示形式的最后两位，并且保持不变。

— 马丁·恩德
source

1

爱丽丝，19字节

/o
\i@/.'d%~'d:'<*+

在线尝试！

说明

太糟糕了，我想从语言中删除了divmod，我想...

/o
\i@/...

这只是线性程序的常规框架，带有十进制I / O的线性程序仅在基数（算术）模式下运行。

.     Duplicate input.
'd%   Mod 100.
~     Swap with other copy.
'd:   Divide by 100.
'<*   Multiply by 60.
+     Add.

— 马丁·恩德
source

1

银河系，10字节

':Z/v40*-!

用法： ./mw code.mwg -i 9999

说明：

code       explanation                          stack

'          push input to stack                  [input]
 :         duplicate ToS                        [input, input]
  Z        push 100                             [input, input, 100]
   /v      integer division (divide and floor)  [input, ⌊input/100⌋]
     40    push 40                              [input, ⌊input/100⌋, 40]
       *   multiply                             [input, ⌊input/100⌋*40]
        -  subtract                             [input - ⌊input/100⌋*40]
         ! print

— ovs
source

1

R，21个字节

x=scan();x-x%/%100*40

在线尝试！

— 标记
source

1

我在R中创建了自己的解决方案，它的优雅程度远不如此。

— 安德鲁·布雷扎（AndrewBrēza）'17

您可以减少，scan因为大多数答案只是假设变量已定义。

— 安德鲁·布雷扎（AndrewBrēza）'17

规则在这方面是如此不一致。您还必须拥有一项功能或进行扫描以获取价值，这是其他挑战之一。

— Mark

1

Common Lisp，34个字节

(lambda(n)(- n(*(floor n 100)40)))

在线尝试！

@ovs公式的另一个端口。

— 伦佐
source

1

REXX，25个字节

arg t
say t%100*60+t//100

（@ovs的另一种翻译）

— 伊德鲁格
source

0

05AB1E，7个字节

т‰ć60*+

在线尝试！

说明

         command                              current stack
т‰ć60*+  full program. push input implicitly  [1234]
т        push 100                             [1234] [100]
 ‰       push divmod                          [12, 34]
  ć      push head extracted (n[1:], n[0])    [34] [12]
   60*   multiply by 60                       [34] [720]
      +  add and display implicitly           [754]

— 辛纳里
source

0

符号Python，66个字节

___=-~-~_-_
__=___*___
__=__*__*___+___*__
_=_-_/(__+__+__/___)*__

在线尝试！

说明

Symbolic Python          values

___=-~-~_-_              ___=2
__=___*___               __=2*2=4
__=__*__*___+___*__      __=4*4*2+2*4=32+8=40
_=_-_/(__+__+__/___)*__  _=_-_/(40+40+40/2)*40=_-_/100*40

— ovs
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.