Étant donné une liste d'entiers, créez un masque booléen de sorte que les vrais indices puissent être utilisés pour filtrer les valeurs distinctes de la liste. Quel indice est sélectionné comme vrai n'a pas d'importance tant qu'un seul d'entre eux est sélectionné pour chaque ensemble d'indices correspondant à des valeurs identiques.

L'entrée sera une liste non vide d'entiers non négatifs dans un format adapté à votre langue et la sortie sera une liste de valeurs booléennes suivant la spécification ci-dessus. Vous êtes autorisé à utiliser vos propres définitions des valeurs véridiques et fausses dans la liste de sortie.

Dans mes exemples ci-dessous, je définis 1pour être vrai et 0pour être faux.

[5, 4, 7, 1]  Input
[1, 1, 1, 1]  Output
              Select only the values with with true indicies in the sieve
[5  4  7  1]  Contains zero duplicate values

[5, 9, 7, 5, 6, 0, 5]
[0, 1, 1, 1, 1, 1, 0]
[   9, 7, 5, 6, 0   ]

Cas de test

Lorsqu'il y a un or, cela signifie qu'il y a plusieurs sorties valides. S'il y a des points de suspension ...après le or, cela signifie que toutes les sorties possibles n'ont pas été répertoriées.

[0] = [1]

[55] = [1]

[32, 44] = [1, 1]

[0, 0] = [1, 0] or [0, 1]

[9001, 9001, 9001] = [1, 0 , 0] or [0, 1, 0] or [0, 0, 1]

[5, 4, 7, 1] = [1, 1, 1, 1]

[1, 2, 3, 4, 3, 5] = [1, 1, 1, 1, 0, 1] or
                     [1, 1, 0, 1, 1, 1]

[5, 9, 7, 5, 6, 0, 5] = [1, 1, 1, 0, 1, 1, 0] or
                        [0, 1, 1, 1, 1, 1, 0] or
                        [0, 1, 1, 0, 1, 1, 1]

[0, 8, 6, 6, 3, 8, 7, 2] = [1, 1, 1, 0, 1, 0, 1, 1] or
                           [1, 0, 0, 1, 1, 1, 1, 1] or
                           [1, 0, 1, 0, 1, 1, 1, 1] or
                           [1, 1, 0, 1, 1, 0, 1, 1]

[45, 47, 47, 45, 24, 24, 24, 8, 47, 41, 47, 88]
= [1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1] or ...

[154, 993, 420, 154, 154, 689, 172, 417, 790, 175, 790, 790, 154, 172, 175, 175, 420, 417, 154, 175, 172, 175, 172, 993, 689, 993, 993, 790]
= [1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] or ...

Règles

• C'est le golf de code, donc la solution la plus courte l'emporte.
• Les Builtins sont autorisés!
• Vous êtes autorisé à utiliser vos propres définitions des valeurs véridiques et fausses dans la liste de sortie. Si vous choisissez de le faire, veuillez indiquer vos définitions.
• L'entrée sera une liste non vide d'entiers non négatifs.
• Vous êtes libre de choisir entre sortir un seul des tamis ou plusieurs ou même tous. Tant que chaque tamis est valide, il sera accepté.

MATL, 7 6 4 octets

1 octet enregistré grâce à @Luis
2 octets enregistrés grâce à @Dennis

&=Rs

Nous définissons 1la vérité et toutes les autres valeurs comme falsey

Essayez-le en ligne

Tous les cas de test

Explication

    % Implicitly grab input array
&=  % 2D array of equality comparisons
R   % Get the upper triangular portion
s   % Sum down the columns
    % Implicitly display the result

Gelée , 4 octets

ĠṪ€Ṭ

Favorise les dernières occurrences. Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça fonctionne

ĠṪ€Ṭ  Main link. Argument: A (array)

Ġ     Group; paritition the indices of A according to their corresponding values.
 Ṫ€   Tail each; select the last index of each group.
   Ṭ  Untruth; generate a Boolean array with 1's at the specified indices.

Python 3, 47 35 39 36 octets

lambda n:[n.pop(0)in n for x in n*1]

Extrait le premier élément de la liste, vérifie s'il existe ailleurs dans la liste et insère Trueou Falsedans une nouvelle liste.

Pour cette fonction, Falseindique une valeur distincte, et Trueest autrement (True=0 et False=1)

Merci à Dennis pour une tonne d'octets

Original, 47 octets:

lambda n:[(1,0)[n.pop()in n]for x in[1]*len(n)]

Essayez-le

Pyth, 6 octets

.eqxQb

Affiche une liste de bools (True et False). Vérifie pour chaque élément dans l'entrée, si son index est égal à l'index de la première occurrence de la valeur. En d'autres termes, cela vérifie si chaque élément est la première occurrence.

En pseudocode pythonique:

.e      enumerated_map(lambda b,k:    # maps with b as value and k as index
  q       equal(
   xQb      Q.index(b),
            k),                       # implicit lambda variable
          Q)                          # implicit argument to map

Testez-le ici.

J , 2 octets

~:

C'est de là qu'est née l'idée de ce défi. Le builtin ~:est appelé Nub-Sieveen J et crée une liste booléenne qui effectue l'opération décrite dans le défi. Ici, 1représente trueet 0représente false.

05AB1E , 8 octets

Code:

v¹ykN>Qˆ

Explication:

y         # For each in the array
 ¹yk      # Get the index of that element in the array
    N>Q   # And see if it's equal to the index
       ˆ  # Add to the global array and implicitly output

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

APL, 6 octets

⍳∘⍴∊⍳⍨

Essayez-le

Explication:

   ⍳⍨  For each character in the string, get the index of its first occurrence
⍳∘⍴     Make a list 1 .. length of input
  ∊    Check if each index is present

C #, 63 octets

int[]l(List<int> i)=>i.Select((m,n)=>i.IndexOf(m)-n).ToArray();

Je pourrais également lui faire retourner 1 ou 0 et faire ainsi le paramètre et le type de retour le même, ce qui me permet d'en faire une expression lambda par lui-même?

quelques conseils seraient appréciés

même code de type

    public static List<int>l(List<int>i){
        return i.Select((m,n)=>i.IndexOf(m)==n?1:0).ToList();
    }

Python, 35 octets

f=lambda l:l and[l.pop(0)in l]+f(l)

Utilise Truecomme valeur fausse et Falsepour valeur vraie. Marque la dernière apparition de chaque élément.

Sélectionne le premier élément uniquement s'il n'apparaît pas parmi les éléments restants, puis revient au reste de la liste tant qu'il n'est pas vide. Le l.pop(0)extrait le premier élément tout en le supprimant.

Rétine , 23 octets

(\d+)((?!.* \1\b))?
$#2

L'entrée est une liste séparée par des espaces. (En fait, d'autres formats comme[1, 2, 3] fonctionneront également tant qu'il y aura un espace devant chaque numéro, sauf le premier.)

Essayez-le en ligne!(Fonctionne simultanément sur plusieurs cas de test séparés par des sauts de ligne.)

Nous transformons simplement chaque élément en 0s'il en existe une autre copie plus tard dans l'entrée et dans le 1cas contraire.

PowerShell v2 +, 40 octets

$a=@();$args[0]|%{(1,0)[$_-in$a];$a+=$_}

Crée un tableau vide $a. Ensuite, nous prenons la liste d'entrée via $args[0]et la canalisons dans une boucle |%{...}. Chaque itération que nous sélectionnons soit 1ou à 0partir d'un pseudo-ternaire selon que l'élément courant est $aou non. Ces sélections sont laissées sur le pipeline. On ajoute ensuite l'élément courant dans le tableau$a . Les éléments du pipeline sont rassemblés et la sortie sous forme de tableau est implicite.

Exemple:

(sortie ici avec un séparateur de nouvelle ligne, car c'est la valeur .ToString()par défaut pour un tableau)

PS C:\Tools\Scripts\golfing> .\distinct-sieves.ps1 1,2,3,4,1,3,5,7
1
1
1
1
0
0
1
1

JavaScript (ES6), 31 octets

f=a=>a.map((e,i)=>i-a.indexOf(e))

Zéro est vrai et d'autres chiffres sont faux.

Mathematica, 53 31 octets

Merci aux miles de m'avoir donné une idée qui a permis d'économiser 22 octets.

s[[;;x++]]~FreeQ~#&/@(x=0;s=#)&

Perl 5

push@o,map{$b=pop@a;(grep{/^$b$/}@a)?1:0}(1..~~@a);

Java, 96 octets

void s(int[]a){for(int i=0,j,n=a.length,b=1;i<n;a[i++]=b,b=1)for(j=i+1;j<n;)b=a[i]==a[j++]?0:b;}

Modifie le tableau sur place. Favorise la dernière occurrence.

La valeur véridique est 1tandis que la valeur de falsey est 0.

Vérifiez tous les cas de test .

Non golfé:

void sieve(int[]a){
    int n = a.length;
    for(int i=0;i<n;i++){
        int b = 1;
        for(int j=i+1;j<n;j++){
            if(a[i] == a[j]){
                b = 0;
            }
        }
        a[i] = b;
    }
}

En fait, 11 octets

;╗ñ`i@╜í=`M

Essayez-le en ligne!

Explication:

;╗ñ`i@╜í=`M
;╗           save a copy of input in reg0
  ñ          enumerate
   `i@╜í=`M  for each (index, value) pair:
    i@         flatten, swap
      ╜í       first index in input of value
        =      compare equality

Pyke, 4 octets

F@oq

Essayez-le ici!

     - o = 0 #(Implicit)
F    - for i in input:
 @   -   input.index(i)
   q -  ^==V
  o  -   o+=1

C ++, 242 octets

Certes, une solution exagérée, car elle fonctionne sur n'importe quel conteneur standard de tout type commandé:

#include<algorithm>
#include<list>
#include<set>
template<class T>auto f(T a){using V=typename T::value_type;std::set<V>s;std::list<bool>r;std::transform(a.begin(),a.end(),std::back_inserter(r),[&](V m){return s.insert(m).second;});return r;}

Non golfé:

(et plus généralisé)

template<class T>
auto f(T a)
{
    using std::begin;
    using std::end;
    using V=typename T::value_type;
    std::set<V>s;
    std::list<bool>r;
    std::transform(begin(a),end(a),std::back_inserter(r),[&](V m){return s.insert(m).second;});
    return r;
}

Suite de tests:

int test(const std::list<bool>& expected, const auto& x) { return f(x) != expected; }
#include<array>
#include<chrono>
#include<forward_list>
#include<initializer_list>
#include<string>
#include<vector>
using namespace std::literals::chrono_literals;
int main()
{
    return 0
        + test({},            std::vector<short>{})
        + test({1},           std::array<int,1>{})
        + test({1},           std::vector<char>{55})
        + test({true,true},   std::vector<unsigned>{32,44})
        + test({1,0},         std::list<std::string>{"zero", "zero"})
        + test({1,0,0},       std::vector<long>{9001,9001,9001})
        + test({1,1,1,1},     std::array<char,4>{5,4,7,1})
        + test({1,1,1,1,0,1}, std::initializer_list<std::string>{"one","two","three","four","three","five"})
        + test({1,0,1,0,0},   std::forward_list<std::chrono::seconds>{60s, 1min, 3600s, 60min, 1h});
}

TSQL 52 octets

DECLARE @ TABLE(i int identity, v int)
INSERT @ values(1),(2),(3),(4),(3),(5)

SELECT i/max(i)over(partition by v)FROM @ ORDER BY i

Violon

PHP, 66 62 39 octets

• accepte toutes les valeurs atomiques (booléen, entier, flottant, chaîne) à l'
  exception des valeurs évaluées en faux (faux, 0, "") et les chaînes numériques ("1" est égal à 1)
• drapeaux première occurrence

nouvelle version (programme, 37 + 2 octets)
^{bat Java et (maintenant encore) C #. Même bat presque Python maintenant. Content.}

<?foreach($a as$v)$u[$v]=print$u[$v]|0;

• +6 pour PHP> = 5.4, + 16-3 pour une fonction
• imprime la liste des non délimitées 0(true) et 1(faux)
  insérer !aprèsprint inverser
• utilisation: set register_globals=On, short_open_tags=Onet error_reporting=0dans php.inipour php-cgi
  demandâmesphp-cgi -f <filename> a[]=<value1> a[]=<value2> ...;echo"" ;
• pour PHP> = 5.4: remplacez $apar $_GET[a](+6), définissez short_open_tags=Oneterror_reporting=0
• ou remplacez $apar array_slice($argv,1)(+19), supprimez <?(-2)
  et appelezphp -d error_reporting=0 -r '<code>' <value1> <value2> ...;echo""

ancienne version (fonction, 62 octets)

function f($a){foreach($a as$v)$u[$v]=1|$m[]=$u[$v];return$m;}

• renvoie un tableau de falsepour vrai et truepour faux; (ouput sous forme de chaîne vide ou 1)
  insérer !après$m[]= pour inverser
• Il existe également un autre moyen pour une fonction qualifiée avec 55 octets.

tests (sur ancienne version)

function out($a){if(!is_array($a))return$a;$r=[];foreach($a as$v)$r[]=out($v);return'['.join(',',$r).']';}
function test($x,$e,$y){static $h='<table border=1><tr><th>input</th><th>output</th><th>expected</th><th>ok?</th></tr>';echo"$h<tr><td>",out($x),'</td><td>',out($y),'</td><td>',out($e),'</td><td>',(strcmp(out($y),out($e))?'N':'Y'),"</td></tr>";$h='';}
$samples=[
    [0],[1],    [55],[1],    [32,44],[1,1],    [9001,9001,9001],[1,false,false],
    [5,4,7,1],[1,1,1,1],    [1,2,3,4,3,5],[1,1,1,1,false,1],
    [5,9,7,5,6,0,5],[1,1,1,false,1,1,false],    [0,8,6,6,3,8,7,2],[1,1,1,false,1,false,1,1],
    [45,47,47,45,24,24,24,8,47,41,47,88],[1,1,'','',1,'','',1,'',1,'',1],
    [154,993,420,154,154,689,172,417,790,175,790,790,154,172,175,
        175,420,417,154,175,172,175,172,993,689, 993,993,790],
        array_merge([1,1,1,false,false,1,1,1,1,1],array_fill(0,18,false))
];
for($i=count($samples);$i--;--$i)for($j=count($samples[$i]);$j--;)$samples[$i][$j]=!$samples[$i][$j];
while($samples)
{
    $a=array_shift($samples);
    $em=array_shift($samples);
    test($a,$em,$ym=s($a));
    $eu=[];foreach($em as$i=>$f)if($f)$eu[]=$a[$i];
    $yu=[];foreach($ym as$i=>$f)if($f)$yu[]=$a[$i];
#   sort($eu); sort($yu);
    test('unique values',$eu,$yu);
}
echo '</table>';

Haskell, 29 27 octets

f a=[elem x t|x:t<-tails a]

Utilise Falsecomme valeur vraie Trueou fausse:

λ> let f a=[elem x t|x:t<-tails a] in f [5, 9, 7, 5, 6, 0, 5]
[True,False,False,True,False,False,False]

Vous devrez peut-être import Data.Listutiliser, tailsmais, tryhaskell.org exécute le code tel quel .

Perl 5 + Perligata , 343 octets

315 octets, plus 28 pour -MLingua::Romana::Perligata

Utilisé comme perl -MLingua::Romana::Perligata foo.pl ; entrée (depuis stdin) et sortie (vers stdout) sont des chaînes séparées par des traits de soulignement d'entiers décimaux. Testé sur Strawberry 5.20.2 avec la version 0.6 de Perligata; Je ne sais pas si cela fonctionne avec la version 0.50 de Perligata.

huic vestibulo perlegementum da.qis _ scindementa da.dum qis fac sic
ao qis decumulamentum da.ao aum tum nullum addementum da.meo io.meo ro.per ium in qis fac sic
si ium tum aum aequalitas fac sic ro I da cis cis
ro nullum tum non rum addementum da.capita bis rum cis
per in bis fac sic hoc tum _ egresso scribe cis

Évidemment, c'est clair comme une cloche. Dans le cas contraire, exécutez-le avec -MLingua::Romana::Perligata=converteau lieu de-MLingua::Romana::Perligata , et perl, au lieu d'exécuter le script, produisez une traduction en Perl normal:

 $_ = Lingua::Romana::Perligata::getline (*STDIN );
 @q = split ( '_');
while (@q) { $a = pop (@q );
 $a =  ($a + 0);
my $i ;
my $r ;
for $i (@q) {if ( ($i eq $a)) { $r = 1}
}
;
 $r =  (0 +  ! ($r));
unshift (@b, $r)}
;
for $_ (@b) {print (STDOUT $_, '_')}

Pour une analyse jeton par jeton, utilisez -MLingua::Romana::Perligata=discribe .

Notes de golf:

• Sans papiers (mais sans surprise), vous n'avez pas besoin d'espace après . .
• (Aussi sans surprise,) scinde n'a pas besoin d'un deuxième argument et utilisehoc .
• Je devais utiliser ao aum tum nullum addementum da parce que je ne pouvais pasmorde au travail.
• De même, j'ai utilisé per ium in qis... ro I da parce que je ne pouvais pas obtenirvanne au travail.
• Au lieu de huic vestibulo perlegementum da , j'ai essayé -pMLingua::Romana::Perligata, mais je n'ai pas pu le faire fonctionner non plus.

Juste pour les coups de pied (bien que toute cette réponse soit juste pour les coups de pied):

• Après l'avoir nettoyé Huic vestibulo perlegementum da. Qis lacunam scindementa da. Dum qis fac sic ao qis decumulamentum da. Ao aum tum nullum addementum da. Meo io. Meo ro. Per ium in qis fac sic si ium tum aum aequalitas fac sic ro I da cis cis. Ro nullum tum non rum addementum da. Capita bis rum cis. Per in bis fac sic hoc tum lacunam egresso scribe cis., Google Translate donne This court perlegementum grant. QIS gap scindementa grant. While QIS QIS decumulamentum do so ao da. Ao sum and no addementum grant. My io. My ro. Through ium in QIS do so if the sum ium equality do so ro 1 from cis. Ro was not any rum addementum grant. The heads of the bis side. Write, do so as soon as he at that time that in the gap by the Kish was taken..