A maioria das pessoas aqui estão familiarizadas com sete displays de segmento, que também são usados em quebra-cabeças de palitos de fósforo. Abaixo estão os dígitos 0através de 9e cartas aatravés z, exceto k,m,t,v,w, escritos neste formato.
_ _ _ _ _ _ _ _
| | | _| _| |_| |_ |_ | |_| |_|
|_| | |_ _| | _| |_| | |_| _|
_ _ _ _ _ _ _ _ _
|_| |_ | _| |_ |_ | |_ | | | _ _ |_| |_| _ |_ |_| |_| _|
| | |_| |_ |_| |_ | |_| | | | |_| |_ | | |_| | | | _| |_| | | | |_
O desafio aqui é simples. Dada uma sequência de entrada, produza o número de palitos de fósforo necessários para representar essa sequência. Se a string contiver um caractere fora da representação acima, ignore-a (conte-a como 0).
Por exemplo, para entrada 53, 10são necessários um total de palitos de fósforo, 5para 5e 5para 3, portanto a saída é 10.
Para entrada, é necessário helloum total de 19palitos de fósforo h (4), e (5), l (3), l (3), o (4), portanto a saída é 19.
Para maior clareza, aqui estão os palitos de fósforo necessários para criar cada personagem:
0 -> 6
1 -> 2
2 -> 5
3 -> 5
4 -> 4
5 -> 5
6 -> 6
7 -> 3
8 -> 7
9 -> 6
a -> 6
b -> 5
c -> 4
d -> 5
e -> 5
f -> 4
g -> 5
h -> 4
i -> 2
j -> 4
l -> 3
n -> 3
o -> 4
p -> 5
q -> 5
r -> 2
s -> 5
u -> 3
x -> 5
y -> 4
z -> 5
Agora, para a reviravolta, e há dois deles.
- A primeira é que a entrada é considerado caso- em sensível. Ou seja,
Aeaambos devem contar para6palitos de fósforo, mesmo que a representação visual pareça maiúsculaA. - Sua pontuação é o seu código-fonte executado nesse algoritmo; além do tamanho do seu código-fonte em bytes, quanto menor, melhor. Por exemplo, se o seu código-fonte fosse
abc123, sua pontuação seria6+5+4+2+5+5 = 27 + 6 = 33. Se o seu código-fonte fosse#&@()*, sua pontuação seria0 + 6 = 6.
Exemplos de entrada / saída
0 -> 6
53 -> 10
111 -> 6
112 -> 9
8888 -> 28
hello -> 19
PPCG -> 19
Programming Puzzles & Code Golf -> 99
#&()mt!!~ -> 0
*DḌƤÆE%Ḅċ0 -> 16
Regras
- Se aplicável, você pode supor que a entrada / saída caiba no tipo Inteiro nativo do seu idioma.
- A entrada e saída podem ser fornecidas por qualquer método conveniente .
- Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
- As brechas padrão são proibidas.
fonte
|_\n|_(em minúsculast)[0-9a-z], devemos contar 0 palitos de fósforo? Isso é o que eu entendo em Sua pontuação: seu código-fonte é executado nesse algoritmo , além do tamanho do seu código-fonte em bytes .Respostas:
Python 2 , 97 bytes + 237 correspondências = 334
Experimente online!
Isso funciona gerando uma sequência em que cada caractere edificável aparece com a mesma quantidade de palitos de fósforo necessários para criar esse caractere
fonte
+'069a8'*6+'8')vez de+'069a'*6+'8'*7).Perl 5 com
-pF, 95 bytes + 14, 109Isso é equivalente a:
mas, usando o
~operador, podemos usar caracteres de byte alto e evitar muitos caracteres sem sacrificar os bytes.Ainda muito longe da pontuação de Ton, mesmo com assistência!
Experimente online!
Esta solução contém imprimíveis, então aqui está um dump hexadecimal reversível para verificar a contagem de bytes:
fonte
}{? Solte-o e a-nopção. Além disso você continua esquecendo+lcvez delc():-)+não me vem à mente imediatamente! Precisonna minha máquina e esqueço que posso largar!}{e-p" (e substituí-la-nse o seu perl ainda precisa dele hoje em dia não conta qualquer maneira.)JavaScript (ES6), 198 (102 bytes + 96 palitos de fósforo)
Economizou 5 pontos graças a @ l4m2
Experimente online!
Quão?
Usamos o módulo 9 do código ASCII de caracteres que não adiciona nenhuma penalidade para codificar o número de palitos de fósforo.
Não precisamos nos preocupar com o caso, porque não
parseInt()faz distinção entre maiúsculas e minúsculas.Para caracteres que não correspondem a [0-9A-Za-z] ,
parseInt()retornosNaNe a pesquisa de sequência resultam emundefined. Uma vez coagido a uma sequência,"undefined".charCodeAt()retorna o código ASCII de"u", que é 117 . Convenientemente, 117 módulo 9 fornece 0 como esperado.fonte
v=>[...v].map(w=>t+='~{w__^_{]|{{_^__^_^w^~]~]^__w_~]~~_^_'.charCodeAt(1+parseInt(w,36))%9,t=+[])|t1 menosGeleia , 42 bytes + 0 palitos de fósforo = 42 pontos
Graças a @ Jonathanon Allan por -2 pontos!
Experimente online!
Como funciona
Os literais que começam com
“e terminam com’divisão“, substituem os caracteres restantes pelos índices baseados em 1 na página de código de Jelly e depois convertem da base bijetiva 250 para inteiro.Esse literal literal codifica
×/reduz por multiplicação, produzindo(Codificar esse número inteiro economizaria 6 bytes, mas custaria 28 palitos de fósforo.)
ṚṚreverte duas vezes; a primeira chamada promove um número inteiro para sua matriz de dígitos. Isso geraċЀØW$conta (ċ) as ocorrências de cadaЀcaractere ( ) de "A ... Za ... z0 ... 9_" (ØW) na sequência de entrada.Finalmente,
æ.pega o produto escalar, multiplicando cada contagem de caracteres pelo custo correspondente em palitos de fósforo e, em seguida, obtendo a soma.fonte
Dsalvar outro. Experimente onlineƊ. Obrigado!Código Perl 5
-p,9064 + 9 chicotes eval + 14 palitos de fósforo = 87Substitua os códigos hexadecimais pela variante literal de 1 byte ( não UTF-8, como o TIO tenta) pela pontuação reivindicada
Experimente online!
Código Dentro da sequência complementada:
fonte
Geléia , 34 bytes + 3 correspondências = 37
Um link monádico que aceita uma lista de caracteres e retorna um número inteiro.
Experimente online!
Quão?
Funciona de maneira semelhante à resposta de Dennis 'Jelly, mas foi necessário esforço suficiente para que eu justifique outra resposta. A principal diferença é que ela diminui a entrada para um custo de três correspondências (
Œlcontém uml), o que permite que um número muito menor seja usado para criar a matriz de custos. A parte complicada foi encontrar uma maneira de construir esse número sem correspondências, mantendo-se conciso.ØWproduz,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"portanto, contar as ocorrências de entrada com letras minúsculas sempre começa com 26 zeros. Podemos reverter isso e executar um produto escalar com uma matriz de comprimento 37 em vez de uma de comprimento 63.fonte
PHP 176 bytes = 397 pontos
Experimente online!
fonte
SOGL V0.12 , 34 bytes + 18 = 52
Experimente aqui!
Jogou golfe, mas não marcou tanto :
fonte
Python 3 , 138 + 265 = 403 bytes
Experimente online!
fonte
Ruby , 125 bytes + 87 palitos de fósforo = 212
Experimente online!
Fortemente inspirado pela resposta Javascript de Arnauld .
Normalmente, o custo de declarar um lambda para ser usado apenas duas vezes não vale a pena, mas o peso do palito de fósforos "
scanap".scan(/./).mapmudou isso. Este foi um desafio divertido!fonte
MATL , pontuação
166156Comprimento do código 41 + saída para o código usado como entrada 115.
Experimente online!
fonte
R, 112 bytes + 319 correspondências = 431 pontos
Experimente online!
Parabéns a Giuseppe, que apresentou essa melhoria.
Versão antiga, 143 bytes + 454 correspondências = 597 pontos
Para fazer a
el()função funcionar no TIO, você precisa usarlibrary(methods).Meu Deus, é R detalhado!
fonte
methodspacote automaticamente , mas como é umbasepacote, sempre o empurrei no cabeçalho e não o conto para a contagem de bytes.readlinetambém não funcionará no TIO, pois não é uma sessão interativa. Isso é definitivamente jogável, no entanto.Perl 6 , 87 bytes + 26 palitos de fósforo = 113
Experimente online!
Usa alguns caracteres Unicode não ASCII. A tabela de pesquisa é codificada em uma sequência Unicode:
Os caracteres são convertidos em índices com a conversão de base 36 usando algarismos em indicativo árabe:
fonte
sed, 367 (bytes do código-fonte) + 532 (quantidade de palitos de fósforo para o código-fonte) = 899
Experimente Online
Versão multilinhas:
Explicação:
O script acima lê a entrada padrão linha por linha (no espaço do padrão - o "modo sed" usual)) e, para cada linha, gera a quantidade de palitos de fósforo necessários para representar todos os caracteres representáveis pelo palito de fósforo nessa linha. Os cálculos para cada linha de entrada acontecem da seguinte maneira:
Primeiro, removemos todos os caracteres para os quais não temos uma representação de palito de fósforo correspondente (conforme fornecido na pergunta) do espaço do padrão. Ou seja, removemos todos os caracteres que não são um número de "0" a "9", uma letra de "a" a "j", "n" a "s", "l", "u", "x", "y" ou "z". Letras maiúsculas e minúsculas são tratadas da mesma forma.
Se acabarmos com um espaço de padrão vazio, imprimiremos 0 (automaticamente seguido por uma nova linha, como sed sempre faz a menos que você passe uma bandeira especial), pularemos todas as linhas posteriores do script e prosseguiremos para o próximo "ciclo sed" ( ou seja, leia a próxima linha de entrada e repita o processamento novamente desde o primeiro comando até que não haja mais linhas de entrada a serem processadas).
Caso contrário, se o espaço do padrão não estiver vazio, agora o dividimos em dois "subespaços" separados por ponto e vírgula: primeiro, o espaço de entrada , formado inicialmente por todos os caracteres que não foram removidos do espaço do padrão após o execução da linha 1; a seguir, vem o ponto-e-vírgula e, depois, o espaço do mapa .
O espaço do mapa indica quantos palitos de fósforo ao lado de 1 são necessários para representar cada caractere alfanumérico relevante. Se quisermos saber quantas palitos de fósforo são necessários para representar qualquer caractere alfanumérico no espaço do mapa, procuraremos a primeira sequência de% 's contíguos à esquerda desse caractere e a resposta será o número de%' s em essa sequência mais 1. Portanto, por exemplo, o número de palitos de fósforo necessários para representar um "b" é 4 + 1 = 5; representar um "4", 3 + 1 = 4, representar um "y", 3 + 1 = 4; e assim por diante.
Este é um loop. Agora, substituiremos todos os caracteres no espaço de entrada pela sequência (completa) de% s cujo número indica a quantidade necessária de palitos de fósforo para representar esse caractere e seguiremos essa sequência por um caractere de espaço em branco (novamente, letras maiúsculas e minúsculas são dado o mesmo tratamento). O critério para determinar se o loop deve terminar é verificar se há um caractere de espaço em branco na esquerda imediata do ponto e vírgula no espaço do padrão: se essa condição for válida, encerramos o loop e continuamos na próxima linha.
Essas duas linhas removem o ponto e vírgula e tudo depois do espaço do padrão e, em seguida, inserem uma vírgula e um ponto e vírgula no início do espaço do padrão. Agora, temos o espaço padrão dividido novamente em dois novos subespaços: o espaço de resultado analógico antes do ponto e vírgula e o espaço de entrada analógica depois dele.
O espaço de entrada analógica é exatamente o que chamamos anteriormente de "espaço de entrada", mas de uma forma diferente: agora contém seqüências de% s separadas por espaço em branco. O número total desses% 's no espaço de entrada analógica é o mesmo número de palitos de fósforo necessários para representar a cadeia de caracteres de entrada inicial, ou seja, esse número é o resultado. Mas devemos imprimir esse resultado em notação decimal, não como uma sequência de sinais de porcentagem. O objetivo do espaço de resultados analógico é manter uma representação analógica de cada dígito do resultado enquanto calculamos esse resultado somando cada sequência contígua de% s no espaço de entrada analógica, um por um. O próximo loop executa essa soma:
Primeiro, após o rótulo 2 , movemos a próxima sequência contígua de% s após o ponto e vírgula do espaço de entrada analógica para a esquerda imediata do ponto e vírgula, no espaço de resultado analógico;
Em seguida, entramos em um sub-loop (rótulo 3 ) que executa os seguintes cálculos:
Se houver uma sequência contígua de dez% 's após uma vírgula no espaço de resultado analógico, removemos esses%' s e colocamos um único% imediatamente à esquerda da vírgula. Simplificando, isso indica que uma das casas decimais no resultado adquiriu mais de 9 unidades, portanto, retiramos 10 unidades dessa casa decimal e adicionamos 1 unidade à próxima casa decimal maior;
Se um "%" for o primeiro caractere no espaço do padrão, inseriremos uma nova vírgula imediatamente antes dele. Isso indica que a soma atingiu um valor cuja representação decimal tem mais uma casa decimal à esquerda que o valor anterior;
Se ainda houver uma sequência contígua de dez% no espaço de resultados analógicos, voltamos ao rótulo 3 e repetimos esse processo. Caso contrário, sairemos deste sub-loop e passaremos para a próxima linha.
Agora, se ainda houver "%" no espaço de entrada analógica (ou seja, após o ponto-e-vírgula), significa que ainda há algum número de palitos de fósforo a serem adicionados à soma total - então voltamos ao rótulo 2 .
Depois que a soma estiver concluída, entramos no loop final do código:
Aqui, verificamos todos os caracteres formados por uma vírgula à esquerda e um ponto-e-vírgula ou uma vírgula à direita. Substituímos todos esses pares de caracteres por um "0" dentro de duas vírgulas.
O trecho de código acima é bastante simples: substituímos cada sequência contígua de% 's no espaço de resultados analógico por um caractere de dígito decimal que corresponde ao número de%' s em cada sequência específica.
Finalmente, removemos todos os caracteres não numéricos do espaço do padrão e o que resta é o resultado final na notação decimal familiar. Esse valor é impresso na saída padrão e o próximo ciclo sed começa, se houver mais linhas de entrada a serem processadas.
fonte
C (gcc) , 134 bytes + 38 palitos de fósforo = 172
Experimente online!
fonte
05AB1E , 30 bytes + 70 correspondências = pontuação 100
Experimente online!
-5 graças a Emgina
fonte
Al=A. Você também não precisa do}.Pontuação do Java 10,
452432416404 (145 bytes + 259 correspondências)Explicação:
Experimente online.
Nomes de variáveisEDIT: nomes de variáveis$ραετsão usados em vez de letras.kmtvwagora são usados, porque não podem ser formados por correspondências de acordo com a descrição do desafio.''(não imprimível) é usado em vez de6.m-met-tsão usados em vez de0.(char)(w|32)+""com entrada de matriz de caracteres usada em vez dew.toLowerCase()com entrada de matriz de caracteres.fonte
AutoHotkey , 148 bytes + 345 palitos de fósforo = 493
Este foi um desafio para encurtar.
fonte
Python 3 , 123 bytes + 65 correspondências = 188
Uma função sem nome que aceita uma sequência e retorna um número inteiro.
Contém muitos caracteres não imprimíveis (especificamente bytes de um a oito).
Experimente online!
fonte
Carvão , 48 bytes + 3 = 51
Experimente online! Link é a versão detalhada do código. Explicação:
Faça um loop sobre os caracteres da entrada, calculando o número de palitos de fósforo de cada um, depois some o resultado, converta em sequência e imprima implicitamente.
Se é uma carta ...
Procure o número de palitos de fósforo na sequência compactada
65455454240303455250300545.Caso contrário, se aparecer no valor de
2 ** 1000...Procure o número de palitos de fósforo na sequência compactada
6255456376.fonte
PHP, 98 + 253 = 351
Execute como pipe
-nrou experimente online .fonte