Dada una lista de enteros, cree una máscara booleana de modo que los índices verdaderos se puedan usar para filtrar los valores distintos de la lista. El índice seleccionado como verdadero no importa siempre que solo se seleccione uno de ellos para cada conjunto de índices correspondientes a valores idénticos.

La entrada será una lista no vacía de enteros no negativos en un formato adecuado para su idioma y la salida será una lista de valores booleanos siguiendo la especificación anterior. Puede usar sus propias definiciones de valores de verdad y falsedad en la lista de resultados.

En mis ejemplos a continuación, defino 1ser verdadero y 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 prueba

Cuando hay un or, significa que hay múltiples salidas válidas. Si hay puntos suspensivos finales ...después de or, significa que no se enumeraron todas las salidas posibles.

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

Reglas

• Este es el código de golf, por lo que gana la solución más corta.
• ¡Las construcciones están permitidas!
• Puede usar sus propias definiciones de valores de verdad y falsedad en la lista de resultados. Si elige hacerlo, indique sus definiciones.
• La entrada será una lista no vacía de enteros no negativos.
• Usted es libre de elegir entre emitir solo uno de los tamices o múltiples o incluso todos. Mientras cada tamiz sea válido, será aceptado.

MATL, 7 6 4 bytes

1 byte guardado gracias a @Luis
2 bytes guardados gracias a @Dennis

&=Rs

Definimos 1ser veraces y todos los demás valores como falsey

Pruébalo en línea

Todos los casos de prueba

Explicación

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

Jalea , 4 bytes

ĠṪ€Ṭ

Favorece los últimos sucesos. Pruébalo en línea! o verificar todos los casos de prueba .

Cómo 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]

Hace estallar el primer elemento de la lista, comprueba si existe en otra parte de la lista e inserta Trueo Falseen una nueva lista.

Para esta función, Falseindica un valor distinto, y de Truelo contrario es ( True=0y False=1)

Gracias a Dennis por una tonelada de bytes.

Original, 47 bytes:

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

Intentalo

Pyth, 6 bytes

.eqxQb

Emite una lista de bools ( Truey False). Comprueba para cada elemento en la entrada, si su índice es igual al índice de la primera aparición del valor. En otras palabras, esto está verificando si cada elemento es la primera ocurrencia.

En 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

Pruébalo aquí.

J , 2 bytes

~:

Aquí es donde se originó la idea de este desafío. La construcción ~:se llama Nub-Sieveen J y crea una lista booleana que realiza la operación descrita en el desafío. Aquí, 1representa truey 0representa false.

05AB1E , 8 bytes

Código:

v¹ykN>Qˆ

Explicación:

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

Utiliza la codificación CP-1252 . Pruébalo en línea! .

APL, 6 bytes

⍳∘⍴∊⍳⍨

Intentalo

Explicación:

   ⍳⍨  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();

¿También podría hacer que devuelva 1 o 0 y que el parámetro y el tipo de retorno sean el mismo que me permita hacer que esta sea una expresión lambda por sí misma?

se agradecería alguna orientación

mismo 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)

Usos Truecomo el valor falso y Falsepara el valor verdadero. Marca la última aparición de cada elemento.

Selecciona el primer elemento solo si no aparece entre los elementos restantes, luego recurre al resto de la lista siempre que no esté vacío. El l.pop(0)extrae el primer elemento al mismo tiempo que la eliminación de la misma.

Retina , 23 bytes

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

La entrada es una lista separada por espacios. (En realidad, otros formatos como [1, 2, 3]también funcionarán siempre que haya un espacio delante de cada número, excepto el primero).

Pruébalo en línea! (Funciona en múltiples casos de prueba separados por salto de línea a la vez).

Simplemente convertimos cada elemento en 0si hay otra copia más adelante en la entrada y en lo 1contrario.

PowerShell v2 +, 40 bytes

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

Crea una matriz vacía $a. Luego tomamos la lista de entrada vía $args[0]y la canalizamos en un bucle |%{...}. Cada iteración seleccionamos 1o0 de un pseudoternario en función de si el elemento actual está $ao no. Esas selecciones se dejan en la tubería. Luego agregamos el elemento actual a la matriz $a. Los elementos de canalización se recopilan y la salida como una matriz es implícita.

Ejemplo:

(salida aquí con un separador de nueva línea, ya que ese es el valor predeterminado .ToString()para una 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))

El cero es verdadero y otros números son falsos.

Mathematica, 53 31 bytes

Gracias a millas por darme una idea que ahorró 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 la matriz en el lugar. Favorece la última ocurrencia.

El valor verdadero es 1mientras que el valor falsey es 0.

Verificar todos los casos de prueba .

Sin 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 realidad, 11 bytes

;╗ñ`i@╜í=`M

Pruébalo en línea!

Explicación:

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

Pruébalo aquí!

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

C ++, 242 bytes

Es cierto que es una solución excesiva, ya que funciona en cualquier contenedor estándar de cualquier tipo ordenado:

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

Sin golf:

(y más 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;
}

Banco de pruebas:

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

Violín

PHP, 66 62 39 bytes

• acepta todos los valores atómicos (booleano, entero, flotante, cadena),
  excepto los valores que se evalúan como falso (falso, 0, "") y cadenas numéricas ("1" es igual a 1)
• banderas primera aparición

La nueva versión (programa, 37 + 2 bytes)
^{supera a Java y (ahora de nuevo) C #. Incluso casi vence a Python ahora. Contento.}

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

• +6 para PHP> = 5.4, + 16-3 para una función
• imprime una lista no insertada de inserción 0(verdadera) y 1(falsa) después de invertir
  !print
• Uso: configurar register_globals=On, short_open_tags=Ony error_reporting=0en el php.inide php-cgi
  entonces llamadaphp-cgi -f <filename> a[]=<value1> a[]=<value2> ...;echo"" ;
• para PHP> = 5.4: reemplazar $acon $_GET[a](+6), establecer short_open_tags=Onyerror_reporting=0
• o reemplazar $acon array_slice($argv,1)(+19), eliminar <?(-2)
  y llamarphp -d error_reporting=0 -r '<code>' <value1> <value2> ...;echo""

versión anterior (función, 62 bytes)

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

• devuelve una matriz de falsepara verdadero y truepara falso; (salida como cadena vacía o 1)
  insertar !después $m[]=para invertir
• También hay otra forma para una función calificada con 55 bytes.

pruebas (en la versión anterior)

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]

Usos Falsecomo verdadero, 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]

Puede que tenga que import Data.Listusarlo tails, pero tryhaskell.org ejecuta el código tal como está.

Perl 5 + Perligata , 343 bytes

315 bytes, más 28 para -MLingua::Romana::Perligata

Usar como perl -MLingua::Romana::Perligata foo.pl; input (desde stdin) y output (hasta stdout) son cadenas de enteros decimales separadas por subrayado. Probado en Strawberry 5.20.2 con la versión 0.6 de Perligata; No sé si funciona con Perligata versión 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 esto es claro como una campana. En caso de que no sea así, ejecútelo con en -MLingua::Romana::Perligata=convertelugar de -MLingua::Romana::Perligata, yperl , en lugar de ejecutar el script, generará una traducción al 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 $_, '_')}

Para un análisis token por token, use -MLingua::Romana::Perligata=discribe .

Notas de golf:

• Sin documentar (pero no es sorprendente), no necesita un espacio después . .
• (Tampoco es sorprendente) scindeno necesita un segundo argumento y utilizahoc .
• Tuve que usar ao aum tum nullum addementum daporque no pude conseguirmorde a trabajar.
• Del mismo modo, solía per ium in qis... ro I daporque no podía obtenervanne a trabajar.
• En lugar de hacerlo huic vestibulo perlegementum da, lo intenté -pMLingua::Romana::Perligata, pero tampoco pude hacerlo funcionar.

Solo por patadas (aunque toda esta respuesta fue solo por patadas):

• Después de limpiarlo 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 da 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..