Questa è una funzione?

47

Dato un elenco di (key, value)coppie, determinare se rappresenta una funzione, il che significa che ciascun tasto viene mappato su un valore coerente. In altre parole, ogni volta che due voci hanno chiavi uguali, devono anche avere valori uguali. Le voci ripetute sono OK.

Per esempio:

# Not a function: 3 maps to both 1 and 6
[(3,1), (2,5), (3,6)]

# Function: It's OK that (3,5) is listed twice, and that both 6 and 4 both map to 4
[(3,5), (3,5), (6,4), (4,4)]

Input: una sequenza ordinata di (key, value)coppie utilizzando le cifre da 1 a 9. Potrebbe non essere necessario un ordine particolare. In alternativa, è possibile prendere l'elenco di chiavi e l'elenco di valori come input separati.

Output: un valore coerente per le funzioni e un valore coerente diverso per le non funzioni.

Casi di prova: i primi 5 ingressi sono funzioni, gli ultimi 5 no.

[(3, 5), (3, 5), (6, 4), (4, 4)]
[(9, 4), (1, 4), (2, 4)]
[]
[(1, 1)]
[(1, 2), (2, 1)]

[(3, 1), (2, 5), (3, 6)]
[(1, 2), (2, 1), (5, 2), (1, 2), (2, 5)]
[(8, 8), (8, 8), (8, 9), (8, 9)]
[(1, 2), (1, 3), (1, 4)]
[(1, 2), (1, 3), (2, 3), (2, 4)]

Eccoli come due elenchi di input:

[[(3, 5), (3, 5), (6, 4), (4, 4)], [(9, 4), (1, 4), (2, 4)], [], [(1, 1)], [(1, 2), (2, 1)]]
[[(3, 1), (2, 5), (3, 6)], [(1, 2), (2, 1), (5, 2), (1, 2), (2, 5)], [(8, 8), (8, 8), (8, 9), (8, 9)], [(1, 2), (1, 3), (1, 4)], [(1, 2), (1, 3), (2, 3), (2, 4)]]

Classifica:

Mostra snippet di codice

code-golf  decision-problem 
— XNOR
fonte
funzione suriettiva?
— Colpisci
@Poke Non deve essere suriettivo.
— xnor
L'ingresso potrebbe essere due elenchi di uguale lunghezza, uno per le chiavi uno per i valori?
— Calvin's Hobbies,
2
Va (key,value)bene invertire le coppie, come in (value,key)? Posso eliminare qualche byte dalla mia risposta in tal caso.
— ymbirtt,
1
@ymbirtt Sì, puoi avere le coppie in entrambi gli ordini.
— xnor

Risposte:

37

Python 2 , 34 byte

lambda x:len(dict(x))==len(set(x))

Provalo online!

Crea un dizionario e un set dall'input e confronta le loro lunghezze.
I dizionari non possono avere chiavi duplicate, quindi tutti i valori illegali (e ripetuti) vengono rimossi.

— asta
fonte
5
Python 3, 30 byte:lambda x:not dict(x).items()^x
— Veedrac,
21

Haskell, 36 byte

f x=and[v==n|(k,v)<-x,(m,n)<-x,k==m]

Provalo online!

Il ciclo esterno (-> (k,v)) e quello interno (-> (m,n)) sulle coppie e ogni volta k==m, raccolgono il valore di verità di v==n. Controlla se tutti sono veri.

— Nome del modello
fonte
Sei troppo veloce! : /
— flawr
18

Brachylog , 5 4 byte

dhᵐ≠

Provalo online!

Programma completo. Per quanto ne so, il motivo per cui questo sta battendo la maggior parte degli altri linguaggi del golf è che ≠è incorporato in Brachylog, mentre la maggior parte degli altri linguaggi del golf deve sintetizzarlo.

Spiegazione

dhᵐ≠
d     On the list of all unique elements of {the input},
 h    take the first element
  ᵐ     of each of those elements
   ≠  and assert that all those elements are different

Come programma completo, otteniamo truese l'affermazione ha successo o falsese fallisce.

15

Pyth , 5 byte

Sono abbastanza contento di questo.

{IhM{
       implicit input
    {  removes duplicate pairs
  hM   first element of each pair
{I     checks invariance over deduplication (i.e. checks if no duplicates)

Provalo online!

— notjagan
fonte
9

Retina , 25 byte

1`({\d+,)(\d+}).*\1(?!\2)

Provalo online!

Il formato di input è {k,v},{k,v},.... Stampa 0per funzioni e 1per non funzioni. Potrei salvare due byte usando gli avanzamenti di riga anziché le virgole nel formato di input, ma è incasinato.

— Martin Ender
fonte
Credo che si qualifichi come "seriamente stupido", almeno dal punto di vista tecnico.
— FryAmTheEggman,
8

Brachylog , 13 byte

¬{⊇Ċhᵐ=∧Ċtᵐ≠}

Provalo online!

Spiegazione

¬{          }      It is impossible...
  ⊇Ċ               ...to find a subset of length 2 of the input...
   Ċhᵐ=            ...for which both elements have the same head...
       ∧           ...and...
        Ċtᵐ≠       ...have different tails.
— Fatalize
fonte
Puoi spiegare come Ċhᵐ=e come Ċtᵐ≠funziona?
— Calcolatrice
@CalculatorFeline Le lettere maiuscole sono nomi di variabili. Ċè una variabile speciale chiamata Couple che è sempre preconcisa in un elenco di due elementi. ᵐè un metapredicato che applica il predicato immediatamente precedente ( h - heado t - tailqui) a ciascun elemento dell'input (qui, Ċ). =e ≠controllare semplicemente che il loro input contenga tutti gli elementi uguali / tutti diversi.
— Fatalizza il
7

MATL , 8 byte

1Z?gs2<A

Gli input sono: un array con la values, seguito da un array con la keys.

L'output è 1per la funzione, 0altrimenti.

Provalo online! . Oppure verifica tutti i casi di test .

Spiegazione

1Z?

Crea una matrice sparsa. Inizialmente tutte le voci contengono 0; e 1viene aggiunto a ciascuna voce in (i, j)cui je isono l'input key, le valuecoppie.

g

La matrice viene convertita in logica; ovvero, le voci che superano 1(corrispondenti a duplicati key, valuecoppie) sono impostate su 1.

s

Viene calcolata la somma di ogni colonna. Questo è il numero di diverse values per ciascuna key.

2<A

Una funzione avrà tutte queste somme inferiori a 2.

— Luis Mendo
fonte
6

R, 33 byte

Questa è la mia versione per R. Questo sfrutta la avefunzione. Ho consentito un input vuoto impostando i valori predefiniti sulla chiave e sui parametri dei valori. avesta producendo una media dei valori per ciascuna delle chiavi. Fortunatamente questo restituisce i mezzi nello stesso ordine dei valori di input, quindi un confronto con l'input indicherà se ci sono valori diversi. Restituisce TRUEse è una funzione.

function(k=0,v=0)all(ave(v,k)==v)

Provalo online!

— MickyT
fonte
6

05AB1E , 11 9 7 byte

Salvato 2 byte grazie a kalsowerus .

Ùø¬DÙQ,

Provalo online!

Spiegazione

Ù           # remove duplicates
 ø          # zip
  ¬         # get the first element of the list (keys)
   D        # duplicate list of keys
    Ù       # remove duplicates in the copy
     Q      # compare for equality
      ,     # explicitly print result
— Emigna
fonte
@Riley: Sì. Sono ancora abbastanza contento che il caso speciale sia finito solo per un terzo del programma: P
— Emigna,
Penso che potresti risparmiare 3 byte sostituendo `\)^con head ( ¬): TIO
— kalsowerus,
@kalsowerus: Sfortunatamente questo si interrompe per il caso speciale di []:(
— Emigna,
@Enigma Oh ha funzionato perché durante i test avevo ancora un residuo ,alla fine. Aggiungilo e poi funziona in qualche modo [].
— Kalsowerus,
TIO
— kalsowerus,
5

JavaScript (ES6), 45 38 byte

6 byte salvati grazie a @Neil

a=>a.some(([k,v])=>m[k]-(m[k]=v),m={})

Restituisce falseo trueper funzioni e non funzioni, rispettivamente.

Questo funziona sottraendo costantemente il vecchio valore di ciascuna funzione ( m[k]) e quello nuovo ( m[k]=v, che memorizza anche il nuovo valore). Ogni volta, ci sono tre casi:

  • Se non esisteva un valore precedente, m[k]restituisce undefined. Sottraendo qualsiasi cosa dai undefinedrisultati NaN, il che è falso.
  • Se il vecchio valore è uguale a quello nuovo, ne m[k]-vrisulta 0che è falso.
  • Se il vecchio valore è diverso da quello nuovo, si m[k]-vottiene un numero intero diverso da zero, il che è vero.

Pertanto, dobbiamo solo assicurarci che m[k]-(m[k]=v)non sia mai vero.

— ETHproductions
fonte
1
Troppo tempo. Usa a=>!a.some(([x,y])=>m[x]-(m[x]=y),m=[]).
— Neil,
@Neil Dang, sapevo che doveva esserci un modo per utilizzare l' m[k]essere indefinito ... Grazie!
— ETHproductions
5

Mathematica, 24 byte

UnsameQ@@(#&@@@Union@#)&

Spiegazione: Unionelimina le coppie duplicate, quindi #&@@@ottiene il primo elemento da ciascuna coppia (come First/@ma con meno byte). Se c'è una ripetizione in questi primi elementi, le coppie non fanno una funzione, con cui controlliamo UnsameQ.

(Questo potrebbe avere la più alta densità di @caratteri in qualsiasi programma che ho scritto ...)

— Non un albero
fonte
2
@densità =
— Calcolatrice
4

Bash + coreutils, 17

sort -u|uniq -dw1

L'ingresso viene fornito tramite STDIN. keye valuesono Tabseparati e ogni coppia è delimitata da newline.

sortrimuove le coppie chiave-valore duplicate. uniq -dgenera solo duplicati, quindi genera la stringa vuota nel caso di una funzione e una stringa non vuota in caso contrario, quando sono presenti chiavi duplicate associate a valori diversi.

Provalo online .

— Trauma digitale
fonte
4

05AB1E , 9 byte

Codice:

ãü-ʒ¬_}}Ë

Spiegazione:

ã            # Cartesian product with itself
 ü-          # Pairwise subtraction
   ʒ  }}     # Filter out elements where the following is not true:
    ¬_       #   Check whether the first digit is 0
        Ë    # Check if all equal

Utilizza la codifica 05AB1E . Provalo online!

— Adnan
fonte
ʒ
— Riuscire a mettermi
@Emigna Yeah haha: p, ma ho già trovato un bug che mi fa usare }}invece di }.
— Adnan,
4

Gelatina , 6 byte

QḢ€µQ⁼

Provalo online!

Spiegazione

QḢ€µQ⁼
Q      - Remove duplicate pairs
 Ḣ€    - Retrieve the first element of each pair
   µ   - On the output of what came before..
     ⁼ - Are the following two equal (bit returned)?
    Q  - The output with duplicates removed
       - (implicit) the output.

Ecco un metodo alternativo, anche 6 byte:

QḢ€ṢIẠ

Provalo online!

Invece di testare con la rimozione di chiavi duplicate, questo ordina ( Ṣ) e verifica se la differenza tra terms ( I) è tutta verità ( Ạ)

— fireflame241
fonte
4

R , 95 66 byte

function(k,v)any(sapply(k,function(x){length(unique(v[k==x]))-1}))

Salvato 29 byte grazie a Jarko Dubbeldam.

Funzione anonima. Emette FALSEse una funzione e in TRUEcaso contrario (scusate). Prende come argomenti un elenco di chiavi e un elenco di valori, in questo modo.

> f(c(1,2,5,1,2),c(2,1,2,2,5))
[1] TRUE # not a function

Passa attraverso tutte le chiavi e afferra la lunghezza dell'insieme di valori univoci per quella chiave. Se uno anydi questi è> 1, ritorna TRUE.

Questo è battuto dalla risposta di MickyT e anche da quella di Giuseppe . vota una di quelle.

— BLT
fonte
Perché stai creando un frame di dati, solo per fare riferimento ai vettori che hai appena inserito in quel frame di dati? function(k=0,v=0)any(sapply(k,function(x){length(unique(v[k==x]))-1}))dovrebbe realizzare la stessa cosa.
— JAD
Perché sto ancora imparando! Almeno una delle altre risposte R fa più o meno come descrivi.
— BLT
scusami se sono venuto un po 'duro :) la tua presentazione è un po' diversa dalle altre risposte R, e se dovessi tagliare i data.frame ridondanti, potresti essere in grado di confrontare meglio.
— JAD
4

J-uby , 48 33 25 21 byte

-3 byte grazie alla Giordania! 

:size*:==%[:to_h,~:|]

Spiegazione

:size*:==%[:to_h,~:|]

# "readable"
(:size * :==) % [:to_h, ~:|]

# transform :% to explicit lambda
->(x){ (:size * :==).(:to_h ^ x, ~:| ^ x)

# apply explicit x to functions
->(x){ (:size * :==).(x.to_h, x|x) }

# expand :* (map over arguments)
->(x){ :==.(:size.(x.to_h), :size.(x|x) }

# simplify symbol calls to method calls
->(x){ x.to_h.size == (x|x).size }

# :| is set union for arrays; x|x just removes duplicates, like :uniq but shorter
->(x){ x.to_h.size == x.uniq.size }

Primo approccio, 33 byte

-[:[]&Hash,:uniq]|:*&:size|:/&:==

Questo è più lungo dell'equivalente soluzione Ruby, ma è stato divertente da realizzare.

Tentativo di spiegazione trasformandosi in Ruby:

-[:[]&Hash,:uniq]|:*&:size|:/&:==

# "readable"
-[:[] & Hash, :uniq] | (:* & :size) | (:/ & :==)                  

# turn into explicit lambda
->(x){ (:/ & :==) ^ ((:* & :size) ^ (-[:[] & Hash, :uniq] ^ x)) } 

# simplify expressions now that we have an explicit x
->(x){ :== / (:size * [Hash[x], x.uniq]) }                          

# translate to equivalent Ruby code
->(x) { [Hash[x], x.uniq].map(&:size).reduce(:==) }               

# simplify reduce over explicit array
->(x) { Hash[x].size == x.uniq.size }

Potrei salvare 2 byte con una versione più recente sostituendola :uniqcon~:|

— Cyoce
fonte
3

Mathematica, 35 byte

(l=Length)@Union@#==l@<|Rule@@@#|>&

Funzione pura che prende un elenco di coppie ordinate come input e che restituisce Trueo False. Sfrutta il fatto che Union@#elimina le coppie ordinate ripetute, ma <|Rule@@@#|>(un'associazione) elimina tutte le coppie ordinate tranne una con un primo elemento particolare. Quindi possiamo solo confrontare le Lengths delle due uscite per verificare se l'elenco di input è una funzione.

— Greg Martin
fonte
3

Gelatina , 6 byte

nþ`ḄCȦ

Provalo online!

Come funziona

nþ`ḄCȦ  Main link. Argument: M (n×2 matrix)

nþ`     Construct the table of (a != b, c != d) with (a, b) and (c, d) in M.
   Ḅ    Unbinary; map (0, 0), (0, 1), (1, 0), (1, 1) to 0, 1, 2, 3 (resp.).
    C   Complement; map each resulting integer x to 1 - x.
     Ȧ  All; test if all resulting integers are non-zero.
— Dennis
fonte
3

CJam , 19 17 byte

Salvato 2 byte grazie a Martin Ender

0l~$2ew{:.=~!&|}/

Uscite 0per funzioni e 1per non funzioni.

Provalo online!

Spiegazione

0                     e# Push a 0. We need it for later.
 l~                   e# Read and eval a line of input.
   $                  e# Sort it by the keys.
    2ew               e# Get all consecutive pairs of the sorted list.
       {              e# For each pair of pairs:
        :.=           e#  Check if the keys are equal and if the values are equal.
           ~!&        e#  Determine if the keys are equal AND the values are not equal.
              |       e#  OR with 0. If any pair indicates that the input is not a function,
                      e#  this will become 1 (and remain 1), otherwise it will be 0.
               }/     e# (end block)
— Gatto di affari
fonte
3

APL (Dyalog) , 16 12 11 9 byte

(∪≡⊢)⊃¨∘∪

Provalo online!

Spiegazione

∪             Unique, remove duplicates; (3 5) (3 5) => (3 5)
¨∘            For each element
⊃             Pick the first sub element (3 5) (2 3) => 3 

 ≡            Check whether the arguments (listed below) are the same
  ⊢           The right argument
∪             And the right argument with duplicates removed

Stampa 0per falso e 1vero

— Kritixi Lithos
fonte
Whoa, stai diventando davvero bravo.
— Adám,
3

In realtà , 4 byte

╔♂F═

Provalo online!

Spiegazione:

╔♂F═
╔     uniquify (remove duplicate pairs)
 ♂F   take first items in each pair (keys)
   ═  are all of the keys unique?
— Mego
fonte
3

Brainfuck , 71 byte

,[[-[->>+<<]+>>],>[[->+<<->]<[<<]>]>[-<+>]<<[->+<]+[-<<]>>,]-[--->+<]>.

Provalo online!

L'input viene considerato come una stringa piatta: ad esempio, il primo caso di test sarebbe 35356444. Per ottenere la rappresentazione mostrata nella domanda originale, è sufficiente aggiungere un totale di sei virgole al programma nei punti giusti.

L'output è Uper funzioni e Vper non funzioni.

Spiegazione

Per qualsiasi codice ASCII il punto n, f (n) è memorizzato nella cella 2n + 1. Le celle 2n e 2n + 2 sono spazio di lavoro e 0, 2, 4, 6, ... 2n-2 sono una scia di pangrattato per ricondurre alla cella 0. Quando l'ingresso ha dimostrato di non essere una funzione, f ( 0) è impostato su 1 (tra i vari effetti collaterali).

,                  input first key
[                  start main loop
 [-[->>+<<]+>>]    move to cell 2n, leaving a trail of breadcrumbs
 ,                 input value corresponding to current key
 >[                if key already has a value:
   [->+<<->]<      copy existing value, and compare to new value
   [<<]            if values are different, go to cell -2
   >               go back to cell 2n+1 (or -1 if mismatch)
 ]
 >[-<+>]           move existing value back to cell 2n+1 (NOP if no existing value, move the 1 from cell 0 to cell -1 if mismatch)
 <<[->+<]          copy new value to cell 2n+1 (NOP if there was already a value)
 +[-<<]>>          follow breadcrumbs back to cell 0 (NOP if mismatch)
 ,                 input next key
]                  (if mismatch, cell -2 becomes the next "cell 0", and the next key is also effectively changed by the breadcrumbs left lying around)
-[--->+<]>.        add 85 to cell 1 and output the result
— Nitrodon
fonte
2

Pyth - 9 8 byte

ql.d{Ql{

Provalo

Funziona rimuovendo prima tutte le coppie ripetute ({Q); quindi confronta la lunghezza dell'elenco con la lunghezza di un dizionario creato dall'elenco (se lo stesso valore x si verifica più di una volta, il costruttore del dizionario utilizza solo l'ultimo, risultando il dizionario più breve dell'elenco)

— Maria
fonte
2

MATL , 12 byte

iFFvXu1Z)SdA

L'input è una matrice a 2 colonne, in cui la prima colonna è chiave e la seconda è valore.

Provalo online!

Spiegazione

i     % Input: 2-column matrix
FFv   % Postpend a row with two zeros. This handles the empty case
Xu    % Unique rows. This removes duplicate (key, value) pairs
1Z)   % Select first column, that is, key. We need to check if all
      % keys surviving at this point are different
S     % Sort
d     % Consecutive differences
A     % Are all values nonzero?
— Luis Mendo
fonte
2

PHP, 49 byte

foreach($_GET as[$x,$y])($$x=$$x??$y)-$y&&die(n);

Non stampa nulla per funzioni e nnon funzioni.

— user63956
fonte
1

CJam , 14 11 9 byte

_&0f=__&=

Provalo online!

Accetta l'input come una matrice di coppie chiave / valore nello stack, restituisce 1se l'input è una funzione e 0se non lo è.

Questa soluzione si basa sullo snippet _&, che de-duplica un array prendendo l'intersezione impostata di esso con se stesso. Lo faccio due volte, prima sull'input completo (per sbarazzarsi di qualsiasi coppia chiave / valore esattamente duplicata) e poi solo sulle chiavi (per vedere se ci sono ancora chiavi duplicate dopo la prima de-duplicazione).

Ecco il codice completo con commenti:

_&           "remove duplicate key/value pairs from input";
  0f=        "remove the values, leaving only the keys";
     _       "make a copy of the array of keys";
      _&     "remove duplicate keys from the copy";
        =    "compare the de-duplicated key array with the original";
— Ilmari Karonen
fonte
Solo per quello che sai, e#è la sintassi dei commenti di linea dedicata in CJam.
— Esolanging Fruit,
1

Rubino, 39 30 29 byte

Grazie a @ValueInk per aver salvato 9 byte!

->x{Hash[x].size==(x|x).size}

Python 2 di Port of @ Rod .

— Cyoce
fonte
Hash[x]funziona altrettanto bene tbh
— Value Ink
@ValueInk grazie. Non sono sicuro del perché non ci abbia pensato.
— Cyoce,
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.