Da un po 'di tempo, ho riscontrato un problema quando conto sulle mie dita, in particolare, che posso contare solo fino a dieci. La mia soluzione a questo problema è stata quella di contare in binario sulle mie dita, alzando il pollice per uno, il mio indice per due, sia il pollice che l'indice per tre, ecc. Tuttavia, quando arriviamo a riscontrare un problema il numero quattro. In particolare, ci richiede di alzare il dito medio, il che si traduce in un gesto piuttosto sfortunato, che in genere non è accettato nella società. Questo tipo di numero è un numero scortese . Arriviamo al prossimo numero maleducato a 36, ​​quando alziamo il pollice sulla nostra seconda mano e il medio della nostra prima mano. La definizione di un numero osceno è qualsiasi numero che, con questo sistema di conteggio, risultati in noi mettendo su soloil dito medio di qualsiasi mano. Dopo aver superato 1023 (il numero massimo raggiungibile su una persona, con due mani di cinque dita ciascuna), supponiamo di continuare con una terza mano, con le mani aggiuntive aggiunte come richiesto.

Il tuo compito:

Scrivi un programma o una funzione che riceve un input e genera un valore di verità / falsa in base al fatto che l'input sia un numero rude.

Ingresso:

Un numero intero compreso tra 0 e 10 ⁹ (incluso).

Produzione:

Un valore di verità / falsità che indica se l'input è un numero scortese.

Casi test:

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

punteggio:

Questo è code-golf , quindi vince il punteggio più basso in byte.

APL (dzaima / APL) , 5 byte

4∊32⊤

Provalo online!

4∊ è un membro di 4

32⊤ a-base-32?

Regex (ECMAScript), 37 byte

L'input è in unario, come la lunghezza di una stringa di xs.

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

Provalo 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

JavaScript (SpiderMonkey) , 23 byte

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

Provalo online!

Questa è una soluzione banale, vuoi solo convertire in base 32 e controllare se c'è un 4 in essa.

JavaScript (SpiderMonkey) , 26 byte

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

Provalo online!

È interessante che /4/.test(...)costa un byte in più rispetto a ....match(4).

Japt , 5 byte

sH ø4

Provalo online!

Spiegazione

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

Rubino, 36 19 byte

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

Provalo online!

Salvato 17 byte con il metodo @tsh .

APL + WIN, 10 byte

Richiede l'immissione di un numero intero

4∊(6⍴32)⊤⎕

È necessario notare sei mani per rappresentare 10 ^ 9 convertiti in vettore di 6 elementi della rappresentazione di base 32 e verificare se esiste un 4 in qualsiasi elemento.

Perl 6 , 16 byte

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

Provalo online!

Verifica se 4nella base 32 è presente una rappresentazione del numero. Restituisce Nil come falso o una corrispondenza contenente a 4.

Puoi dimostrarlo dal fatto che quindi ogni cifra è lo stato di ogni mano.$2^5 = 32$

Python 2 , 34 32 byte

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

Provalo online!

2 byte grazie a tsh

Codice macchina x86, 17 byte

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

I byte precedenti definiscono una funzione che accetta il numero come input nel EAXregistro e restituisce il risultato come valore booleano nel EAXregistro ( EAX== 0 se l'input non è un numero scortese;! EAX= 0 se l'input è un numero scortese ).

In mnemonici di assemblaggio leggibili dall'uomo:

; 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

Provalo online!

Julia 1.0 , 25 byte

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

Provalo online!

Julia 1.0 , 26 byte

Alternativa che è di 1 carattere più corta, ma 1 byte più lunga, peccato che ∈impiega 3 byte in Unicode.

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

Provalo online!

05AB1E , 5 byte

32B4å

Porta della risposta APL di @Adám (dzaima / APL) .

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Catholicon , 4 byte

ǔ?QǑ

Accetta un numero come stringa base-256.

Provalo online!

Suite di test

C # (compilatore interattivo Visual C #) , 31 byte

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

Emette lanciando un'eccezione. Il modo in cui converti un numero da decimale a un'altra base è quello di dividere ripetutamente il numero decimale per quella base e prendere il resto come una cifra. Questo è ciò che facciamo e controlliamo se una qualsiasi delle cifre ha un valore di 4 in base-32;

Provalo online!

J , 12 byte

4 e.32#.inv]

Provalo online!

R , 50 48 byte

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

Provalo online!

Ora utilizza un approccio basato su matrice (per gentile concessione di @Giueseppe). Genera una matrice di bit 5x7, la converte in una serie di numeri interi di base 32 e verifica la presenza di 4 secondi.

Python 3 , 43 byte

Controlla ogni blocco a 5 bit per vedere se è scortese (uguale a 4).

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

Provalo online!

C (gcc) , 34 byte

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

Provalo online!

Carbone , 6 byte

№⍘Ｎ³²4

Provalo online! Il collegamento è alla versione dettagliata del codice. Emette -s in base a quanto è scortese il numero. Spiegazione:

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

Uso la conversione di stringhe base per evitare di separare i letterali numerici per 32e 4.

Ordinato , 18 byte

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

Provalo online! Verifica se 4è un elemento di base(32,x)(conversione di base).

Haskell , 31 byte

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

Provalo online!

Cubix , 26 byte

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

Provalo online!

Avvolge su un cubo con la lunghezza del bordo 3 come segue

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

Guarda correre

Un'implementazione abbastanza semplice, senza tutti i reindirizzamenti che fa:

• IS avvia il programma spingendo l'input e 32 nello stack
• %4-! ottiene il resto e controlla se è 4 per sottrazione
• 1O@ uscita 1 se era 4 e si ferma
• ;;, ripulire lo stack e fare la divisione intera
• p;? ripulire il fondo dello stack e controllare il risultato div per 0
• O@ se div risulta zero output e stop
• s scambiare la parte superiore dello stack e ricominciare dal passaggio 2 sopra

MATL , 8 byte

32YA52=a

Provalo online!

Lotto, 77 45 byte

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

Sulla base di questi hack modulari . Spiegazione: È necessario controllare solo 6 lancette a causa della gamma limitata (30 bit) dell'ingresso che è necessario supportare. Il numero magico mequivale a 111111nella base 32, quindi la prima operazione attiva / disattiva i bit grezzi nel numero di ingresso. Resta quindi da scoprire quale delle 6 mani è ora zero.

codice macchina x86, 14 byte

(lo stesso codice macchina funziona in 16-bit, 32-bit e 64-bit. In modalità 16-bit, utilizza AX e DI anziché EAX ed EDI in modalità 32 e 64-bit.)

Algoritmo: controllare 5 bit bassi con x & 31 == 4, quindi spostare a destra di 5 bit e ripetere se il risultato dello spostamento è diverso da zero.

Callable da C char isrude(unsigned n);secondo la convenzione di chiamata System V x86-64. 0 è vero, non-0 è falso (questo è asm, non 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

Questo sfrutta la op al, imm8codifica abbreviata per AND e SUB. Avrei potuto XOR al,4produrre 0 sull'uguaglianza, ma SUB è più veloce perché può fondere macro con JZ in un singolo sub-and-branch nella famiglia Sandybridge.

Curiosità: l'utilizzo del risultato della bandiera di uno spostamento di più di 1 sarà lento sulla famiglia P6 (le bancarelle front-end fino alla fine del turno), ma va bene.

Nota 1: questa è una funzione del linguaggio assembly e x86 asm ha entrambi jze jnz, quindi per meta posso scegliere in entrambi i modi. Non intendo questo per abbinare C verità / falsità.

È sembrato conveniente tornare in AL invece di EFLAGS, quindi possiamo descrivere la funzione a un compilatore C senza un wrapper, ma la mia scelta di verità / falsità non è vincolata usando un chiamante C per testarlo.

ES6, 31 30 26 byte

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

Sentiti libero di dire idee su come ridurlo ulteriormente, se ce ne sono.

Retina 0.8.2 , 31 byte

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

Provalo online! Il link include casi di test. Emette zero a meno che il numero non sia maleducato. Funziona convertendo l'input in unario e quindi in base codificata unaria 32 e contando il numero di 4s nel risultato.

Java 8, 40 33 byte

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

Porta della risposta APL di @Adám (dzaima / APL) .

Provalo online.

Spiegazione:

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 byte

Le uscite 4 per i numeri scortesi generano un'eccezione per i numeri non scortesi.

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

Provalo online!

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

-2 byte di Jonathan Frech

#~IntegerDigits~32~MemberQ~4&

Provalo online!

Soluzione a 31 byte:

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

Provalo online!

Java 8, 28 22 21 byte

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

Ispirato dalla risposta di @ kevin-cruijssen . Funziona solo con 2 mani.

Provalo online!

Spiegazione:

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