Avec une liste d'entiers finis non vide, affiche une valeur de vérité s'il existe exactement deux entrées égales et si toutes les autres entrées sont distinctes, et une valeur de Falsey sinon.

Exemples

truthy:
[1,1]
[1,2,1]
[1,6,3,4,4,7,9]

falsey:
[0]
[1,1,1]
[1,1,1,2]
[1,1,2,2]
[2,1,2,1,2]
[1,2,3,4,5]

code-golf array-manipulation decision-problem

— flawr
source

Je suppose que nous ne pouvons pas supposer que les entiers seront toujours inférieurs à 10?

— Martin Ender

1

Oui sauf si votre langue ne supporte pas les entiers plus grands.

— flawr

1

Pouvez-vous préciser ce que vous entendez par compatible ?

— flawr

33

J'ai vu cela au sommet de HNQ et je pensais que nous avions atteint la dernière question interpersonnelle.se

— gntskn

3

@Walfrat Postez-le comme votre propre défi. De plus, ces commentaires sont généralement appréciés dans le bac à sable.

— mardi

22

Python 3, 30 28 octets

lambda m:len({*m})+1==len(m)

Essayez-le en ligne!

{*m}jette la liste sur un setobjet, une liste non ordonnée d'éléments sans doublons. Cela réduira toujours la longueur de la liste du nombre de doublons qu'elle contient. En calculant combien la longueur a changé, nous pouvons facilement savoir si la liste comportait une seule copie et renvoyer le résultat du test.

^{-2 octets grâce aux ovs.}

— LyricLy
source

Exactement la solution que j'avais, mais j'ai oublié le {*m}raccourci au lieu de set, bien joué au golf!

— FlipTack

27 octets pour la négation . (Falsey quand il devrait être Vérité, etc.)

— mbomb007

3

Voici une autre façon bizarre de le faire (aussi la négation):lambda m:~-len(m[len({*m}):])

— mbomb007

9

Husk , 4 octets

εṠ-u

Essayez-le en ligne!

Explication

εṠ-u  Implicit input.
   u  Unique elements.
 Ṡ-   Delete them from input, counting multiplicities.
ε     Is the result a singleton list?

— Zgarb
source

7

MATL , 7 , 6 octets

&=sp4=

Essayez-le en ligne!

Un octet enregistré grâce à @Guiseppe!

Explication:

&=  % Table of pair-wise equality comparisons
    %
    % [1 0 0 0 0 0 0
    %  0 1 0 0 0 0 0
    %  0 0 1 0 0 0 0
    %  0 0 0 1 1 0 0
    %  0 0 0 1 1 0 0
    %  0 0 0 0 0 1 0
    %  0 0 0 0 0 0 1]
    %
s   % Sum each Column. Stack:
    %
    % [1 1 1 2 2 1 1]
    %
p   % Product of the array. Stack:
    %
    % [4]
    %
4=  % Compare the stack to '4'

— DJMcMayhem
source

1

Puisque sis sumet sumsums le long de la première dimension non singleton (colonnes) et que la matrice est symétrique, est-ce que cela ne pourrait pas simplement être à la splace de Xs?

— Giuseppe

1

@ Giuseppe Ah, TIL. Je vous remercie!

— DJMcMayhem

7

Haskell , 34 octets

f x=[1|a<-x,b<-x,a==b]==1:1:(1<$x)

Essayez-le en ligne! Basé sur la réponse de H.PWiz .

— Laikoni
source

6

Gelée , 8 5 octets

QL‘=L

Essayez-le en ligne!

Explication

QL‘=L  - Main link, argument L (a list)   e.g [1,6,3,4,4,7,9]
Q      - Deduplicated elements                [1,6,3,4,7,9]
 L     - Length                               6
  ‘    - Increment                            7
    L  - Length of the input                  7 ([1,6,3,4,4,7,9])
   =   - Are they equal?                      1

Si les valeurs de sortie peuvent être des valeurs cohérentes, alors QL_Lfonctionne, ce qui -1génère pour vérité et tout autre nombre non positif pour falsey (merci @JonathanAllan)

— caird coinheringaahing
source

QL_Lproduirait -1pour la vérité et un nombre inférieur à -1ou 0pour falsey (par exemple [1,6,3,4,4,7,9,9,9], reviendrait -3, tandis [1,6,3,4,7,9]que reviendrait 0).

— Jonathan Allan

@ JonathanAllan Oh oui. Je suppose que les exemples sur lesquels je l'ai testé sont tous revenus -2.

— Caird coinheringaahing

5

JavaScript (ES6), 30 octets

a=>new Set(a).size==a.length-1

Essayez-le en ligne

— Hirsute
source

4

Pushy , 8 octets

Mise en œuvre simple de vérifier si len(set(list)) == len(list)-1:

LtvuL^=#

Explication:

       \ Implicit: Put all input on stack
Ltv    \ Get the stack length - 1, save in auxiliary stack
u      \ Remove non-unique elements
L      \ Get the new length
^=     \ Compare with the previously saved length
#      \ Print result

Cela fonctionne car la longueur ne diminuera de 1 que s'il y avait seulement 1 entier non distinct dans la liste initiale.

Essayez-le en ligne!

— FlipTack
source

1

Wow, je n'ai pas vu de réponse Pushy depuis longtemps! 1

— Caird coinheringaahing

1

@cairdcoinheringaahing Pushy ne mourra jamais. Il ne fera que revenir plus fort.

— FlipTack

4

Octave , 25 octets

Ceci n'utilise pas une approche groupou uniquecomme beaucoup d'autres réponses, mais plutôt le "produit cartésien" de toutes les comparaisons possibles.

@(x)nnz(triu(x==x',1))==1

Explication

             x==x'        %create a matrix where the entry at (i,j) compares whether x(i) == x(ju)
        triu(x==x',1)     %only consider the strict upper triangular matrix
    nnz(triu(x==x',1))    %count the number of nonzero entries
@(x)nnz(triu(x==x',1))==1 %check whether this number is actually 1

Essayez-le en ligne!

Et parce qu'aucun programme ne serait complet sans convolution (merci @LuisMendo pour avoir réparé une erreur):

Octave , 40 octets

@(x)nnz(~conv(sort(x),-1:2:1,'same'))==1

Essayez-le en ligne!

— flawr
source

Tu m'as inspiré pour proposer cette approche :)

— Stewie Griffin Le

2

@StewieGriffin Je pense que la réponse MATL a utilisé votre approche exacte :)

— dimanche

4

J , 7 à 6 octets

=&#0,=

=vérifier que chaque élément est identique à chaque élément unique, crée une matrice de m lignes pour m éléments uniques.
0,ajoutez une ligne vide en haut.
=&#le nombre de lignes est-il égal à la longueur de l'entrée?

Essayez-le en ligne!

— FrownyFrog
source

Je pense que vous pouvez remplacer .~par=

— H.PWiz

@ H.PWiz Nice, édité.

— FrownyFrog

4

Retina , 15 12 11 octets

Merci à Neil pour avoir sauvegardé 1 octet.

D`
Mm2`^$
1

Essayez-le en ligne!

L'entrée est séparée par un saut de ligne. (La suite de tests utilise une séparation par virgule pour plus de commodité.)

Explication

D`

Dédupliquez les lignes dans l'entrée, ce qui supprime tout entier apparu auparavant (mais laisse le ou les sauts de ligne environnants).

Mm2`^$

Comptez le nombre de lignes vides, qui est égal au nombre de doublons supprimés, mais ne considérez que les deux premières correspondances. Ainsi, la sortie ne sera que 0(pas de doublons), 1(un duplicata), 2(deux doublons ou plus).

Assurez-vous qu’un seul duplicata a été supprimé.

— Martin Ender
source

Enregistrez un octet en limitant la correspondance de nouvelle ligne à 2, de sorte que l'entrée dans la troisième ligne soit toujours 0, 1 ou 2, ce qui simplifie le test. (Vous pouvez Fâcheusement pas utiliser A`.pour compter les sauts de ligne, car elle laisse tomber le dernier.)

— Neil

@Neil Merci, la limite est une bonne idée. J'ai également essayé d'utiliser A`., mais le problème est plutôt que vous ne pouvez pas distinguer une seule ligne vide de ne pas avoir de lignes du tout. Peut-être que je devrais envisager de terminer Aet de Gsortir avec un saut de ligne s'il y a des lignes. Bien que cela devrait probablement être une option puisque je peux imaginer que ce saut de ligne soit gênant dans d’autres scénarios.

— Martin Ender

Faire correspondre une seule ligne vide est facile - c'est juste ^$¶.

— Neil

@Neil Non, je veux dire que le résultat de Aest identique, qu'il conserve une seule ligne vide ou qu'il supprime toutes les lignes.

— Martin Ender

Désolé, c'est ce que je voulais dire par "supprime le dernier" - il renvoie une ligne vide de moins, mais vous ne pouvez pas distinguer entre 0 et 1.

— Neil

3

05AB1E , 4 octets

{¥_O

Essayez-le en ligne!

Les sorties 1sous forme de vérité, tout autre entier non négatif sous forme de fausseté. Dans 05AB1E, 1est le seul numéro de vérité (merci @Emigna pour la perspicacité!).

Explication

{       Implicit input. Sort
 ¥      Consecutive differences
  _     Boolean negate
   O    Sum. Implicit display

— Luis Mendo
source

3

Ruby, 32 octets

->(s){s.uniq.length==s.length-1}

— parenparen
source

Bienvenue chez PPCG! Parce que c'est du code golf, vous devez inclure le nombre d'octets de votre programme. J'ai pris la liberté de le faire pour vous cette fois.

— Pavel

Que diriez- Array#sizevous

— Travis

Vous pouvez obtenir jusqu'à 26 octets en utilisant->s{s.uniq.size==s.size-1}

— Conor O'Brien

3

C # (.NET Core) , 35 + 18 octets

+18 pour utiliser System.Linq.

n=>n.Distinct().Count()==n.Length-1

Essayez-le en ligne!

Alternative de 67 octets sans Linq:

n=>new System.Collections.Generic.HashSet<int>(n).Count==n.Length-1

Essayez-le en ligne!

— Ian H.
source

3

Excel, 42 octets

Version danoise

=TÆLV(A:A)=SUM(--(FREKVENS(A:A,A:A)>0))+1

Assume chaque entier de la liste dans une cellule séparée dans une colonne A.
Si nous étions autorisés pour des valeurs falsey incohérentes , nous pourrions économiser 3 octets:

=TÆLV(A:A)+SUM(-(FREKVENS(A:A,A:A)>0))

Version en langue anglaise (44 bytes)

=COUNTA(A:A)=SUM(--(FREQUENCY(A:A,A:A)>0))+1

— pyjonk
source

3

R , 32 31 octets

-1 octet grâce à @JarkoDubbeldam

cat(sum(duplicated(scan()))==1)

Essayez-le en ligne!

Lit à partir de stdin, écrit sur stdout.

duplicateditère dans la liste, en remplaçant les valeurs par lpar TRUEsi cette valeur apparaît plus tôt dans la liste, et FALSEsinon. S'il y a une paire d'âme sœur unique, il devrait y avoir exactement une TRUEvaleur, donc la somme devrait l'être 1.

— Giuseppe
source

1

31 octets

— JAD

1

@ JarkoDubbeldam ah, bien sûr. C'est bon de te revoir! Cela fait longtemps.

— Giuseppe

Été occupé avec d'autres choses, pas sûr que je sois complètement de retour.

— JAD

@ Giuseppe, je viens de lire cette question et immédiatement pensé à votre approche originale .... Très sympa! Je n'aurais jamais pensé à l' scan()approche.

— Joseph Wood

3

PowerShell , 40 37 octets

($args|sort -u).count-eq$args.count-1

Essayez-le en ligne!

La Sort-Objectcommande (alias sort) avec l' -uindicateur nique extrait uniquement les composants uniques de l'entrée. Par exemple, pour une entrée @(1,3,3,2), cela se traduira par @(1,2,3).

Ainsi, nous devons simplement nous assurer que le contenu .countde cet objet (c'est-à-dire le nombre d'éléments dont il dispose) est -eqidentique à celui .countde notre tableau d'entrée -1(c'est-à-dire que nous avons exactement une entrée dupliquée).

3 octets sauvés grâce à Sinusoid.
Correction d'un bug grâce à TessellatingHeckler.

— AdmBorkBork
source

Pouvez-vous utiliser le pseudo unique 'gu' à la place du groupe pour obtenir le même résultat?

— Sinusoid

@ Sinusoid Oui, nous pouvons. Merci!

— AdmBorkBork

Cela ne fonctionne pas sur le deuxième cas de test 1,2,1- get-uniquefonctionne uniquement sur une entrée triée au préalable. Qu'en ($args|sort -u).count-eq$args.count-1est-il de 37, mais qui fonctionne pour tous les cas de test, si vous l'appelez comme f 1 2 1au lieu de f 1,2,1?

— TessellatingHeckler

@TessellatingHeckler Ah, bonne prise. Tous les tests que j'ai effectués portaient sur une entrée présélectionnée. Merci!

— AdmBorkBork

2

Perl 5 , 36 + 1 ( `-a`) = 37 octets

map$k{$_}++,@F;@a=keys%k;say@a+1==@F

Essayez-le en ligne!

— Xcali
source

1

peut être golfé@k{@F}++;say@F==1+keys%k

— Nahuel Fouilleul

2

Haskell , 37 octets

f x=sum[1|a<-x,b<-x,a==b]==2+length x

Essayez-le en ligne!

— H.PWiz
source

2

Octave / MATLAB (avec package de statistiques / boîte à outils), 21 octets

@(x)nnz(~pdist(x))==1

Fonction anonyme. L'entrée est un vecteur de colonne. La sortie est true(affichée comme 1) ou false(affichée comme 0).

Essayez-le en ligne!

Explication

pdist(x)calcule un vecteur de distances euclidiennes entre toutes les paires de lignes de x. Il considère chaque paire une seule fois (l'ordre des deux lignes n'a pas d'importance) et ne considère pas les paires formées deux fois par la même ligne.

Dans notre cas, il xs’agit d’un vecteur colonne, la distance euclidienne entre deux lignes est donc la différence absolue entre les deux nombres.

~est la négation logique (booléenne), le nnznombre de nonzeros et se ==1compare à 1. Le résultat est donc truesi et seulement s'il n'y a qu'une seule paire qui donne une distance nulle.

— Luis Mendo
source

2

Jq 1.5 , 53 25 octets

length-(unique|length)==1

Inspiré par la réponse de Riley et beaucoup plus courte que ma solution d'origine.

Essayez-le en ligne!

— jq170727
source

2

Julia, 39 26 octets

!a=sum(a.==a')==endof(a)+2

Explication

Le code génère un tableau bidimensionnel de booléens, qui est ensuite collecté à l'aide de la fonction sum, en comptant le nombre de paires d'éléments identiques dans le carré cartésien de A. Il est ensuite comparé à la longueur de la chaîne plus deux, et les quantités sont égales seulement quand il y a exactement un caractère de répétition.

Ce code redéfinit l'opérateur NOT.

— eaglgenes101
source

!a=sum(a.==a')==endof(a)+2enregistre quelques octets. Essayez-le en ligne!

— Dennis

2

Pyth , 6 octets

qtlQl{

Vérifiez tous les cas de test.

l{ - Obtient le nombre d'éléments uniques.
tlQ - Obtient la longueur de la liste de saisie, décrémentée.
q - Vérifie l'égalité.

7 octets

q1l.-Q{

Vérifier tous les cas de test

— M. Xcoder
source

2

Octave , 23 26 octets

@(x)prod(sum(x==x'))==4

Essayez-le en ligne!

La x==x'partie a été inspirée par la réponse de flawr . C'est plus long que la réponse de Luis, mais il n'utilise aucune boîte à outils.

Explication:

C'est une fonction anonyme qui prend un vecteur xen entrée et le compare à lui-même transposé. Cela donnera une matrice où se trouvent tous les éléments diagonaux 1et tous les éléments non diagonaux indiquent qu'il y a des éléments en double.

La somme de chaque colonne indique le nombre de doublons de ce nombre. Nous voulons que deux des nombres aient un doublon, nous avons donc deux valeurs égales à deux et le reste inégal à deux.

Si nous prenons le produit de cette matrice, nous aurons 4s'il n'y a que deux éléments égaux ( 2*2*1*1*1*1*...), et autre chose que 4s'il n'y a pas de doublons, ou plus de deux.

— Stewie Griffin
source

2

PHP, 46 octets

<?=count(array_unique($argv))==count($argv)-1;

Compte le nombre d'entrées $argvet le compare au nombre d'entrées uniques. Si le premier est plus élevé que le second de 1, alors la vérité, sinon falsey.

Essayez-le sur eval.in!

— roberto06
source

Devez-vous utiliser le nom de variable $ argv ne pouvez-vous pas simplement utiliser $ a à la place?

— dading84

3

@ dading84 $argvest la liste des paramètres de ligne de commande. Donc: non, il ne peut pas simplement utiliser $a.

— Titus

2

05AB1E , 6 5 octets

{¥>ΘO

Essayez-le en ligne!

{¥>ΘO   # example input:               [1, 6, 3, 4, 4, 7, 9]
{       # sort                      -> [1, 3, 4, 4, 6, 7, 9]
 ¥      # get deltas                -> [  2, 1, 0, 2, 1, 2 ]
  >     # increment                 -> [  3, 2, 1, 3, 2, 3 ]
   Θ    # truthify (only 1 gives 1) -> [  0, 0, 1, 0, 0, 0 ]
    O   # sum                       -> 1

1étant la seule valeur de vérité dans 05AB1E, nous pouvons nous arrêter ici. (Merci @ Emigna pour l'avoir signalé.)

Pour n'obtenir que deux valeurs distinctes, on peut éventuellement ajouter:

     Θ  # equals 1?                 -> 1

— Arnauld
source

1

Si vous pouvez renvoyer une valeur Falsey pour les cas Falsey, vous pouvez ignorer la valeur Θ, car 1c'est la seule valeur de vérité de 05AB1E.

— Emigna

@ Emigna Merci! Je n'étais pas sûr que cela ait été approuvé par l'OP, mais j'imagine que oui.

— Arnauld

Je crains que vous n’ayez besoin de revenir à la solution précédente car ¢cela ne fonctionnera pas. Il compterait [19,4,4,9]aussi faux et [19,9]aussi vrai , car il trouve l' 0en 10.

— Emigna

@ Emigna Merci d'avoir remarqué cela. Je pense que c'est fixé.

— Arnauld

{¥_Odevrait être bien aussi.

— Emigna

2

APL (Dyalog Unicode) , ^SBCS 7 octets

1=≢-≢∘∪

Essayez-le en ligne!

Explication:

1=≢-≢∘∪  ⍝ Monadic function train
    ≢∘∪  ⍝ Generate a list of unique items in the input,
         ⍝ and return the length of that list
  ≢-     ⍝ Take the length of the input and subtract the above
1=       ⍝ If the difference is 1, true, otherwise false

— voidhawk
source

1

Gelée , 10 octets

ċ@€`QṢ⁼1,2

Essayez-le en ligne!

une approche plus longue mais différente

— HyperNeutrino
source

1

Japt, 7 octets

â Ê¶UÊÉ

L'essayer

Explication

Supprimez les doublons ( â), obtenez length ( Ê) et comparez equal ( ¶) avec le length ( Ê) de input ( U) moins 1 ( É).

— Hirsute
source

N'est-ce pas 12 octets? Les âÊÉ¶caractères multi-octets ne sont-ils pas ?

— RedClover

1

Haskell , 37 octets

f x=sum[1|0<-(-)<$>x<*>x]==2+length x

Essayez-le en ligne!

— flawr
source

1

05AB1E , 5 octets

gIÙg-

Essayez-le en ligne!

g     # Get number of elements in input
 IÙg  # Get number of unique elements in input
    - # Subtract

Dans 05AB1E, 1 est la seule valeur de vérité. Par conséquent, pour obtenir un résultat de vérité, il doit y avoir exactement 1 élément dupliqué supprimé par l'uniquify.

— Riley
source

À la recherche d'une âme soeur

Exemples

Python 3, 30 28 octets

Husk , 4 octets

Explication

MATL , 7 , 6 octets

Haskell , 34 octets

Gelée , 8 5 octets

Explication

JavaScript (ES6), 30 octets

Pushy , 8 octets

Octave , 25 octets

Explication

Octave , 40 octets

J , 7 à 6 octets

Retina , 15 12 11 octets

Explication

05AB1E , 4 octets

Explication

Ruby, 32 octets

C # (.NET Core) , 35 + 18 octets

Excel, 42 octets

R , 32 31 octets

PowerShell , 40 37 octets

Perl 5 , 36 + 1 ( -a) = 37 octets

Haskell , 37 octets

Octave / MATLAB (avec package de statistiques / boîte à outils), 21 octets

Explication

Jq 1.5 , 53 25 octets

Julia, 39 26 octets

Explication

Pyth , 6 octets

7 octets

Octave , 23 26 octets

Explication:

PHP, 46 octets

05AB1E , 6 5 octets

APL (Dyalog Unicode) , SBCS 7 octets

Gelée , 10 octets

Japt, 7 octets

Explication

Haskell , 37 octets

05AB1E , 5 octets

Perl 5 , 36 + 1 ( `-a`) = 37 octets

APL (Dyalog Unicode) , ^SBCS 7 octets