Sono un numero maleducato?


72

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 9 (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 è , quindi vince il punteggio più basso in byte.


43
assume we continue with a third handQuando si tratta di essere scortesi, il lavoro di squadra fa funzionare il sogno.
Veskah,

5
@Veskah scopre che per i limiti della domanda, hai solo bisogno di 3 persone per creare un determinato numero. Sicuramente batte il vecchio tipo di contare sulle dita.
Gryphon - Ripristina Monica il

12
È peggio se sei britannico - anche il 6 è maleducato!
Matteo

1
È corretto accettare input in una base diversa da 10?
wastl

2
5 sembra anche abbastanza scortese. Non sono sicuro che qualcuno direbbe "Oh, aveva il pollice fuori, è perfettamente educato"
ale10ander

Risposte:



17

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

13
Pensavo di conoscere regex, ma apparentemente no.
CT Hall


10

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)

8

Rubino, 36 19 byte

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

Provalo online!

Salvato 17 byte con il metodo @tsh .


Questo è vero per 2207, che ha una rappresentazione binaria di100010011111
Incarnazione dell'ignoranza il

@EmbodimentofIgnorance Questo è il risultato corretto, no? La seconda mano è 00100.
Maniglia della porta

Non parlo Ruby. Ma perché no ->n{n.to_s(32)=~/4/}?
TSH

1
@tsh perché non sono intelligente come te :)
Maniglia della porta

Scusami se non capisco la domanda, ma non è la prima mano del 2207 10001, la seconda 00111e la terza 11? Nessuno di loro ha il dito medio solo in alto
Incarnazione dell'ignoranza il

8

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.


6

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.25=32



6

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!


1
Un'idea interessante da usare idiv, però. Non vedo miglioramenti incrementali a questo. Ma vedi la mia risposta : 14 byte per un loop di spostamento che utilizza MOV / AND / SUB / JZ per verificare la maleducazione dei 5 bit bassi.
Peter Cordes,



4

Catholicon , 4 byte

ǔ?QǑ

Accetta un numero come stringa base-256.

Provalo online!

Suite di test


2
Hm, se questo è permesso, allora è consentito accettare numeri nella base 32?
ricorsivo il

@recursive È possibile racchiudere i numeri <<e >>consente numeri superiori a 255 in quelli, come mostrato nella suite di test.
Okx,

1
Era inteso come una domanda sulla sfida, ma non era molto chiaro.
ricorsivo il

4

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!


27? come bonus non viene prodotto in modo strano
ASCII-only

1
anche quello che è tplig
solo ASCII il

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


1
L'arresto o meno di un programma non è un metodo di output consentito . L'output tramite eccezione è consentito.
Deadcode


3

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.


@Giuseppe Oops, l'ho perso del tutto. Dovrebbe funzionare ora, anche se in modo deludente di 19 byte in più. Non credo che ci sia una funzione inversa per strtoi diverso da quello esadecimale e ottale nella base R
Nick Kennedy,

48 byte con qualche magia matrice. Credo che la conversione dei bit sia più lunga di intToBitsma poi possiamo lavorare intsinvece di quelli rawche finiscono per salvare un byte - vedi per esempio questo conintToBits
Giuseppe,

@Giuseppe è una soluzione completamente diversa (e ordinata) dalla mia - vuoi che aggiorni la mia o pubblichi la tua?
Nick Kennedy,

sei libero di prenderlo. :-)
Giuseppe,

1
naturalmente, il porting di una delle molte risposte che verifica la presenza di una cifra 4in un numero base-32 è, oh, 29 byte .
Giuseppe,



2

Carbone , 6 byte

№⍘N³²4

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

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




2

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

2

MATL , 8 byte

32YA52=a

Provalo online!


@Luis Posso sicuramente eliminare il G(non so perché l'ho incluso in primo luogo) ma è solo un byte (grazie per averlo individuato!). Cambiare 32YA52in 32_YA4è lo stesso numero di byte giusto?
Sanchises

Ah, sì, non posso contare
Luis Mendo il

2
@Luis Count? Chi ha bisogno di contare quando puoi'32_YA4'n'32YA52'n-
Sanchises

2

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.


2

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

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.


2

ES6, 31 30 26 byte

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

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


Benvenuti in PPCG!
Laikoni,

Non hai bisogno di contare il nome della tua funzione, e anche se penso che puoi salvare un byte usando test, puoi effettivamente salvare due byte abbinandoli 4come numero e lasciandolo matchconvertire in una stringa e poi in RegExp per te .
Neil

1

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.



1

> <> , 28 byte

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

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

Provalo online!


1
Un'eccezione è accettabile, la risposta C # lo fa
solo ASCII

1

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!


Ciao e benvenuto in PPCG. Allo stato attuale, la tua espressione è un singolo valore booleano. Correggi la risposta in modo che sia un programma completo o una funzione ( ...#...&viene spesso utilizzata in Mathematica).
Jonathan Frech,

Ciao. È ciò che intendi?
Rainer Glüge,

per favore usa tio.run/#mathematica invece di W | A per assicurarti che sia un codice matematico valido: P e [n]alla fine non hai bisogno del &. Inoltre, poiché i post hanno una cronologia delle modifiche, va bene tralasciare le voci precedenti e la convenzione per i punteggi precedenti è<s>40</s> <s>36</s>
ASCII, solo il

Sì. Questo è ciò che intendevo. 29 byte .
Jonathan Frech,

Immagino che mi debba abituare allo stile di programmazione funzionale.
Rainer Glüge,

1

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

Sono abbastanza sicuro che le risposte debbano funzionare con entrambe le mani
Embodiment of Ignorance
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.