Cela fait un moment que je rencontre un problème en comptant sur mes doigts, en particulier que je ne peux compter que dix. Ma solution à ce problème a été de compter en binaire sur mes doigts, en plaçant mon pouce pour un, mon index pour deux, les deux pouce et index pour trois, etc. Cependant, nous rencontrons un petit problème lorsque nous arrivons à le nombre quatre. Plus précisément, cela nécessite que nous levions le majeur, ce qui entraîne un geste plutôt malheureux, ce qui n’est généralement pas accepté dans la société. Ce type de numéro est un nombre grossier . Nous arrivons au prochain chiffre impoli à 36 ans, lorsque nous levons le pouce de notre seconde main et le majeur de notre première main. La définition d'un nombre brut est un nombre qui, dans ce système de comptage, a pour résultat que nous n'émettons quele majeur de n'importe quelle main. Une fois que nous avons passé 1023 (le nombre maximum accessible sur une personne, avec deux mains de cinq doigts chacune), supposons que nous poursuivions avec une troisième main, avec des mains supplémentaires ajoutées si nécessaire.

Ta tâche:

Ecrivez un programme ou une fonction qui reçoit une entrée et génère une valeur vérité / fausseté selon que l'entrée est un nombre brut ou non.

Contribution:

Un entier compris entre 0 et 10 ⁹ (inclus).

Sortie:

Une valeur vérité / fausseté qui indique si l'entrée est un nombre grossier.

Cas de test:

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

Notation:

C'est le code-golf , donc le score le plus bas en octets l'emporte.

APL (dzaima / APL) , 5 octets

4∊32⊤

Essayez-le en ligne!

4∊ est 4 un membre de

32⊤ à-base-32?

Regex (ECMAScript), 37 octets

L'entrée est unaire, comme la longueur d'une chaîne de xs.

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

Essayez-le en ligne!

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

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

Essayez-le en ligne!

C'est une solution triviale, vous voulez juste convertir en base 32 et vérifier s'il y a un 4 dedans.

JavaScript (SpiderMonkey) , 26 octets

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

Essayez-le en ligne!

Il est intéressant que /4/.test(...)coûte un octet de plus que ....match(4).

Japt , 5 octets

sH ø4

Essayez-le en ligne!

Explication

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

Ruby, 36 19 octets

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

Essayez-le en ligne!

Enregistré 17 octets avec la méthode de @tsh .

APL + WIN, 10 octets

Invites pour la saisie d'un entier

4∊(6⍴32)⊤⎕

En notant six mains sont nécessaires pour représenter 10 ^ 9 convertis en vecteur de 6 éléments de la représentation de base 32 et vérifie si un 4 existe dans un élément.

Perl 6 , 16 octets

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

Essayez-le en ligne!

Vérifie s'il existe une 4représentation du nombre dans la base 32. Renvoie Nil comme faux ou une correspondance contenant un 4.

Vous pouvez le prouver par le fait que sorte que chaque chiffre correspond à l'état de chaque main.$2^5 = 32$

Python 2 , 34 32 octets

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

Essayez-le en ligne!

2 octets grâce à tsh

Code machine x86, 17 octets

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

Les octets ci-dessus définissent une fonction qui prend le nombre en entrée dans le EAXregistre et renvoie le résultat sous forme de valeur booléenne dans le EAXregistre ( EAX== 0 si l'entrée n'est pas un nombre brut;! EAX= 0 si l'entrée est un nombre brut ).

En mnémotechnique d'assemblage lisible par l'homme:

; 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

Essayez-le en ligne!

Julia 1.0 , 25 octets

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

Essayez-le en ligne!

Julia 1.0 , 26 octets

Alternative qui a 1 caractère plus court, mais 1 octet plus long, dommage que cela ∈prenne 3 octets en unicode.

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

Essayez-le en ligne!

05AB1E , 5 octets

32B4å

Réponse du port de @ Adám (dzaima / APL) .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

Catholicon , 4 octets

ǔ?QǑ

Prend un nombre en tant que chaîne en base 256.

Essayez-le en ligne!

Suite de tests

C # (compilateur interactif Visual C #) , 31 octets

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

Les sorties en lançant une exception. Pour convertir un nombre décimal en une autre base, divisez le nombre décimal par cette base à plusieurs reprises et prenez le reste sous forme de chiffre. C'est ce que nous faisons et nous vérifions si l'un des chiffres a une valeur de 4 en base 32;

Essayez-le en ligne!

J , 12 octets

4 e.32#.inv]

Essayez-le en ligne!

R , 50 48 octets

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

Essayez-le en ligne!

Utilise maintenant une approche nette basée sur une matrice (avec la permission de @Giueseppe). Il génère une matrice de bits 5x7, la convertit en une série d’entiers de base 32 et vérifie la présence de 4s.

Python 3 , 43 octets

Vérifie chaque bloc de 5 bits pour voir s'il est grossier (égal à 4).

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

Essayez-le en ligne!

C (gcc) , 34 octets

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

Essayez-le en ligne!

Charbon de bois , 6 octets

№⍘Ｎ³²4

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Sorties -s en fonction de la grosseur du nombre. Explication:

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

J'utilise la conversion de base de chaîne pour éviter d'avoir à séparer les littéraux numériques pour 32et 4.

Rangé , 18 octets

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

Essayez-le en ligne! Vérifie si 4est un élément de base(32,x)(conversion de base).

Haskell , 31 octets

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

Essayez-le en ligne!

Cubix , 26 octets

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

Essayez-le en ligne!

S'enveloppe sur un cube de longueur d'arête 3 comme suit

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

Regarde le courir

Une implémentation assez basique, sans toutes les redirections:

• IS lance le programme en poussant l'entrée et 32 ​​dans la pile
• %4-! récupère le reste et vérifie si c'est 4 par soustraction
• 1O@ sortie 1 s'il était 4 et arrêter
• ;;, nettoyer la pile et faire une division entière
• p;? nettoie le bas de la pile et vérifie le résultat de div pour 0
• O@ si div résultat est nul et s'arrête
• s permutez le haut de la pile et recommencez à l'étape 2 ci-dessus

MATL , 8 octets

32YA52=a

Essayez-le en ligne!

Lot, 77 45 octets

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

Basé sur ces bidouilles bidouilleurs . Explication: Seules 6 aiguilles doivent être vérifiées en raison de la plage limitée (30 bits) de l'entrée à prendre en charge. Le nombre magique mest équivalent à 111111en base 32, de sorte que la première opération bascule les bits bruts dans le nombre entré. Il reste ensuite à trouver laquelle des 6 mains est maintenant zéro.

code machine x86, 14 octets

(Le même code machine fonctionne en 16 bits, 32 bits et 64 bits. En mode 16 bits, il utilise AX et DI au lieu de EAX et EDI en mode 32 et 64 bits.)

Algorithme: vérifie les 5 bits inférieurs avec x & 31 == 4, puis décale à droite de 5 bits et répète si le résultat du décalage est différent de zéro.

Appelable à partir de C avec char isrude(unsigned n);la convention d'appel System V de x86-64. 0 est la vérité, non-0 est la fausseté (c'est asm, pas 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

Cela tire parti du op al, imm8codage abrégé pour AND et SUB. J'aurais peut-être eu l'habitude XOR al,4de produire 0 sur l'égalité, mais SUB est plus rapide car il peut fusionner avec JZ en une seule sous-branche sur la famille Sandybridge.

Anecdote: utiliser le drapeau d'une journée avec plus d'un joueur sera lent sur la famille P6 (stalles avant le départ à la retraite), mais c'est correct.

Référence 1: Il s'agit d'une fonction de langage d'assemblage, et x86 asm possède les deux jzet jnz, de sorte que, conformément à la méta, je peux choisir l'une ou l'autre solution. Je n’ai pas l’intention de faire correspondre cette vérité à la vérité.

Il est très pratique de retourner en AL au lieu d’EFLAGS afin de pouvoir décrire la fonction à un compilateur C sans encapsuleur, mais mon choix de vérité / fausseté n’est pas contraint par l’utilisation d’un appelant C pour le tester.

ES6, 31 30 26 octets

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

N'hésitez pas à dire des idées sur la façon de réduire cela, le cas échéant.

Retina 0.8.2 , 31 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Affiche zéro sauf si le nombre est grossier. Fonctionne en convertissant l'entrée en base unaire puis en base 32 codée unaire et en comptant le nombre de 4s dans le résultat.

Java 8, 40 33 octets

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

Réponse du port de @ Adám (dzaima / APL) .

Essayez-le en ligne.

Explication:

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 octets

Les sorties 4 pour les nombres bruts lève une exception pour les nombres non bruts.

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

Essayez-le en ligne!

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

-2 octets par Jonathan Frech

#~IntegerDigits~32~MemberQ~4&

Essayez-le en ligne!

Solution de 31 octets:

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

Essayez-le en ligne!

Java 8, 28 22 21 octets

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

Inspiré par la réponse de @ kevin-cruijssen . Ne fonctionne que pour 2 mains.

Essayez-le en ligne!

Explication:

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