Desafio
Dada uma representação ASCII de um número babilônico como entrada, imprima o número em algarismos arábicos ocidentais.
Sistema Numérico da Babilônia
Como os babilônios contavam? Curiosamente, eles usaram um sistema Base 60 com um elemento de um sistema Base 10. Vamos primeiro considerar a coluna da unidade do sistema:
Os babilônios tinham apenas três símbolos: T
(ou, se você pode renderizá-lo:), 𒐕
que representava 1, e <
(ou, se você pode renderizá-lo:), 𒌋
que representava 10, e \
(ou, se você renderizá-lo:), 𒑊
que representava zero.
Nota: Tecnicamente, \
(ou 𒑊
) não é zero (porque os babilônios não tinham a noção de 'zero'). 'Zero' foi inventado mais tarde, assim \
como um símbolo de espaço reservado adicionado mais tarde para evitar ambiguidade. No entanto, para os propósitos deste desafio, basta considerar \
como zero
Então, em cada coluna você apenas adiciona o valor dos símbolos, por exemplo:
<<< = 30
<<<<TTTTTT = 46
TTTTTTTTT = 9
\ = 0
Nunca haverá mais que cinco <
ou mais que nove T
em cada coluna. \
sempre aparecerá sozinho na coluna.
Agora, precisamos estender isso para adicionar mais colunas. Isso funciona exatamente como qualquer outra base sessenta, onde você multiplica o valor da coluna mais à direita por , o da esquerda por , o da esquerda por e assim por diante. Você então adiciona o valor de cada um para obter o valor do número.60 2
As colunas serão separadas por espaços para evitar ambiguidade.
Alguns exemplos:
<< <TT = 20*60 + 12*1 = 1212
<<<TT \ TTTT = 32*60^2 + 0*60 + 4*1 = 115204
Regras
- Você é livre para aceitar entrada ASCII (
T<\
) ou entrada Unicode (𒐕𒌋𒑊
) - O número inserido sempre estará abaixo de
- Os
<
sempre estarão à esquerda dosT
em cada coluna \
sempre aparecerá sozinho em uma coluna
Ganhando
O menor código em bytes vence.
fonte
<<<<TTTTTT <TTTTTTT <<<<TTTTTT <<<<
"How did the Babylonians count? Interestingly, they used a Base 60 system with an element of a Base 10 system."
Que ainda está em uso hoje; o sistema numérico da Babilônia é exatamente o que usamos para relógios. Dois dígitos decimais para segundos, minutos e horas, 60 segundos para o minuto, 60 minutos para a hora.Respostas:
JavaScript (ES6), 44 bytes
Recebe entrada como uma matriz de caracteres ASCII.
Experimente online!
Quão?
O Sistema Numérico da Babilônia pode ser visto como uma linguagem de quatro instruções que trabalha com um único registro - vamos chamá-lo de acumulador.
Começando com , cada caractere na matriz de entrada modifica o acumulador seguinte maneira:c a kk = 0 c uma k
space
: multiplique por (implementado como: adicione a )60 59 k k<
: adicione akT
: incremento\
: fazer nada; esta é aNOP
instrução deste idioma (implementada como: adicione a )kfonte
C (gcc) ,
140138136 bytesExperimente online!
fonte
Perl 6 , 39 bytes
-3 bytes graças a nwellnhof
Experimente online!
Usa os caracteres cuneiformes.
Explicação:
fonte
{:60[.words>>.&{sum (.ords X%151)X%27}]}
(40 bytes)Geléia ,
1312 bytesUm link monádico que aceita uma lista de caracteres que gera um número inteiro.
Experimente online!
Quão?
Outro 12:
ḲO⁽¡€%:5§ḅ60
(⁽¡€
é1013
, por isso este modulos1013
pelosO
valores rdinal recebendo53
,5
e1
para<
,T
,\
respectivamente, em seguida, executa inteiro divisão,:
por5
chegar10
,1
e0
)fonte
05AB1E , 13 bytes
Experimente online!
Para compensar o quão preguiçoso eu tenho com a minha resposta Jelly, aqui está uma submissão em 05AB1E xD.
fonte
8740
?•Yη•
(4 bytes)1|Ç7%-13%O60β
também tem 13 anos - é jogável?Python 2 ,
96938785 bytesExperimente online!
Salvou:
fonte
(ord(c)%5/2or 11)-1
8740%ord(c)/4
Excel VBA, 121 bytes
Restrito ao Office de 32 bits, como
^
serve comoLongLong
literal de tipo nas versões de 64 bitsLeva a entrada da célula
A1
e sai para a janela imediata do vbe.Sem Golfe e Comentado
fonte
Dyalog APL ,
3330 bytesExperimente online!
Edit: -3 bytes graças a ngn
'\ T<'⍳
substitui os caracteres por números (sua posição na constante da string) e⌽
inverte a entrada para que os 'dígitos' mais significativos sejam os últimos. Isso permite+\2=
manter uma contagem60*
contínua da potência desejada de 60 (aplicada por ) contando o número de vezes que um espaço (índice 2 na constante da cadeia) é encontrado.⌊10*⍵-3
dá a potência desejada de dez para cada personagem. A ordem dos caracteres na constante da string e o deslocamento -3 fazem com que '\' e espaço passem para números negativos, resultando em frações quando esses caracteres são elevados à potência de 10, permitindo que sejam eliminados por⌊
.Tudo o que precisamos fazer agora é multiplicar as potências de 10 dígitos pelos valores das potências de 60 e resumir o lote
+/
.fonte
' '
:{+/(⌊10*⍵-3)×60*+\2=⍵}'\ T<'⍳⌽
Python 2 , 62 bytes
Experimente online!
Isso usa a técnica da resposta de Arnauld .
fonte
Tela ,
201716 bytesExperimente aqui!
Explicação:
fonte
APL (NARS ←io ← 0), 28 caracteres, 56 bytes
algum teste com verificação de tipo:
Cada resultado do tipo é número.
fonte
JavaScript (Node.js) ,
12211410710683 bytesExperimente online!
Estou um pouco obcecado com operações de matriz "estilo funcional", usa entrada ASCII, tanto quanto posso dizer, JS não é muito bom em obter códigos de golfe
Eu estou mantendo isso por causa da posteridade, mas essa é uma solução ingênua / burra, sugiro que você verifique a resposta de Arnauld, que é muito mais interessante na implementação do desafio
fonte
c<'T'
trabalha no lugar dec=='<'
&&
por|
.for...of
loops: PRetina ,
292623 bytesExperimente online! Usa separação de nova linha, mas o link inclui o cabeçalho para usar espaços, por conveniência. Editar: salvou 3 bytes com a ajuda de @KevinCruijssen. Economizei mais 3 bytes graças a @FryAmTheEggman. Explicação:
Substitua cada um
<
por 10T
s.Pegue a primeira linha, multiplique-a por 60 e adicione a próxima linha. Em seguida, repita até restar apenas uma linha.
Conte os
T
s.Versão mais rápida de 51 bytes:
Experimente online! Usa separação de nova linha, mas o link inclui o cabeçalho para usar espaços, por conveniência. Explicação:
Combine cada linha individualmente e conte o número de se
T
10 vezes o número de<
s. Isso converte cada linha em seu valor "dígito" de base 60.Conversão de base 60, executando uma linha por vez. O cálculo é feito em decimal para velocidade.
fonte
<
sem a+
, a menos que eu não esteja vendo algum tipo de caso extremo.$&
agora é sempre um caractere, posso usar o caractere padrão, economizando mais dois bytes!_
tempo$*
nas versões anteriores do Retina por padrão1
.<
as correspondências únicas e as repetia 10 vezes o comprimento (a quantidade<
correspondente na correspondência), e minha alteração proposta é repetida a cada<
10 vezes separadamente (que você gastou mais 2 bytes usando o 1 implícito com10*
) Agora eu entendo melhor porque o+
estava lá inicialmente. Eu não sei muito sobre os retins internos da Retina, apenas regexes em geral, daí a minha alteração proposta porque eu já a li como repetida a cada>
10 vezes. ;)Bash (com sed e dc), 50 bytes
Leva a entrada delimitada por espaço de
stdin
, produz parastdout
Experimente online!
Explicação
Usa sed para transformar a entrada com
<<<TT \ TTTT
várias correspondências de expressões regulares até que, por exemplo, a entrada tenha sido transformada emA+A+A+1+1+60*60*1+1+1+1+
. Em seguida, essa entrada é alimentada em dc com o comando explícito de execução de entrada?
, precedido porz
(empurra o comprimento da pilha (0) para a pilha para que tenhamos algum lugar para fundamentar a adição) e seguido porp
(imprimir).fonte
J ,
3430 bytesExperimente online!
fonte
Dyalog APL,
3532 bytesExperimente online!
31 em dzaima / APL
fonte
Noether , 55 bytes
Experimente online!
A mesma abordagem que @Arnauld.
fonte
Carvão , 26 bytes
Experimente online! Link é a versão detalhada do código. Explicação:
Limpe o resultado.
Faça um loop sobre os caracteres de entrada. O
≡
comando é agrupado em um bloco para impedir que ele encontre um bloco "padrão".Alterne o caractere atual ...
se for um espaço, multiplique o resultado por 60 ...
se for um
<
, adicione 10 ao resultado ...se for um
T
incremento do resultado.Imprima o resultado.
fonte
R ,
9881 bytesExperimente online!
Ridiculamente longo devido à análise de string.Obrigado ao Giusppe por eliminar 16 bytes desnecessários.Defina
y
o valor do bytecode da entrada unicode eR = y("T<\") = y("𒐕𒌋𒑊")
Observe isso
R%%3 = 1,2,0
eR%%6 = 1,5,0
... entãoR%%3 * R%%6 = 1,10,0
!O resto é fácil: soma por coluna e produto pontual com potências decrescentes de 60.
fonte
scan(,"")
divide os espaços automaticamente?/60
pode ser substituído-1
na expressão expoente por outro byte desativado, além do que<-
pode ser substituído por,=
pois está tudo entre parênteses.Ruby ,
5046 bytesExperimente online!
Uma porta básica da resposta de Arnauld foi aprimorada em GB por -4 bytes.
fonte
C (gcc) ,
656463 bytesExperimente online!
fonte
return o
pors=o
salva outros 5 bytes.Java 8,
6460 bytes-4 bytes graças a @ceilingcat .
Experimente online. Explicação:
fonte
Perl -F // -E, 39 bytes
Lê o número a ser convertido de STDIN.
É essencial a mesma solução fornecida pelo @Arnauld usando JavaScript.
fonte
F #, 128 bytes
Experimente online!
Ungolfed ficaria assim:
Seq.mapFoldBack
combinaSeq.map
eSeq.foldBack
.Seq.mapFoldBack
itera pela sequência para trás e encadea um valor acumulador pela sequência (nesse casoi
).Para cada elemento da sequência, o número babilônico é calculado (por
Seq.sumBy
, que mapeia cada caractere para um número e totaliza o resultado) e depois multiplicado pori
.i
é então multiplicado por 60 e esse valor é passado para o próximo item na sequência. O estado inicial do acumulador é 1.Por exemplo, a ordem das chamadas e os resultados
Seq.mapFoldBack
para entrada<<<TT \ TTTT
seria:A função retornará uma tupla de
seq<int>, int
. Afst
função retorna o primeiro item nessa tupla eSeq.sum
faz a soma real.Por que não usar
Seq.mapi
ou similar?Seq.mapi
mapeia cada elemento na sequência e fornece o índice para a função de mapeamento. De lá, você poderia fazer60 ** index
(onde**
está o operador de energia em F #).Mas
**
exigefloats
, nãoints
, o que significa que você precisa inicializar ou converter todos os valores na função comofloat
. Toda a função retornará afloat
, o que (na minha opinião) é um pouco confuso.Usá-
Seq.mapi
lo pode ser feito assim para 139 bytes :fonte
Tcl , 134 bytes
Experimente online!
Na lista invertida, faço um loop incrementando o resultado na contagem
<
eT
(com a-all
opção regexp) e incrementando uma potência natural como 60.Versão correta (ver comentário)
fonte
regsub {\\} $l0 l
antes do loop foreach ....APL (Dyalog Extended) , SBCS de 18 bytes
Função de prefixo tácito anônimo.
Experimente online!
fonte
05AB1E (herdado) , 10 bytes
Experimente online!
05AB1E , 11 bytes
Experimente online!
O mesmo algoritmo, mas no 05AB1E moderno
O
não funciona em listas de entradas e listas mistas, por isso precisamos€O
.fonte