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 ⁹ (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 código de golf , por lo que gana la puntuación más baja en bytes.

APL (dzaima / APL) , 5 bytes

4∊32⊤

Pruébalo en línea!

4∊ es 4 un miembro de

32⊤ a-base-32?

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

JavaScript (SpiderMonkey) , 23 bytes

f=x=>x&&x%32==4|f(x>>5)

Pruébalo en línea!

Esta es una solución trivial, solo desea convertir a la base 32 y verificar si hay un 4 en ella.

JavaScript (SpiderMonkey) , 26 bytes

x=>x.toString(32).match(4)

Pruébalo en línea!

Es interesante que /4/.test(...)cuesta un byte más que ....match(4).

Japt , 5 bytes

sH ø4

Pruébalo en línea!

Explicación

      // Implicit input
sH    // To a base-H (=32) string
   ø  // Contains
    4 // 4 (JavaScript interprets this as a string)

Ruby, 36 19 bytes

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

Pruébalo en línea!

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

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.

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.

$2^5 = 32$

Python 2 , 34 32 bytes

f=lambda a:a%32==4or a>0<f(a/32)

Pruébalo en línea!

2 bytes gracias a tsh

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!

Julia 1.0 , 25 bytes

f(n)=n%32==4||n>0<f(n>>5)

Pruébalo en línea!

Julia 1.0 , 26 bytes

Alternativa que es 1 carácter más corto, pero 1 byte más largo, lástima que ∈tome 3 bytes en unicode.

n->'4'∈string(n,base=32)

Pruébalo en línea!

05AB1E , 5 bytes

32B4å

Respuesta de APL (dzaima / APL) del puerto de @ Adám .

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

32B    # Convert the (implicit) input to Base-32
   4å  # And check if it contains a 4
       # (output the result implicitly)

Catholicon , 4 bytes

ǔ?QǑ

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

Pruébalo en línea!

Banco de pruebas

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!

J , 12 bytes

4 e.32#.inv]

Pruébalo en línea!

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.

Python 3 , 43 bytes

Comprueba cada fragmento de 5 bits para ver si es grosero (igual a 4).

lambda n:any(n>>5*i&31==4for i in range(n))

Pruébalo en línea!

C (gcc) , 34 bytes

f(i){return i?i&31^4?f(i/32):1:0;}

Pruébalo en línea!

Carbón de leña , 6 bytes

№⍘Ｎ³²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:

  Ｎ     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.

Ordenado , 18 bytes

{x:4∈base(32,x)}

Pruébalo en línea! Comprueba si 4es un elemento de base(32,x)(conversión de base).

Haskell , 31 bytes

elem 9.(mapM(:[6..36])[0..5]!!)

Pruébalo en línea!

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

MATL , 8 bytes

32YA52=a

Pruébalo en línea!

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.

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 ¹ ).

 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.

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.

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.

Java 8, 40 33 bytes

n->n.toString(n,32).contains("4")

Respuesta de APL (dzaima / APL) del puerto de @ Adám .

Pruébalo en línea.

Explicación:

n->                 // Method with Integer parameter and boolean return-type
  n.toString(n,32)  //  Convert the input to a base-32 String
   .contains("4")   //  And check if it contains a "4"

> <> , 28 bytes

Las salidas 4 para números groseros arrojan una excepción para números no groseros.

:1(?^:" ":\
,&-v?=4:%&/
 ;n<

Pruébalo en línea!

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!

Java 8, 28 22 21 bytes

n->n%32==4|n>>5%32==4

Inspirado por la respuesta de @ kevin-cruijssen . Solo funciona para 2 manos.

Pruébalo en línea!

Explicación:

n->                 // Method with int parameter and boolean return-type
  n%32              // Only consider right 5 bytes (fingers)
  ==4               // Middle finger
  | ... n>>5       // Repeat with shifted bits for other hand