Questa relazione è inquietante?


73

Secondo questo fumetto di XKCD , esiste una formula per determinare se il divario di età in una relazione è "inquietante". Questa formula è definita come:

(Age/2) + 7

essendo l'età minima delle persone che puoi frequentare.

Pertanto una relazione è inquietante se una delle persone in detta relazione è più giovane dell'età minima dell'altra.

Data l'età di due persone, puoi capire se quella relazione è inquietante?

Regole

  1. Il tuo programma dovrebbe prendere due numeri interi come input, l'età di entrambe le persone nella relazione. Questi possono essere presi in qualsiasi formato ragionevole.

  2. Il tuo programma deve quindi generare un valore di verità o falsità che descriva se la relazione è "inquietante" (Verità = Creepy).

  3. Non sono ammesse scappatoie standard.
  4. Questo puzzle è Code Golf, quindi vince la risposta con il codice sorgente più breve in byte

Casi test

40, 40    - Not Creepy
18, 21    - Not Creepy
80, 32    - Creepy
15, 50    - Creepy
47, 10000 - Creepy
37, 38    - Not Creepy
22, 18    - Not Creepy

3
Come dovrebbe age/2essere arrotondato? Probabilmente su se la metà esatta dovrebbe essere il minimo? 17,21sarebbe un buon caso di prova.
Martin Ender,

4
@MartinEnder Il valore è un minimo, quindi non arrotondare affatto. Non deve essere un numero intero.
Leo,

81
Puoi anche aggiungere 13, 13 - Creepy.
Greg Martin,

12
47, 10000 è una combinazione ... interessante. Vorrei anche sottolineare che secondo questa formula, è inquietante per Doctor Who uscire con un essere umano.
David Conrad,

8
@DavidConrad - beh sì. è fondamentalmente la bestialità da parte sua ...
Batman,

Risposte:



17

Python 3 , 26 byte

lambda x:max(x)/2+7>min(x)

Provalo online!
L'input è un elenco con entrambe le età


Ho avuto lo stesso prima di leggere le risposte esistenti. +1
ElPedro,

Sembra che potresti effettivamente assumere una tupla in cui è sempre (più giovane, più grande) - appena chiesto a OP - chiedersi cosa dirà.
rm-vanda,

@ rm-vanda, ho chiesto prima, non puoi presumere
Stephen,

15

05AB1E , 8 6 byte

;7+R‹Z

Provalo online! oppure prova tutti i test

         # Implicit Input: an array of the ages
;        # Divide both ages by 2
 7+      # Add 7 to both ages
   R     # Reverse the order of the ages
         #    this makes the "minimum age" line up with the partner's actual age
    ‹    # Check for less than the input (vectorized)
     Z   # Push largest value in the list

3
Come programmatore C concordo sul fatto che 2 è veritiero.
Gmatht,

@gmatht Questo dovrebbe sempre restituire 0 o 1, mai 2.
Riley

4
[13,13] è doppiamente inquietante.
gmatht

1
@gmatht Immagino che sarebbe doppio. Non pensavo ai numeri così piccoli. È comunque vero.
Riley,

@Riley 2non è vero, guarda questo .
Okx,

13

Cancelli NAND, 551

16-bit creepiness calculator Creato con Logisim

Stesso principio dell'altra mia risposta , ma accetta input con segno a 2 byte, quindi può gestirlo 47, 10000. Funziona con TUTTI i casi di test!

Questo non è ottimale per i casi di test dati, poiché 10000 possono essere espressi con solo 15 dei 16 bit, ma funziona per tutte le età nell'intervallo [-32768, 32768). Si noti che qualsiasi età negativa verrà restituita 1.

Ingressi a sinistra (nessun ordine particolare, 1 bit in alto). Uscita in basso a destra.


10

Porte NAND, 274 262

Originale:

Meglio: creato con Logisim

Questo accetta due input a sinistra come numeri interi con segno a 1 byte, con 1 bit in alto. L'output è in basso a sinistra; la verità e la falsità qui dovrebbero essere ovvie.

Funziona con tutti i casi di test tranne 47, 10000, quindi immagino che tecnicamente questa non sia una risposta valida. Tuttavia, la persona più anziana sul record (affidabile) era 122, quindi 8 bit (max 127) funzioneranno per qualsiasi scenario possibile fino a questo punto. Pubblicherò una nuova risposta (o dovrei modificarla?) Quando finisco la versione a 16 bit.

La versione a 16 bit è terminata!

Noterai alcune sezioni verticali del circuito. Il primo (da sinistra) determina quale input è maggiore. I prossimi due sono multiplexer, ordinando gli input. Aggiungo quindi 11111001(-7) al minore nella quarta sezione e concludo confrontando due volte questo con l'input maggiore. Se è inferiore, la relazione è inquietante. Dato che cambio i bit per raddoppiare, devo prendere in considerazione il bit inutilizzato di lesser-7. Se questo è un 1, allora lesser-7è negativo e il più giovane dei due non ha più di sei anni. Raccapricciante. Termino con un gate OR, quindi se uno dei test di creepiness ritorna 1, l'intero circuito lo fa.

Se guardi da vicino, vedrai che ho usato sette una costante s (codifica dura 11111011e finale 0). L'ho fatto perché Logisim richiede almeno un valore per un gate logico per produrre un output. Tuttavia, ogni volta che viene utilizzata una costante, due porte NAND garantiscono un 1valore indipendentemente dalla costante.

-12 porte grazie a me !


Ho notato un'ovvia ottimizzazione. Se lo fai notare prima che io modifichi, ti accrediterò comunque!
Khuldraeseth na'Barya,

9

C #, 22 byte

n=>m=>n<m/2+7|m<n/2+7;

1
Non sono un programmatore C #, ma è richiesto il punto e virgola finale come parte della funzione?
Olivier Grégoire,

1
@ OlivierGrégoire È solo una sintassi non valida se omessa; questa è una funzione anonima
gatto,

8

C, 29 byte

#define f(a,b)a/2+7>b|b/2+7>a

Come funziona:

  • #define f(a,b)definisce una funzione macro fche accetta due argomenti non tipizzati.
  • a/2+7>b controlla se la prima età divisa per due più sette è più grande della seconda età.
  • b/2+7>a controlla se la seconda età divisa per due più sette è più grande della prima età.
  • Se uno dei valori sopra è vero, restituisce 1 (inquietante). Altrimenti, restituisce 0 (non inquietante).

Provalo online!


dovresti capovolgere il confronto, dovrebbe essere come >bno<b
Khaled.K

Citare "essendo l'età minima" significa che devi verificare se age >= min, anche tu hai bisogno di E invece di OR, poiché entrambe le parti devono soddisfare per non essere inquietante, test case "47, 10000 - Creepy"
Khaled.K

okay ho corretto l'errore, ma la logica è sbagliata, torna vero, tio.run
Khaled.K

1
@ No
MD XF,

1
Saluti, grazie per il link
Tas,

7

JavaScript (ES6), 21 byte

a=>b=>a<b/2+7|b<a/2+7

Restituisce 0 per non inquietante, 1 per inquietante.

f=a=>b=>a<b/2+7|b<a/2+7

console.log(f(40)(40));
console.log(f(18)(21));
console.log(f(80)(32));
console.log(f(15)(50));
console.log(f(47)(10000));
console.log(f(37)(38));
console.log(f(22)(18));


Salva un byte con curry: a=>b=>invece di (a,b)=>, chiama con f(40)(40).
Stephen,

@StephenS, grazie, ho imparato qualcosa di nuovo!
Rick Hitchcock,

Nessun problema, l'ho imparato quando qualcuno mi ha detto la stessa cosa :) funziona solo con due parametri, dopo che non ne vale la pena.
Stephen,


5

Retina , 20 byte

O`.+
^1{7}(1+)¶1\1\1

Provalo online!

L'input è unario con un avanzamento di riga tra i due numeri. L'output è 0(non inquietante) o 1(inquietante).

Spiegazione

O`.+

Ordina i due numeri, quindi sappiamo che quello più grande è il secondo.

^1{7}(1+)¶1\1\1

Chiama l'età più piccola ae l'età più grande b. Prima catturiamo a-7in gruppo 1. Poi cerchiamo di abbinare 2*(a-7)+1in b, il che significa b >= 2*(a-7)+1o b >= 2*(a-7)o b/2+7 > ache è il criterio per un rapporto inquietante.


5

TI-Basic, 20 10 9 byte

max(2Ans<14+max(Ans

-10 byte usando un elenco e parte del suggerimento di Timtech

-1 byte usando il suggerimento di lirtosiast

Comprende un elenco di due età, "{40,42}: prgmNAME"

Restituisce 1 per "inquietante" e 0 per "non inquietante".


TI-BASIC chiude automaticamente le parentesi in corrispondenza di un simbolo di prova ( < <= = != >= >)?
Zacharý,

@ Zacharý No, TI-Basic chiude solo le parentesi alla fine di una linea o di due punti.
pizzapants184

Oh, scusa, ho dimenticato che l'input è stato preso come un elenco di numeri!
Zacharý,

4

GNU APL 1.2, 23 byte

Definisce una funzione che accetta due argomenti e stampa 1 se inquietante, 0 se no.

∇A f B
(A⌊B)<7+.5×A⌈B
∇

Spiegazione

inizia e termina la funzione
A f Bè l'intestazione della funzione; La funzione viene denominata fe accetta due argomenti Ae B(le funzioni in APL possono essere monadiche - prendere un argomento - o diadico - prendere due argomenti)
A⌊Bè min(A,B)ed A⌈Bè max(A,B)
APL valutata da destra a sinistra, quindi sono necessarie le parentesi per garantire la corretta precedenza

Gli altri operatori si spiegano da soli.

Il codice potrebbe essere in grado di giocare a golf, io sono ancora nuovo a code-golf.


1
Benvenuti nel sito!
OldBunny2800,

Caspita, GNU APL, non lo vedo da un po '.
Zacharý,

Inoltre, è possibile prendere gli argomenti come un elenco: f Xallora (⌊/X)<7+.5×⌈/X. IIRC è possibile rimuovere la nuova riga tra la seconda e la terza riga.
Zacharý,

@ Zacharý Sì, sono possibili lambda anonime. Non sono supportati da questa versione di GNU APL e la più recente non viene compilata su Mac. Alcune delle mie altre risposte usano APL 1.7 perché le collaudo su Ubuntu. Non ho usato lambdas (potrei risolverli in seguito) perché sono ancora abbastanza nuovo in APL.
Arc676,

Prova ngn-apl. È open-source come GNU APL, ma in tutta onestà è meglio.
Zacharý,

4

Python 3, 74 45 byte

First Code Golf, probabilmente terribile.

Riduzione di 29 byte di @Phoenix

lambda a,b:0 if(a/2)+7>b or(b/2)+7>a else 1

Ciao, assicurati di formattare correttamente il codice utilizzando il sistema di markdown.
Leo,

non ti preoccupare, qualcuno mi ha battuto, ma risolverò male
KuanHulio

Puoi sbarazzarti di alcuni degli spazi lì :)
Decadimento Beta

Inoltre, lambda a,b:0 if(a/2)+7>b or(b/2)+7>a else 1dovrebbe funzionare ed è molto più breve.
Pavel,

1
lambda a,b:a/2+7>b or b/2+7>a. Abbandonare l'onere di quei fastidiosi 1s e 0s e abbracciare il potere di True/ False!
Value Ink

3

JavaScript (ES6), 27 byte

f=a=>b=>b>a?f(b)(a):b>a/2+7

Nessun curry (chiama come f(a,b)invece di f(a)(b))

f=(a,b)=>b>a?f(b,a):b>a/2+7

Se b > a, scambiare i parametri e riprovare. Altrimenti, controlla. Currying non salva alcun byte a causa della chiamata ricorsiva.

f=a=>b=>b>a?f(b)(a):b>a/2+7

console.log(f(18)(22))
console.log(f(22)(18))
console.log(f(18)(21))


3

Java, 21 byte

a->b->a/2+7>b|b/2+7>a

Assolutamente non originale.

analisi

Provalo online!

import java.util.function.*;

public class Pcg122520 {
  static IntFunction<IntPredicate> f = a->b->a/2+7>b|b/2+7>a;
  public static void main(String[] args) {
    int[][] tests = {
      {40, 40},
      {18, 21},
      {80, 32},
      {15, 50},
      {47, 10000},
      {37, 38},
      {22, 18}
    };
    for (int[] test: tests) {
      System.out.printf("%d, %d - %s%n", test[0], test[1], f.apply(test[0]).test(test[1]) ? "Creepy" : "Not creepy");
    }
  }
}

1
+1 per la menzione " Assolutamente non originale. ". Quasi nessun altro lo fa, mentre sono quasi tutti uguali. E mi sono preso la libertà di aggiungere un collegamento TIO dal tuo codice di test. Non sei sicuro del motivo per cui aggiungi sempre un codice di prova, ma non un collegamento TIO ? .. :)
Kevin Cruijssen,

1
Grazie Kevin! A volte ne aggiungo uno, a volte no. Dipende se ho il mio IDE aperto o chiuso. E 'così semplice! : P Inoltre, mostro il codice di prova in modo che le persone possano capire cosa rende valido questo lambda. :)
Olivier Grégoire

3

Python 3, 31 byte

lambda a,b:abs(a-b)>min(a,b)-14

Non molto più breve degli altri invii di Python, ma ho trovato un modo leggermente diverso per verificare la presenza di brividi. Ho notato che la differenza accettabile tra le età è pari a min - 14. Ciò deriva dalla riorganizzazione algebrica della formula.

min = (max/2) + 7
min - 7 = max/2
2*min - 14 = max

dif = max - min
max = dif + min

2*min - 14 = dif + min
min - 14 = dif

Questo mi consente di risolvere senza ricorrere a due costanti e anche senza utilizzare sia il massimo sia il minimo, invece di usare abs (ab). Dal punto di vista del golf ho ottenuto solo un byte in meno rispetto alla soluzione di @ nocturama, ma ho usato una formula leggermente diversa per farlo.


Sicuramente questo fallisce il [37,53] (non nella suite di test ma) all'interno dello spirito (x / 2) +7 di questo fairway
Alexx Roche,

@AlexxRoche No, quando viene dato [37,53] come [a, b], il calcolo dovrebbe diventare abs(37 - 53) > min(37, 53) - 14 = abs(-16) > 37 - 14 = 16 > 23 = False Questa è la risposta corretta, perché secondo (x / 2) + 7, l'età minima per 53 è53/2 + 7 = 26.5 + 7 = 33.5
Delya Erricson

3

Excel, 26 24 byte

Formula della cella che accetta input come numeri dall'intervallo di celle A1:B1e genera un valore booleano che rappresenta la creepiness nella cella della formula

=OR(A1/2+7>B1,B1/2+7>A1)

Vecchia versione, 26 byte

=MAX(A1:B1)/2+7>MIN(A1:B1)

2

TI-Basic, 10 9 10 byte

2min(Ans)-14≤max(Ans

Elenco input da Ans, output 1se "inquietante" o 0altro.


2

Matematica , 16 byte

Max@#/2+7<Min@#&

Provalo online!

-2 byte grazie a @GregMartin

Vero per non inquietante, falso per inquietante.

            (* Argument: A list of integers     *)
Max@#       (* The maximum of the input         *)
 /2+7       (* Divided by 2, plus 7             *)
  <         (* Is less than?                    *)
   Min@#    (* The minimum of the input         *)
    &       (* Anonymous function               *)

Salva 2 byte prendendo le età come elenco:Max@#/2+7<Min@#&
ngenisi

2

SAS, 77 byte

%macro t(a,b);%put%eval(%sysfunc(max(&a,&b))/2+7>%sysfunc(min(&a,&b)));%mend;

2

Röda , 16 byte

{sort|[_<_/2+7]}

Provalo online!

Questa è una funzione anonima che accetta input come due letterali (non una matrice) dal flusso di input.

Spiegazione

{sort|[_<_/2+7]}                 Anonymous function
 sort                            Sorts the numbers in the input stream
     |[       ]                  And push
       _<                        whether the smaller value  is less than
         _/2+7                   the greater value / 2 + 7



2

Python 3 - 32 27 byte

Impossibile commentare, ma ho ottenuto una risposta leggermente più breve rispetto all'altra soluzione Python 3:

lambda *a:min(a)<max(a)/2+7

-5 grazie a @Cyoce!


puoi rimuovere lo spazio inlambda *a
Cyoce

1

Fourier, 37 byte

oI~AI~B>A{1}{A~SA~BS~B}A/2+7>B{1}{@o}

Provalo su FourIDE!

Accetta due numeri come input. Giocherà a golf più tardi.


Non è necessario emettere una stringa del genere, può essere veritiera o falsa
Leone,

Bel golf. È stato veloce.
MD XF,


1

Japt , 11 byte

Ritorna trueper "raccapricciante" e falseper non.

wV /2+7>UmV

Provalo online


Spiegazione

      :Implicit input of first integer U
wV    :Get the maximum of U and the second integer V
/2+7  :Divide by 2 & add 7
>     :Check if the result is greater than...
UmV   :the minimum of the two integers.

1

J, 10 byte

<.<7+2%~>.

Uscite 1per non inquietanti, 0per inquietanti

Spiegazione

<.          NB. the minimum
  >         NB. is greater than
    7+2%~>. NB. half the maximum + 7

1

J-uby , 25 byte

:>%[:min,:max|~:/&2|:+&7]

Chiama come f^[80,32]. Dà trueper non inquietante,false per inquietante.

Spiegazione

    :min                  # the minimum
:>%[    ,               ] # is greater than
         :max|            # the maximum...
              ~:/&2|        # over two...
                    :+&7    # plus 7 

Questa è una lingua meravigliosa Ho trascorso molto tempo a cercare di raggiungere obiettivi simili con Ruby (l'ho chiamato "Blurb"), ma appoggiarsi pesantemente ha method_missingportato a troppa complessità. Questo approccio è pulito ed elegante. Congratulazioni!
Giordania,

@Jordan grazie! Non posso prendermi tutto il merito, poiché questo è stato fortemente ispirato da J (da cui il nome). Sono aperto ai suggerimenti di un altro programmatore di Ruby se ne hai.
Cyoce,

@Jordan dovresti vedere alcune delle altre risposte J-uby più complesse. Sono abbastanza qualcosa.
Cyoce,

1

AWK , 26 byte

{$0=$1/2+7>$2||$2/2+7>$1}1

Provalo online!

Uscite 1 per "Creepy" e 0 per "Not Creepy". Potrebbe salvare 3 byte se nessun output potrebbe essere considerato un valore errato, tramite:

$0=$1/2+7>$2||$2/2+7>$1
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.