Programe meu forno microondas [fechado]

Como sou muito preguiçosa, tento sempre programar meu microondas com o menor número possível de pressionamentos de botão . Meu microondas possui os seguintes botões:

• Um botão "minuto mais" que só pode ser pressionado primeiro e implica em "iniciar". Pode ser pressionado várias vezes por vários minutos, mas não adicionará um minuto a um tempo inserido manualmente. Resultado+
• Um conjunto de 0-9 botões. A entrada de tempo é MMSS (ou seja, "130" significa 1 minuto e 30 segundos). Os segundos podem variar de 0 a 99. Portanto, "130" e "90" são entradas equivalentes. Obviamente, cada minuto é de 60 segundos, mesmo que a parte dos segundos da entrada exceda 59. Saída 0..9
• Um botão "start" que deve ser pressionado para iniciar o microondas se a hora for inserida manualmente. ResultadoS

Meus pacotes de alimentos especificam o tempo em MM: SS e, portanto, o programa deve aceitar essa entrada.

Exemplos

• 1:00 é +(lembre-se "minuto mais" implica início)
• 1:01 61S(os segundos podem exceder 59, mas "mais um minuto" não funciona em conjunto com dígitos - acho que essa é uma falha de design no micro-ondas)
• 9:00 é 900S(menor que +++++++++)

APL

A APL tem uma má reputação de ilegível, o que não é totalmente o caso se não for jogado.

As regras:

• Minutos inteiros <= 4 obtêm +, ++, +++ e ++++
• 960-999 é preferido acima de 1000-1039. 9960-9999 é preferido acima de 10000-10039, etc.
• Se o tempo puder ser reescrito de forma que os segundos sejam 66, 77, 88 ou 99, isso será feito. (Isso nunca dá uma solução pior e geralmente dá uma solução melhor, ou seja, 888 em vez de 928.)

∇ Microondas; tempo; seg; min; fmt; ⎕ML

 ←ML ← 3

 ⎕ ← 'Digite a hora (m +: ss)'
 tempo ← ⍞
 mins segs ← ⍎¨ (time ≠ ':') ⊂time

Minute 'minute plus' só pode ser usado em minutos inteiros ≤ 4
 : Se (segundos = 0) ∧ (minutos≤4)
     ⎕ ← minutos⍴ '+'
     :Retorna
 :Fim se
⍝ Se possível, salve um pressionamento de tecla usando segundos> 60
Mins se min é uma potência de dez
 : Se (min> 0)
     : Se ((⌈10⍟mins) = (⌊10⍟mins)) ∧ (segundos <40)
         ⎕ ← ('BI2'⎕FMT min-1), (⎕FMT s + 60),' S '
         :Retorna
     :Fim se
 :Fim se
⍝ Para o requisito de 'movimento dos dedos', queremos o máximo
⍝ das teclas pressionadas quanto possível para ter a mesma tecla.
⍝ Então, 888S ipv 928S.
 : Se seg. 66 77 88 99-60
     ⎕ ← ('BI2'⎕FMT min-1), (⎕FMT s + 60),' S '
     :Retorna
 :Fim se
Caso contrário, apenas produza mmssS, não há alternativa melhor.
 : Se min> 0
    ⍝ segundos de saída com zero inicial
     ⎕ ← ('BI2'⎕FMT min), (' G⊂99⊃'⎕FMT s), 'S'
 :Outro
    ⍝ apenas segundos de saída, não com zero inicial
     ⎕ ← ('BI2'⎕FMT s),' S '
 :Fim se
∇

Javascript

var x = /(\d+):(\d\d)/.exec('<time here>');
x[1] === '0' ? +x[2] + 'S' :
x[1] < 4 && x[2] === '00' ? (
    x[1] === '1' ? '+' :
    x[1] === '2' ? '++' : '+++') :
x[2] < 40 ?
    (x[1] - 1 ? x[1] - 1 : '') + '' + (6 + +x[2][0]) + x[2][1] + 'S' :
x[1] + x[2] + 'S'

Perl

atende aos requisitos, mas não é como eu digitaria os botões (por exemplo, "860S" vs "900S") lida com exatamente 60 segundos como um caso especial

use strict;
use warnings;

sub cook
{
  my ($mins, $secs) = @_;

  my $plus = $secs =~ /00/ ? $mins : undef;

  my $secs_total = $mins * 60 + $secs;
  my $mins_total = 0;

  while ($secs_total > 99)
  {
    ++$mins_total;
    $secs_total -= 60;
  }

  $plus = "+" x $plus if defined $plus;

  my $nums = "";
  my $even = ($mins_total > 0 and $secs_total == 60);

  $secs_total *= not $even;
  $mins_total += $even;

  if ($mins_total > 0)
  {
    $nums = sprintf "%s%02dS", $mins_total, $secs_total;
  }
  else
  {
    $nums = sprintf "%2dS", $secs_total;
  }

  return ($nums, $plus)
    [defined $plus and length $plus < length $nums];
}

die "usage:$/\tperl $0 <MINUTES>:<SECONDS>$/"
  unless @ARGV > 0 and shift =~ /([0-9]{1,2}):([0-9]{1,2})/;

print cook($1, $2), $/;

Resultado

andrew@gidget:~$ perl mic.pl 9:00
900S
andrew@gidget:~$ perl mic.pl 1:00
+
andrew@gidget:~$ perl mic.pl 1:01
61S
andrew@gidget:~$ perl mic.pl 1:30
90S
andrew@gidget:~$ perl mic.pl 0:07
 7S
andrew@gidget:~$ perl mic.pl 4:00
400S

rubi

#Build a string for the microwave
def build_result(minutes, seconds)
  duration = minutes * 60 + seconds  
  if duration < 99
    result = "%iS" % [ duration]    #shortcut '90S' instead '130S'
  else
    result = "%i%02iS" % [ minutes, seconds]
  end  
  result
end

#Call microwave optimizer
def microwave( input )
  minutes  = input.split(/:/).first.to_i 
  seconds = input.split(/:/).last.to_i

  #build result
  result = build_result(minutes, seconds)
  #try a shorter result, make 999S out of '10:39':
  if seconds < 40 and minutes > 0
    result2 = build_result(minutes - 1, seconds + 60)   #try a 
    result = ( result.size <= result2.size ? result : result2 )
  end

  #Check if a version with only '+' is shorter
  if seconds == 0 and minutes <= result.size
    result = '+' * minutes
  end
  result
end

#Test if called with an argument
if ARGV.empty?
  require 'test/unit'   #Exceute a test
  class MicrowaveTest < Test::Unit::TestCase
    def test_007
      assert_equal('7S', microwave('0:07'))
    end  
    def test_100
      assert_equal('+', microwave('1:00'))
    end
    def test_101
      assert_equal('61S', microwave('1:01'))
    end  
    def test_130
      assert_equal('90S', microwave('1:30'))
    end  
    def test_400
      #~ assert_equal('400S', microwave('4:00'))
      assert_equal('++++', microwave('4:00'))
    end  
    def test_500
      assert_equal('500S', microwave('5:00'))
    end  
    def test_900
      assert_equal('900S', microwave('9:00'))
    end 
    def test_1000
      #~ assert_equal('1000S', microwave('10:00'))
      assert_equal('960S', microwave('10:00'))
    end 
    def test_1015
      #~ assert_equal('1015S', microwave('10:15'))
      assert_equal('975S', microwave('10:15'))
    end 
    def test_1039
      #~ assert_equal('1039S', microwave('10:39'))
      assert_equal('999S', microwave('10:39'))
    end 
  end
else  #started via shell, evaluate input
  puts microwave(ARGV.first)
end

Observações:

• Comece com ruby program-my-microwave-oven.rbe um teste de unidade é avaliado.
• Comece com ruby program-my-microwave-oven.rb 10:00e escreve960S

Algumas observações sobre as regras (e minha interpretação):

• O mais curto 10:00é 960S(9 minutos e 60 segundos -> 10 minutos).
• O mais curto 10:39é 999S(9 minutos e 99 segundos -> 10 minutos e 39 segundos).
• por 4:00isso prefere ++++(menos movimentos do dedo)