Dado um número inteiro positivo, produza um valor de verdade / falsidade para saber se o número pode comer sozinho.
Regras
Mais à esquerda é a cabeça, mais à direita é a cauda
Se a cabeça é maior ou igual à cauda, a cabeça come a cauda e a nova cabeça se torna sua soma.
Se , a cabeça é substituída por .
não pode ser ignorado, no entanto, o número de entrada nunca terá nenhum zero inicial.
Exemplo:
number=2632
head-2, tail-2
2632 -> 463
head-4, tail-3
463 -> 76
head-7, tail-6
76 -> 3
If only one digit remains in the end, the number can eat itself.
Se em algum momento a cabeça não puder comer o rabo, a resposta será falsa.
number=6724
072
False (0<2)
Casos de teste:
True:
[2632, 92258, 60282, 38410,3210, 2302, 2742, 8628, 6793, 1, 2, 10, 100, 55, 121]
False:
[6724, 47, 472, 60247, 33265, 79350, 83147, 93101, 57088, 69513, 62738, 54754, 23931, 7164, 5289, 3435, 3949, 8630, 5018, 6715, 340, 2194]
Isso é código-golfe, então o código mais curto vence.
code-golf
decision-problem
Vedant Kandoi
fonte
fonte
Respostas:
JavaScript (ES6),
52 5150 bytesGuardado 1 byte graças a @tsh
Recebe a entrada como uma sequência. Retorna um valor booleano.
Experimente online!
Comentado
fonte
f=n=>n>[n%10]?f(-(-n[0]-n)%10+n.slice(1,-1)):!n[1]
Gelatina , 11 bytes
Experimente online!
Como funciona
fonte
Perl 6 ,
6362 bytesExperimente online!
Explicação:
fonte
Java (JDK) , 83 bytes
Experimente online!
Créditos
fonte
/10
e%10
em um loop. Tão bem feito ao vencer as respostas do Python; +1 de mim. :)r+=
parar=
e?1:0
para?1:r
.r=1
r&=h<n%10?0:r;return r;
Mathematica, 62 bytes
Primeiro chame
IntegerDigits
a entrada para obter uma lista de seus dígitos e, em seguida, aplique repetidamente a seguinte regra:A regra é aplicada até que o padrão não corresponda mais; nesse caso, resta apenas um dígito (verdade) ou a cabeça é menor que a cauda (falsidade).
Em vez de chamar
Length[__]==1
, podemos salvar alguns bytes0(__)=={0}
, multiplicando todos os elementos da lista0
e comparando-os com a lista{0}
.fonte
Python 3 , 50 bytes
Primeira linha roubada da resposta de Black Owl Kai .
Experimente online!
A saída é via código de saída. Falha (1) para entradas falsas e acabamentos (0) para entradas verdadeiras.
fonte
p%10<k>q
que não lança um NameError sep%10 >= k
?p%10<k>q
faz o mesmo quep%10<k and k>q
.Python 2 ,
1058281 bytesExperimente online!
Muito obrigado por um enorme -23 de @ ØrjanJohansen
Obrigado a @VedantKandoi (e @ ØrjanJohansen) por mais -1
fonte
for
com uma fatia inversa e também fazer o%10
único ao testar: Experimente online!if i[0]<i[-1]:x=0
e , em seguidaelse:....
. @ ØrjanJohansen, na sua resposta também.True
casos, mas não para todos osFalse
.Braquilog , 23 bytes
Experimente online!
Esta é uma economia de 1 byte na solução da Fatalize . Isso usa uma abordagem recursiva em vez de uma iterativa
Explicação
fonte
APL (Dyalog Unicode) , SBCS de 33 bytes
Função de prefixo tácito anônimo usando uma string como argumento.
Experimente online!
⍎¨
avalie cada caractere (isso nos fornece uma lista de dígitos){
...}
aplique o seguinte "dfn" a isso;⍵
é o argumento (lista de dígitos):⌽⍵
inverter o argumento⊃
escolha o primeiro elemento (esta é a cauda)t←
atribuir at
(para t ail)⍵<
para cada um dos dígitos originais, veja se é menor que isso⊃
escolha o primeiro verdadeiro / falso:
se então:0
retorna falso⋄
então:3::
se a partir de agora, ocorrer um erro de índice (fora dos limites):1
retornar verdadeiro¯1↓⍵
solte o último dígito⊢
produz que (separa1
e¯1
assim eles não formarão uma única matriz)t+@1
adicione a cauda ao primeiro dígito (a cabeça)10|
mod-10∇
recursoQuando atingirmos um único dígito, a lista
¯1↓
será vazia e@1
causará um erro de índice, pois não há um primeiro dígito, fazendo com que a função retorne verdadeira.fonte
Python 3 , 77 bytes
Experimente online!
E minha solução antiga com uma abordagem recursiva
Python 3 , 90 bytes
Experimente online!
Recebe a entrada como uma sequência.
fonte
Braquilog , 24 bytes
Experimente online!
Devo alterar
ⁱ
o comportamento padrão da iteração para iterar um número desconhecido de vezes (atualmente, iterará 1 vez por padrão, o que é completamente inútil). Eu então não precisaria do[…];I[…]⁾
, economizando 3 bytesExplicação
Este programa contém um garfo feio dentro de um garfo. Há também algum encanamento necessário para trabalhar em listas de dígitos em vez de números (porque se removermos a cabeça e a cauda de
76
nós, ficaremos com isso0
, o que não funcionará ao contrário de[7,6]
onde terminamos[]
).fonte
,
eu poderia remover 1 byte Experimente online!Haskell,
706460 bytesA entrada é tomada como uma sequência.
Experimente online!
Edite: -6 bytes usando o truque de @ Laikoni em
||
vez de usar guardas separados. Mais -4 bytes graças a @Laikoni.fonte
read[l b]
pode ser apenasread b
porque você olha apenas para o último dígito de qualquer maneira. Economiza mais 4 bytes também alinhandolast
: Experimente on-line!Perl 5 , 64 bytes
Experimente online!
fonte
Python 2 ,
7567 bytesExperimente online!
Abordagem recursiva lambda. Recebe a entrada como uma sequência. Muito obrigado a Dennis por economizar 8 bytes!
fonte
Haskell ,
6964 bytesExperimente online! Exemplo de uso:
f 2632
rendimentosTrue
.Editar: -5 bytes porque
mod (h + mod n 10) 10 = mod (h + n) 10
fonte
||
, o que também me ajudou a diminuir minha resposta. Obrigado!Ruby, 139 bytes
Experimente online! (possui algum código extra para processar a entrada, pois é uma função)
Código não destruído:
fonte
Retina 0.8.2 , 42 bytes
Experimente online!O link inclui casos de teste. Explicação:
Converta os dígitos em unários e insira separadores.
Se o último dígito não for maior que o primeiro, adicione-os.
Reduza o módulo 10, se apropriado.
Repita até o último dígito ser maior que o primeiro ou restar apenas um dígito.
Teste se resta apenas um dígito.
fonte
05AB1E ,
262524 bytesProvavelmente pode ser jogado um pouco mais .. Parece muito longo, mas talvez o desafio seja em termos de código mais complexo do que eu pensava anteriormente.
Experimente online ou verifique todos os casos de teste .
Explicação:
fonte
C ++ (gcc) , 144 bytes
Experimente online!
Na primeira vez que estou tentando algo assim, se formatar algo errado, avise-me. Não tenho 100% de certeza sobre as regras para coisas como o uso de namespace para eliminar os 5 bytes "std ::", então deixei dentro.
Ungolfed:
fonte
#include
declarações. No entanto, eu proporia a programação no subdialeto std lib facilities do C ++ com o#include "std_lib_facilities.h"
prefixado, o que também faz ausing namespace std;
. Esse cabeçalho foi escrito pelo autor do idioma de volta (a última versão é 2010) para os novos alunos do C ++.#import<string>
. Experimente online!#!/usr/bin/sh
newlinegcc -include "std_lib_facilities.h" $@
- se eu encontrar um curso C ++ que forneça esse shell script, isso contaria?-include iostream
, trata-se de 144 bytes.C #, 114 bytes
Experimente online
fonte
C (gcc) (com string.h) ,
110108 bytesExperimente online!
Ainda relativamente novo no PPCG, a sintaxe correta para vincular bibliotecas como um novo idioma é estranha para mim. Observe também que a função retorna 0 ou 1 para false / true e a impressão resultante para stdout exige stdio. Se estivermos sendo pedantes e o exercício exigir saída, o idioma requer stdio que tão bem.
Conceitualmente semelhante à resposta do @ BenH, mas em C, então parabéns pelo seu vencimento (Bem-vindo ao PPCG, btw), mas usando recursão. Ele também usa aritmética de ponteiro de matriz, porque o código sujo é mais curto que o código limpo.
A função é recursiva de cauda, com condições de saída se o primeiro número não puder comer o último ou se o comprimento for 1, retornando falso ou verdadeiro, respectivamente. Esses valores são encontrados desreferenciando um ponteiro para a C-String (que fornece um caractere) no início e no final da string e fazendo as comparações sobre eles. A aritmética do ponteiro é feita para encontrar o final da string. finalmente, o último caractere é "apagado" substituindo-o por um terminador nulo (0).
É possível que a aritmética do módulo seja encurtada em um byte ou dois, mas eu já preciso de um banho após a manipulação do ponteiro.
Versão Ungolfed Aqui
Atualização: salvou dois bytes substituindo c == 1 por! C. Isso é essencialmente c == 0. Ele executará um tempo adicional e desnecessariamente se duplicará antes de se excluir, mas salva dois bytes. Um efeito colateral é que as cadeias de comprimento nulo ou zero não causam recursão infinita (embora não devamos obter cadeias nulas, pois o exercício indica números inteiros positivos).
fonte
gcc
- embora os avisos sejam gerados,gcc
o código será compilado sem#include
s. Além disso, você pode salvar 4 bytes com-DR=return
. Finalmente, no seu código de teste, os\0
são desnecessários, pois a string já os inclui implicitamente.b=case1?res1:case2?res2:res_else;
é o mesmo queif(case1)return res1;if(case2)return res2;return res_else;
c
: você pode determinar se a string tem comprimento zerohead-tail
.Powershell, 89 bytes
Importante! O script se chama recursivamente. Então salve o script como
g.ps1
arquivo no diretório atual. Além disso, você pode chamar uma variável de bloco de script em vez de arquivo de script (consulte o script de teste abaixo). Isso chama tem o mesmo comprimento.Nota 1: O script usa uma avaliação lenta dos operadores lógicos
-or
e-and
. Se"$args"-notmatch'(.)(.*)(.)'
forTrue
, a subexpressão correta de-or
não será avaliada. Além disso, se($m=$Matches).1-ge$m.3
forFalse
, a subexpressão correta de-and
também não será avaliada. Portanto, evitamos recursões infinitas.Nota 2: A expressão regular
'(.)(.*)(.)'
não contém âncoras de início e fim porque a expressão(.*)
é gananciosa por padrão.Script de teste
Saída:
PowerShell, 90 bytes
Sem recursão. Nenhuma dependência de nome de arquivo e nenhuma dependência de nome de bloco de script.
Um PowerShell converte implicitamente um operando direito em um tipo de operando esquerdo. Portanto,
$s-ge$s%10
calcula o operando direito$s%10
comointeger
e o compara como umstring
tipo porque o operando esquerdo éstring
. E2+$s[0]+$s
converte um caractere$s[0]
e uma string$s
parainteger
porque o operando esquerdo2
é inteiro.$s|% S*g 1($s.Length-2)
é um atalho para$s.Substring(1,($s.Length-2))
fonte
C # (compilador interativo do Visual C #) , 69 bytes
Experimente online!
Sucesso ou fracasso é determinado pela presença ou ausência de uma exceção . A entrada está no formato de uma sequência.
Menos golfe ...
Existem alguns bytes extras para lidar com a conversão entre caracteres e dígitos, mas no geral isso não afetou muito o tamanho.
fonte
Perl 5
-pF
, 53 bytesExperimente online!
fonte
Braquilog , 18 bytes
Experimente online!
Leva três bytes off solução de Fatalize apenas em virtude de superscriptless não-determinístico
ⁱ
existente agora, mas perde outros três, fazendo coisas vagamente inspirados Jelly comz₁
evitar o usoc
,g
ou até mesmoh
. (Também inspirado por tentar, e falhar, usar um novo recurso diferente: oʰ
metapredicado.)fonte
PowerShell ,
9491 bytesExperimente online!
Script de teste
Código não destruído:
fonte
$n[0]
suafor
declaração - basta verificar$n
.-6
em vez-96
porque é o suficiente para calc% 10return
e salvar 7 bytesparam($n)
oufunction f($n)
.["1","2","3"]
entrada inválida, mas"123"
é válida . se o @VedantKandoi tiver um problema, eu definitivamente posso mudá-lo!