Eu sou um número rude?

72

Há um tempo, estou enfrentando um problema ao contar nos dedos, especificamente, que só posso contar até dez. Minha solução para esse problema foi contar binário em meus dedos, colocando meu polegar para um, meu indicador para dois, polegar e indicador para três, etc. No entanto, encontramos um pouco de problema quando chegamos o número quatro. Especificamente, exige que levantemos o dedo médio, o que resulta em um gesto bastante infeliz, que normalmente não é aceito na sociedade. Este tipo de número é um número rude . Chegamos ao próximo número grosseiro aos 36, quando levantamos o polegar na segunda mão e o dedo médio da primeira mão. A definição de um número grosseiro é qualquer número que, sob este sistema de contagem, resulta em nos colocar-se unicamenteo dedo médio de qualquer mão. Depois de passarmos o 1023 (o número máximo alcançável em uma pessoa, com duas mãos de cinco dedos cada), suponha que continuemos com uma terceira mão, com as mãos adicionais adicionadas conforme necessário.

Sua tarefa:

Escreva um programa ou função que receba uma entrada e emita um valor de verdade / falsidade com base no fato de a entrada ser um número rude.

Entrada:

Um número inteiro entre 0 e 10 9 (inclusive).

Resultado:

Um valor de verdade / falsidade que indica se a entrada é um número rude.

Casos de teste:

Input:    Output:
0   --->  falsy
3   --->  falsy
4   --->  truthy
25  --->  falsy
36  --->  truthy
127 --->  falsy
131 --->  truthy

Pontuação:

Isso é código-golfe , então a pontuação mais baixa em bytes vence.

code-golf  number  decision-problem 
— Gryphon - Restabelecer Monica
fonte
43
assume we continue with a third handQuando se trata de ser rude, o trabalho em equipe faz o sonho funcionar.
— Veskah 27/02
5
@Veskah verifica que, para os limites da pergunta, você precisa apenas de 3 pessoas para fazer qualquer número. Com certeza, é melhor do que contar com os dedos.
— Gryphon - Restabelece Monica
12
É pior se você é britânico - 6 também é rude!
— Matthew
11
É aceitável receber informações em uma base diferente de 10?
— wastl
2
5 parece bastante rude também. Não tenho certeza se alguém diria "Oh, ela estava com o polegar para fora, isso é perfeitamente educado"
— ale10ander

Respostas:

17

Regex (ECMAScript), 37 bytes

A entrada é unária, como o comprimento de uma sequência de xs.

^((?=(x+)(\2{31}x*))\3)*(x{32})*x{4}$

Experimente online!

^
(
    (?=(x+)(\2{31}x*))    # \2 = floor(tail / 32); \3 = tool to make tail = \2
    \3                    # tail = \2
)*                        # Loop the above as many times as necessary to make
                          # the below match
(x{32})*x{4}$             # Assert that tail % 32 == 4
— Deadcode
fonte
13
Eu pensei que sabia regex, mas aparentemente não.
— CT Hall
8

Ruby, 36 19 bytes

->n{n.to_s(32)[?4]}

Experimente online!

Economizou 17 bytes com o método @tsh .

— Maçaneta da porta
fonte
Isso retorna verdadeiro para 2207, que possui uma representação binária de100010011111
— Modalidade de Ignorância
@EmbodimentofIgnorance Esse é o resultado correto, não é? A segunda mão é 00100.
— Maçaneta da porta
Eu não falo Ruby. Mas porque não ->n{n.to_s(32)=~/4/}?
— tsh
11
@tsh porque não sou tão inteligente quanto você :)
— Maçaneta da porta
Perdoe-me se não estou entendendo a pergunta, mas não é a primeira mão de 2207 10001, a segunda 00111e a terceira 11? Nenhum deles tem apenas o dedo do meio levantado
— Modalidade de Ignorância
8

APL + WIN, 10 bytes

Solicita a entrada de número inteiro

4∊(6⍴32)⊤⎕

A observação de seis ponteiros é necessária para representar 10 ^ 9 convertidos em vetor de 6 elementos da representação base 32 e verifica se 4 existe em algum elemento.

— Graham
fonte
6

Perl 6 , 16 bytes

{.base(32)~~/4/}

Experimente online!

Verifica se existe uma representação 4na base 32 do número. Retorna Nil como false ou um Match contendo a 4.

Você pode provar isso pelo fato de 25=32. modo que cada dígito é o estado de cada ponteiro.

— Brincadeira
fonte
6

Código da máquina x86, 17 bytes

6A 20 59 85 C0 74 09 99 F7 F9 83 FA 04 75 F4 91 C3

Os bytes acima definem uma função que aceita o número como entrada no EAXregistro e retorna o resultado como um valor booleano no EAXregistro ( EAX== 0 se a entrada não for um número rude;! EAX= 0 se a entrada for um número rude )

Em mnemônicos de montagem legíveis por humanos:

; Determines whether the specified number is a "rude" number.
; Input:    The number to check, in EAX
; Output:   The Boolean result, in EAX (non-zero if rude; zero otherwise)
; Clobbers: ECX, EDX
IsRudeNumber:
    push    32           ; \ standard golfing way to enregister a constant value
    pop     ecx          ; /  (in this case: ECX <= 32)
CheckNext:
    test    eax, eax     ; \ if EAX == 0, jump to the end and return EAX (== 0)
    jz      TheEnd       ; /  otherwise, fall through and keep executing
    cdq                  ; zero-out EDX because EAX is unsigned (shorter than XOR)
    idiv    ecx          ; EAX <= (EAX / 32)
                         ; EDX <= (EAX % 32)
    cmp     edx, 4       ; \ if EDX != 4, jump back to the start of the loop
    jne     CheckNext    ; /  otherwise, fall through and keep executing
    xchg    eax, ecx     ; store ECX (== 32, a non-zero value) in EAX
TheEnd:
    ret                  ; return, with result in EAX

Experimente online!

— Cody Gray
fonte
11
Idéia interessante de usar idiv, no entanto. Não vejo melhorias incrementais nisso. Mas veja minha resposta : 14 bytes para um loop de deslocamento que usa MOV / AND / SUB / JZ para verificar os baixos 5 bits quanto a grosseria.
— Peter Cordes
4

C # (compilador interativo do Visual C #) , 31 bytes

n=>{for(;n>0;n/=n%32==4?0:32);}

Saídas lançando uma exceção. A maneira como você converte um número de decimal para outra base é dividir o número decimal por essa base repetidamente e usar o restante como um dígito. É isso que fazemos, e verificamos se algum dos dígitos tem valor 4 na base 32;

Experimente online!

— Modalidade de ignorância
fonte
27? como um bônus, ele não produz uma saída estranha
— somente ASCII
11
também o que é tplig
— ASCII-only
@ ASCII-only n>31->n>0
— tsh
— Kevin Cruijssen 27/02
11
A interrupção ou não de um programa não é um método de saída permitido . Saída via exceção é permitida.
— Deadcode
3

R , 50 bytes 48

any(2^(0:4)%*%matrix(scan()%/%2^(0:34)%%2,5)==4)

Experimente online!

Agora, usa uma abordagem baseada em matriz pura (cortesia de @Giueseppe). Ele gera uma matriz de bits 5x7, converte isso em uma série de números inteiros base 32 e verifica se há 4s.

— Nick Kennedy
fonte
@ Giuseppe Opa, perdi completamente isso. Deve funcionar agora, embora decepcionantemente 19 bytes a mais. Eu não acho que exista uma função inversa para strtoi que não seja hexadecimal e octal na base R
— Nick Kennedy
48 bytes com alguma mágica de matriz. Eu acredito que a conversão de bits é mais longa do que, intToBitsmas então podemos trabalhar em intsvez de rawque acaba economizando um byte - veja, por exemplo, isso comintToBits
— Giuseppe
@ Giuseppe é uma solução completamente diferente (e pura) para a minha - você quer que eu atualize a minha ou publique a sua?
— Nick Kennedy
você é livre para aceitar. :-)
— Giuseppe
11
é claro, portar uma das muitas respostas que testa a presença de um dígito 4em um número de base 32 é, oh, 29 bytes .
— Giuseppe
2

Carvão , 6 bytes

№⍘Ｎ³²4

Experimente online!Link é a versão detalhada do código. Saídas -s de acordo com a grosseria do número. Explicação:

  Ｎ     Input as a number
 ⍘      Convert to base as a string
   ³²   Literal 32
№       Count occurrences of
     4  Literal string `4`

Eu uso a conversão de base de string para evitar ter que separar os literais numéricos para 32e 4.

— Neil
fonte
2

Cubix , 26 bytes

u!@-W14;OIS%/\;;,p;?wO@u/s

Experimente online!

Envolve em um cubo com o comprimento da aresta 3 da seguinte maneira

      u ! @
      - W 1
      4 ; O
I S % / \ ; ; , p ; ? w
O @ u / s . . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Veja-o correr

Uma implementação bastante básica, sem todos os redirecionamentos que faz:

  • IS inicia o programa pressionando a entrada e 32 na pilha
  • %4-! obtém o restante e verifica se é 4 por subtração
  • 1O@ saída 1 se fosse 4 e parar
  • ;;, limpe a pilha e divida o número inteiro
  • p;? limpe a parte inferior da pilha e verifique o resultado div para 0
  • O@ se div resultar zero saída e parar
  • s Troque a parte superior da pilha e comece na etapa 2 acima
— MickyT
fonte
2

MATL , 8 bytes

32YA52=a

Experimente online!

— Sanchises
fonte
@Luis Eu definitivamente posso largar o G(não sei por que o incluí em primeiro lugar), mas isso é apenas um byte (obrigado por descobrir isso!). Mudar 32YA52para 32_YA4é o mesmo número de bytes, certo?
— Sanchises
Ah, sim, não sei contar
— Luis Mendo
2
@Luis Count? Quem precisa contar quando pode'32_YA4'n'32YA52'n-
— Sanchises
2

Lote, 77 45 bytes

@cmd/cset/a"m=34636833,n=%1^m*4,(n-m)&~n&m*16

Com base nesses pequenos truques . Explicação: Apenas 6 ponteiros precisam ser verificados devido ao alcance limitado (30 bits) da entrada que precisa ser suportado. O número mágico mé equivalente a 111111na base 32, de modo que a primeira operação alterna os bits rudes no número de entrada. Resta então descobrir qual das 6 mãos agora é zero.

— Neil
fonte
2

código de máquina x86, 14 bytes

(o mesmo código de máquina funciona em 16, 32 e 64 bits. No modo de 16 bits, ele usa AX e DI em vez de EAX e EDI no modo de 32 e 64 bits.)

Algoritmo: marque baixos 5 bits com x & 31 == 4, em seguida, desloque-se à direita em 5 bits e repita se o resultado da mudança for diferente de zero.

É possível chamar de C com de char isrude(unsigned n);acordo com a convenção de chamada do System V x86-64. 0 é verdadeiro, não-0 é falso (isto é asm, não C 1 ).

 line   addr    code bytes
  num
     1                             ; input:  number in EDI
     2                             ; output: integer result in AL: 0 -> rude, non-zero non-rude
     3                             ; clobbers: RDI
     4                         isrude:
     5                         .check_low_bitgroup:
     6 00000000 89F8               mov    eax, edi
     7 00000002 241F               and    al, 31          ; isolate low 5 bits
     8 00000004 2C04               sub    al, 4           ; like cmp but leaves AL 0 or non-zero
     9 00000006 7405               jz    .rude            ; if (al & 31 == 4) return 0;
    10                         
    11 00000008 C1EF05             shr    edi, 5
    12 0000000B 75F3               jnz   .check_low_bitgroup
    13                             ;; fall through to here is only possible if AL is non-zero
    14                         .rude:
    15 0000000D C3                 ret


    16          0E             size:  db $ - isrude

Isso tira proveito da op al, imm8codificação abreviada de AND e SUB. Eu poderia ter usadoXOR al,4 para produzir 0 na igualdade, mas o SUB é mais rápido, porque ele pode se fundir com o JZ em um único suboperador e ramificação na família Sandybridge.

Curiosidade: usar o resultado da flag de um turno em mais de 1 será lento na família P6 (barracas de front-end até o turno se aposentar), mas tudo bem.

Nota de rodapé 1: Esta é uma função da linguagem assembly, e o x86 asm possui ambos jze jnz, conforme meta eu posso escolher de qualquer maneira. Não pretendo que isso corresponda a verdade / falsidade.

Era conveniente retornar em AL em vez de EFLAGS, para que possamos descrever a função para um compilador C sem um wrapper, mas minha escolha de verdade / falsidade não é restrita usando um chamador C para testá-lo.

— Peter Cordes
fonte
2

ES6, 31 30 26 bytes

b=>b.toString(32).match`4`

Sinta-se livre para dizer idéias sobre como reduzir isso ainda mais, se houver.

— elipszilon
fonte
Bem-vindo ao PPCG!
— Laikoni 28/02
Você não precisa contar o nome da sua função e, embora eu ache que pode salvar um byte usando test, na verdade, você pode salvar dois bytes comparando com 4um número e deixando matchconverter isso em uma string e, em seguida, em um RegExp para você .
— Neil
1

Retina 0.8.2 , 31 bytes

.+
$*
+`(1+)\1{31}
$1;
\b1111\b

Experimente online! O link inclui casos de teste. Emite zero, a menos que o número seja rude. Funciona convertendo a entrada em base unária e, em seguida, codificada em unária 32 e contando o número de 4s no resultado.

— Neil
fonte
1

Wolfram Language (Mathematica) , 37 bytes 36 bytes 29 bytes

-2 bytes por Jonathan Frech

#~IntegerDigits~32~MemberQ~4&

Experimente online!

Solução de 31 bytes:

MemberQ[IntegerDigits[#,32],4]&

Experimente online!

— Rainer Glüge
fonte
Olá e bem-vindo ao PPCG. Tal como está, sua expressão é um único valor booleano. Corrija sua resposta para ser um programa completo ou uma função ( ...#...&geralmente usada no Mathematica).
— Jonathan Frech
Olá. É isto que você quer dizer?
— Rainer Glüge
Os pls usam tio.run/#mathematica em vez de W | A para garantir que seja um código mathematica válido: P e você não precisa do [n]no final, apenas o &. Além disso, como as postagens têm histórico de edições, é bom deixar de fora as entradas anteriores, e a convenção para pontuações antigas é<s>40</s> <s>36</s>
— somente ASCII
Sim. Foi isso que eu quis dizer. 29 bytes .
— Jonathan Frech
Acho que tenho que me acostumar com o estilo de programação funcional.
— Rainer Glüge
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.