¿Soy un número grosero?


72

Durante un tiempo, me he encontrado con un problema al contar con mis dedos, específicamente, que solo puedo contar hasta diez. Mi solución a ese problema ha sido contar en binario con mis dedos, levantando el pulgar para uno, el índice para dos, el pulgar y el índice para tres, etc. Sin embargo, nos encontramos con un pequeño problema cuando llegamos a El número cuatro. Específicamente, requiere que levantemos nuestro dedo medio, lo que resulta en un gesto bastante desafortunado, que generalmente no se acepta en la sociedad. Este tipo de número es un número grosero . Llegamos al siguiente número grosero en 36, cuando levantamos el pulgar en nuestra segunda mano y el dedo medio de nuestra primera mano. La definición de un número grosero es cualquier número que, bajo este sistema de conteo, resulta en que solo pongamosEl dedo medio de cualquier mano. Una vez que pasamos 1023 (el número máximo alcanzable en una persona, con dos manos de cinco dedos cada una), supongamos que continuamos con una tercera mano, con las manos adicionales agregadas según sea necesario.

Tu tarea:

Escriba un programa o función que reciba una entrada y genere un valor verdadero / falso basado en si la entrada es un número grosero.

Entrada:

Un entero entre 0 y 10 9 (inclusive).

Salida:

Un valor verdadero / falso que indica si la entrada es un número grosero.

Casos de prueba:

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

Puntuación:

Este es el , por lo que gana la puntuación más baja en bytes.


43
assume we continue with a third handCuando se trata de ser grosero, el trabajo en equipo hace que el sueño funcione.
Veskah

55
@Veskah resulta que para los límites de la pregunta, solo necesitas 3 personas para hacer un número determinado. Seguro supera el viejo tipo de contar con los dedos.
Gryphon - Restablece a Monica

12
Es peor si eres británico: ¡el 6 también es grosero!
Mateo

1
¿Está bien tomar una entrada en una base diferente a 10?
Wastl

2
5 parece bastante grosero también. No estoy seguro de que alguien diga "Oh, ella tenía el pulgar afuera, eso es perfectamente educado"
ale10ander

Respuestas:



17

Regex (ECMAScript), 37 bytes

La entrada está en unario, como la longitud de una cadena de xs.

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

Pruébalo en línea!

^
(
    (?=(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

13
Pensé que sabía regex, pero aparentemente no.
CT Hall



8

Ruby, 36 19 bytes

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

Pruébalo en línea!

Guardado 17 bytes con el método de @tsh .


Esto devuelve cierto para 2207, que tiene una representación binaria de100010011111
Encarnación de la ignorancia

@EmbodimentofIgnorance Ese es el resultado correcto, ¿no es así? La segunda mano es 00100.
Pomo de la puerta

Yo no hablo Ruby. ¿Pero por qué no ->n{n.to_s(32)=~/4/}?
tsh

1
@tsh porque no soy tan inteligente como usted :)
Pomo

Perdóname si no entiendo la pregunta, pero ¿no es la primera mano de 2207 10001, la segunda 00111y la tercera 11? Ninguno de ellos tiene su dedo medio solo hacia arriba
Encarnación de la ignorancia

8

APL + WIN, 10 bytes

Solicita entrada de entero

4∊(6⍴32)⊤⎕

Observando que se requieren seis manos para representar 10 ^ 9 conversos en el vector de 6 elementos de la representación base 32 y verifica si existe un 4 en cualquier elemento.


6

Perl 6 , 16 bytes

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

Pruébalo en línea!

Comprueba si hay una representación 4en la base 32 del número. Devuelve Nil como falso o una coincidencia que contiene a 4.

25=32



6

Código de máquina x86, 17 bytes

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

Los bytes anteriores definen una función que toma el número como entrada en el EAXregistro y devuelve el resultado como un valor booleano en el EAXregistro ( EAX== 0 si la entrada no es un número grosero;! EAX= 0 si la entrada es un número grosero )

En mnemónicos de montaje legibles 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

Pruébalo en línea!


1
Sin idivembargo, es una idea interesante de usar . No veo ninguna mejora incremental en esto. Pero vea mi respuesta : 14 bytes para un bucle de desplazamiento que usa MOV / AND / SUB / JZ para verificar la baja grosería de los 5 bits.
Peter Cordes



4

Catholicon , 4 bytes

ǔ?QǑ

Toma un número como una cadena base-256.

Pruébalo en línea!

Banco de pruebas


2
Hm, si esto está permitido, ¿está permitido aceptar números en la base 32 en su lugar?
recursivo

@recursive Puede rodear los números en <<y >>y permite números mayores que 255 en ellos, como se muestra en el conjunto de pruebas.
Okx

1
Fue pensado como una pregunta sobre el desafío, pero no estaba muy claro.
recursivo

4

C # (compilador interactivo de Visual C #) , 31 bytes

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

Salidas lanzando una excepción. La forma de convertir un número de decimal a otra base es dividir el número decimal por esa base repetidamente y tomar el resto como un dígito. Eso es lo que hacemos, y verificamos si alguno de los dígitos tiene un valor de 4 en base-32;

Pruébalo en línea!


27? como beneficio adicional, no sale de una manera extraña
solo ASCII

1
también lo que es tplig
solo ASCII

@ Solo ASCII n>31->n>0
tsh


1
Si un programa se detiene o no, no es un método de salida permitido . Se permite la salida por excepción .
Código muerto


3

R , 50 48 bytes

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

Pruébalo en línea!

Utiliza un enfoque ordenado basado en una matriz ahora (cortesía de @Giueseppe). Genera una matriz de bits de 5x7, la convierte en una serie de enteros de base 32 y comprueba si hay 4s.


@Giuseppe Vaya, lo perdí por completo. Debería funcionar ahora, aunque decepcionantemente 19 bytes más. No creo que haya una función inversa para strtoi que no sea para hexadecimal y octal en la base R
Nick Kennedy

48 bytes con algo de magia matricial. Creo que la conversión de bits es más larga que intToBitspero entonces podemos trabajar con intsen lugar de rawque termina encima de ahorrar un byte - ver, por ejemplo, esto conintToBits
Giuseppe

@Giuseppe es una solución completamente diferente (y ordenada) para la mía: ¿quieres que actualice la mía o publiques la tuya?
Nick Kennedy

eres libre de tomarlo. :-)
Giuseppe

1
por supuesto, portar una de las muchas respuestas que prueba la presencia de un dígito 4en un número base 32 es, oh, 29 bytes .
Giuseppe



2

Carbón de leña , 6 bytes

№⍘N³²4

Pruébalo en línea! El enlace es a la versión detallada del código. Emite -s según cuán grosero sea el número. Explicación:

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

Utilizo la conversión de base de cadena para evitar tener que separar los literales numéricos para 32y 4.




2

Cubix , 26 bytes

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

Pruébalo en línea!

Se envuelve en un cubo con una longitud de borde 3 de la siguiente manera

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

Míralo correr

Una implementación bastante básica, sin todas las redirecciones que hace:

  • IS inicia el programa empujando la entrada y 32 a la pila
  • %4-! obtiene el resto y comprueba si es 4 por sustracción
  • 1O@ salida 1 si era 4 y detener
  • ;;, limpiar la pila y dividir enteros
  • p;? limpiar el fondo de la pila y verificar el resultado div para 0
  • O@ si div resulta cero salida y alto
  • s intercambie la parte superior de la pila y comience de nuevo en el paso 2 anterior

2

MATL , 8 bytes

32YA52=a

Pruébalo en línea!


@Luis definitivamente puedo soltar el G(no estoy seguro de por qué lo incluí en primer lugar) pero eso es solo un byte (¡gracias por ver eso!). Cambiar 32YA52a 32_YA4es el mismo número de bytes ¿verdad?
Sanchises

Ah, sí, no puedo contar
Luis Mendo

2
@Luis Count? ¿Quién necesita contar cuando puedes?'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

Basado en estos trucos poco retorcidos . Explicación: solo se deben verificar 6 manos debido al rango limitado (30 bits) de la entrada que se debe admitir. El número mágico mes equivalente a 111111en la base 32, de modo que la primera operación alterna los bits groseros en el número de entrada. Luego queda encontrar cuál de las 6 manos es ahora cero.


2

código de máquina x86, 14 bytes

(El mismo código de máquina funciona en 16 bits, 32 bits y 64 bits. En modo de 16 bits, utiliza AX y DI en lugar de EAX y EDI en modo de 32 y 64 bits).

Algoritmo: verifique 5 bits bajos con x & 31 == 4, luego desplace a la derecha en 5 bits, y repita si el resultado del cambio no es cero.

Se puede llamar desde C con char isrude(unsigned n);la convención de llamadas del Sistema V x86-64. 0 es verdadero, no 0 es falso (esto es asm, no 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

Esto aprovecha la op al, imm8codificación de formato corto para AND y SUB. Podría haber usado XOR al,4para producir 0 en igualdad, pero SUB es más rápido porque puede fusionarse macro con JZ en una sola sub-y-rama uop en Sandybridge-family.

Dato curioso: usar el resultado de la bandera de un turno en más de 1 será lento en la familia P6 (puestos frontales hasta que el turno se retire), pero está bien.


Nota al pie 1: Esta es una función de lenguaje ensamblador, y x86 asm tiene ambas jzy jnz, por lo que según el meta , puedo elegir cualquier manera. No tengo la intención de que esto coincida con C verdadero / falso.

Resultó conveniente regresar en AL en lugar de EFLAGS, por lo que podemos describir la función a un compilador de C sin un contenedor, pero mi elección de verdadero / falso no está restringida al usar un llamador de C para probarlo.


2

ES6, 31 30 26 bytes

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

Siéntase libre de decir ideas sobre cómo reducir esto aún más, si corresponde.


Bienvenido a PPCG!
Laikoni

No necesita contar el nombre de su función, y aunque creo que puede guardar un byte utilizando test, en realidad puede guardar dos bytes haciendo coincidir 4como un número y dejando matchconvertirlo en una cadena y luego en un RegExp para usted .
Neil

1

Retina 0.8.2 , 31 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Emite cero a menos que el número sea grosero. Funciona convirtiendo la entrada a unario y luego a la base codificada unaria 32 y contando el número de 4s en el resultado.




1

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

-2 bytes por Jonathan Frech

#~IntegerDigits~32~MemberQ~4&

Pruébalo en línea!

Solución de 31 bytes:

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

Pruébalo en línea!


Hola y bienvenidos a PPCG. Tal como está, su expresión es un único valor booleano. Por favor, arregle su respuesta para que sea un programa completo o una función (a ...#...&menudo se usa en Mathematica).
Jonathan Frech

Hola. ¿Es esto lo que quieres decir?
Rainer Glüge

los pls usan tio.run/#mathematica en lugar de W | A para asegurarse de que sea un código matemático válido: P y no necesita el [n]al final, solo el &. Además, dado que las publicaciones tienen historial de edición, está bien dejar de lado las entradas anteriores, y la convención para los puntajes antiguos es<s>40</s> <s>36</s>
solo ASCII

Si. Esto es lo que quise decir. 29 bytes .
Jonathan Frech

Supongo que tengo que acostumbrarme al estilo de programación funcional.
Rainer Glüge

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.