Dada uma lista de números inteiros, crie uma máscara booleana para que os índices verdadeiros possam ser usados ​​para filtrar os valores distintos da lista. Qual índice é selecionado como o verdadeiro não importa, desde que apenas um deles seja selecionado para cada conjunto de índices correspondentes a valores idênticos.

A entrada será uma lista não vazia de números inteiros não negativos em um formato adequado ao seu idioma e a saída será uma lista de valores booleanos seguindo a especificação acima. Você tem permissão para usar suas próprias definições de valores de verdade e falsidade na lista de saída.

Nos meus exemplos abaixo, defino 1ser verdadeiro e 0falso.

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

Casos de teste

Quando existe um or, significa que existem várias saídas válidas. Se houver reticências à direita ...após orisso, significa que nem todas as saídas possíveis foram listadas.

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

Regras

• Isso é código-golfe então a solução mais curta vence.
• Builtins são permitidos!
• Você tem permissão para usar suas próprias definições de valores de verdade e falsidade na lista de saída. Se você optar por fazê-lo, indique suas definições.
• A entrada será uma lista não vazia de números inteiros não negativos.
• Você é livre para escolher entre produzir apenas uma das peneiras ou várias ou mesmo todas. Desde que cada peneira seja válida, ela será aceita.

MATL, 7 6 4 bytes

1 byte economizado graças a @Luis
2 bytes economizados graças a @Dennis

&=Rs

Definimos 1ser verdade e todos os outros valores como falsey

Experimente Online

Todos os casos de teste

Explicação

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

Gelatina , 4 bytes

ĠṪ€Ṭ

Favorece as últimas ocorrências. Experimente online! ou verifique todos os casos de teste .

Como funciona

ĠṪ€Ṭ  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 bytes

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

Aparece o primeiro item da lista, verifica se ele existe em algum lugar da lista e insere True ou Falseem uma nova lista.

Para esta função, Falseindica um valor distinto e, Truecaso contrário , é (True=0 e False=1)

Agradecimentos a Dennis por uma tonelada de bytes

Original, 47 bytes:

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

Tente

Pitão, 6 bytes

.eqxQb

Mostra uma lista de bools ( TrueeFalse ). Verifica cada elemento na entrada, se seu índice é igual ao índice da primeira ocorrência do valor. Em outras palavras, isso está verificando se cada elemento é a primeira ocorrência.

No pseudocódigo pitônico:

.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

Teste aqui.

J , 2 bytes

~:

Foi daí que surgiu a idéia para esse desafio. O builtin ~:é chamado Nub-Sieveem J e cria uma lista booleana que executa a operação descrita no desafio. Aqui, 1representa truee 0representa false.

05AB1E , 8 bytes

Código:

v¹ykN>Qˆ

Explicação:

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

Usa a codificação CP-1252 . Experimente online! .

APL, 6 bytes

⍳∘⍴∊⍳⍨

Tente

Explicação:

   ⍳⍨  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 bytes

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

Eu também poderia fazê-lo retornar 1 ou 0 e, portanto, tornar o parâmetro e retornar o mesmo tipo, permitindo que eu fizesse isso uma expressão lambda por si só?

alguma orientação seria apreciada

mesmo código de tipo

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

Python, 35 bytes

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

Usa Truecomo valor falso e Falsepara o valor verdadeiro . Marca a última aparência de cada elemento.

Seleciona o primeiro elemento apenas se ele não aparecer entre os elementos restantes e depois volta para o restante da lista, desde que não esteja vazio. Ele l.pop(0)extrai o primeiro elemento e também o remove.

Retina , 23 bytes

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

Entrada é uma lista separada por espaço. (Na verdade, outros formatos [1, 2, 3]também funcionarão desde que haja um espaço na frente de cada número, exceto o primeiro.)

Experimente online!(Funciona em vários casos de teste separados por avanço de linha de uma só vez.)

Simplesmente transformamos cada elemento em 0se houver outra cópia mais tarde na entrada e em 1outro.

PowerShell v2 +, 40 bytes

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

Cria uma matriz vazia $a. Então pegamos a lista de entradas via$args[0] e isso em um loop |%{...}. A cada iteração, selecionamos um 1ou 0de um pseudo-ternário com base em se o elemento atual está $aou não. Essas seleções são deixadas no pipeline. Em seguida, adicionamos o elemento atual à matriz $a. Os elementos do pipeline são reunidos e a saída como uma matriz está implícita.

Exemplo:

(imprima aqui com um separador de nova linha, já que esse é o padrão .ToString()para uma matriz)

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 bytes

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

Zero é verdade e outros números são falsos.

Mathematica, 53 31 bytes

Obrigado por milhas por me dar uma idéia que salvou 22 bytes.

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

Perl 5

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

Java, 96 bytes

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

Modifica a matriz no local. Favorece a última ocorrência.

O valor 1verdade é enquanto o valor falsey é 0.

Verifique todos os casos de teste .

Ungolfed:

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

Na verdade, 11 bytes

;╗ñ`i@╜í=`M

Experimente online!

Explicação:

;╗ñ`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 bytes

F@oq

Experimente aqui!

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

C ++, 242 bytes

É certo que é uma solução de exagero, pois funciona em qualquer contêiner padrão de qualquer tipo solicitado:

#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;}

Ungolfed:

(e generalizado)

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

Suíte de teste:

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 bytes

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

Violino

PHP, 66 62 39 bytes

• aceita todos os valores atômicos (booleano, inteiro, flutuante, string)
  exceto os valores avaliados como falso (falso, 0, "") e seqüências numéricas ("1" é igual a 1)
• sinaliza a primeira ocorrência

nova versão (programa, 37 + 2 bytes)
^{supera Java e (agora novamente) C #. Até quase supera o Python agora. Feliz.}

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

• +6 para PHP> = 5,4, + 16-3 para uma função
• impressões lista não delimitado de 0(true) e 1(false)
  inserção !apósprint a invert
• uso: definir register_globals=On, short_open_tags=One error_reporting=0em php.inipara php-cgi
  , em seguida, chamadaphp-cgi -f <filename> a[]=<value1> a[]=<value2> ...;echo"" ;
• para PHP> = 5.4: substitua $apor $_GET[a](+6), defina short_open_tags=Oneerror_reporting=0
• ou substitua $apor array_slice($argv,1)(+19), remova <?(-2)
  e chamephp -d error_reporting=0 -r '<code>' <value1> <value2> ...;echo""

versão antiga (função, 62 bytes)

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

• retorna matriz de falsepara verdadeiro e truepara falso; (saída como string vazia ou 1)
  inserir !após$m[]= inverter
• Há outra maneira de uma função qualificada com 55 bytes também.

testes (na versão antiga)

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 bytes

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

Usa Falsecomo verdadeiro, Truecomo valor falso:

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

Você pode precisar import Data.Listusar tails, mas tryhaskell.org executa o código como está.

Perl 5 + Perligata , 343 bytes

315 bytes, mais 28 para -MLingua::Romana::Perligata

Use como perl -MLingua::Romana::Perligata foo.pl; input (from stdin) e output (to stdout) são sequências de números decimais separadas por sublinhado. Testado no Strawberry 5.20.2 com versão 0.6 do Perligata; Não sei se funciona com o Perligata versão 0.50.

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

Obviamente, isso é claro como um sino. Caso contrário, execute-o com em -MLingua::Romana::Perligata=convertevez de -MLingua::Romana::Perligatae perl, em vez de executar o script, produzirá uma tradução no Perl regular:

 $_ = 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 $_, '_')}

Para uma análise token por token, use -MLingua::Romana::Perligata=discribe.

Notas de golfe:

• Não documentado (mas não surpreendente), você não precisa de um espaço depois ..
• (Também não é surpreendente) scindenão precisa de um segundo argumento e usa hoc.
• Eu tive que usar ao aum tum nullum addementum daporque não conseguia mordetrabalhar.
• Da mesma forma, usei per ium in qis... ro I daporque não conseguia vannetrabalhar.
• Em vez disso huic vestibulo perlegementum da, tentei -pMLingua::Romana::Perligata, mas também não consegui fazê-lo funcionar.

Apenas para chutes (embora toda essa resposta tenha sido apenas para chutes):

• Depois de limpá-lo 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., o Google Translate dá 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..