Dato un elenco di numeri interi, creare una maschera booleana in modo che gli indici reali possano essere utilizzati per filtrare i valori distinti dall'elenco. L'indice selezionato come vero non ha importanza purché ne sia selezionato solo uno per ciascun set di indici corrispondenti a valori identici.

L'input sarà un elenco non vuoto di numeri interi non negativi in ​​un formato adatto alla tua lingua e l'output sarà un elenco di valori booleani seguendo le specifiche sopra. È consentito utilizzare le proprie definizioni di valori di verità e falsità nell'elenco di output.

Nei miei esempi che seguono, definisco la 1verità e la 0falsità.

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

Casi test

Quando c'è un or, significa che ci sono più output validi. Se c'è un puntino di sospensione ...dopo il or, significa che non sono stati elencati tutti i possibili output.

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

Regole

• Questo è code-golf, quindi vince la soluzione più breve.
• I builtin sono ammessi!
• È consentito utilizzare le proprie definizioni di valori di verità e falsità nell'elenco di output. Se si sceglie di farlo, si prega di indicare le proprie definizioni.
• L'input sarà un elenco non vuoto di numeri interi non negativi.
• Sei libero di scegliere tra l'erogazione di uno solo dei setacci o multipli o anche tutti. Finché ogni setaccio è valido, sarà accettato.

MATL, 7 6 4 byte

1 byte salvato grazie a @Luis
2 byte salvato grazie a @Dennis

&=Rs

Definiamo 1essere la verità e tutti gli altri valori come falsità

Provalo online

Tutti i casi di test

Spiegazione

    % 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 byte

ĠṪ€Ṭ

Favorisce ultimi avvenimenti. Provalo online! o verifica tutti i casi di test .

Come funziona

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

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

Apre il primo elemento dall'elenco, controlla se esiste altrove nell'elenco e inserisce Trueo Falsein un nuovo elenco.

Per questa funzione, Falseindica un valore distinto ed Trueè altrimenti ( True=0e False=1)

Grazie a Dennis per una tonnellata di byte

Originale, 47 byte:

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

Provalo

Pyth, 6 byte

.eqxQb

Uscite un elenco di Caccio ( Truee False). Verifica ogni elemento nell'input, se il suo indice è uguale all'indice della prima occorrenza del valore. In altre parole, questo sta verificando se ogni elemento è la prima occorrenza.

Nello pseudocodice pythonic:

.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

Provalo qui.

J , 2 byte

~:

Da qui è nata l'idea di questa sfida. Il builtin ~:viene chiamato Nub-Sievein J e crea un elenco booleano che esegue l'operazione descritta nella sfida. Qui, 1rappresenta truee 0rappresenta false.

05AB1E , 8 byte

Codice:

v¹ykN>Qˆ

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online! .

APL, 6 byte

⍳∘⍴∊⍳⍨

Provalo

Spiegazione:

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

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

Potrei anche farlo restituire 1 o 0 e quindi rendere il parametro e restituire lo stesso tipo che mi consenta di rendere questa espressione lambda da sola?

alcuni consigli sarebbero apprezzati

codice dello stesso tipo

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

Python, 35 byte

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

Utilizza Truecome valore di falsità e Falseper il valore di verità. Contrassegna l'ultima apparizione di ciascun elemento.

Seleziona il primo elemento solo se non viene visualizzato tra gli elementi rimanenti, quindi ricorre al resto dell'elenco purché non sia vuoto. Il l.pop(0)estrae il primo elemento, mentre anche la rimozione.

Retina , 23 byte

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

L'input è un elenco separato da spazi. (In realtà, altri formati come [1, 2, 3]funzioneranno anche se c'è uno spazio davanti a ciascun numero tranne il primo.)

Provalo online! (Funziona su più casi di test separati da avanzamento riga contemporaneamente).

Trasformiamo semplicemente ogni elemento in 0se ne esiste un'altra copia più avanti nell'input e in 1altrimenti.

PowerShell v2 +, 40 byte

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

Crea un array vuoto $a. Quindi prendiamo l'elenco di input tramite $args[0]e lo inseriamo in un loop |%{...}. Ogni iterazione che selezioniamo 1o 0da uno pseudo-ternario in base al fatto che l'elemento corrente si trovi $ao meno. Tali selezioni vengono lasciate sulla pipeline. Aggiungiamo quindi l'elemento corrente nella matrice $a. Gli elementi della pipeline vengono raccolti e l'output come array è implicito.

Esempio:

(output qui con un separatore newline, poiché quello è il valore predefinito .ToString()per un array)

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 byte

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

Zero è truthy e altri numeri sono falsy.

Mathematica, 53 31 byte

Grazie a miglia per avermi dato l'idea che ha salvato 22 byte.

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

Perl 5

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

Java, 96 byte

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 l'array sul posto. Favorisce l'ultima occorrenza.

Il valore di verità è 1mentre il valore di falsità è 0.

Verifica tutti i test .

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

In realtà, 11 byte

;╗ñ`i@╜í=`M

Provalo online!

Spiegazione:

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

F@oq

Provalo qui!

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

C ++, 242 byte

Certamente una soluzione eccessiva, poiché funziona su qualsiasi contenitore standard di qualsiasi tipo ordinato:

#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 in seguito generalizzato)

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 di test:

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 byte

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 byte

• accetta tutti i valori atomici (boolean, integer, float, string)
  tranne i valori che valutano false (false, 0, "") e stringhe numeriche ("1" equivale a 1)
• bandiere prima occorrenza

nuova versione (di programma, 37 + 2 byte)
^{batte Java e (ora di nuovo) C #. Anche quasi batte Python ora. Contento.}

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

• +6 per PHP> = 5.4, + 16-3 per una funzione
• stampe lista undelimited del 0(vero) e 1(false)
  di inserimento !dopoprint invertire
• utilizzo: set register_globals=On, short_open_tags=One error_reporting=0in php.iniper php-cgi
  poi chiamataphp-cgi -f <filename> a[]=<value1> a[]=<value2> ...;echo"" ;
• per PHP> = 5.4: sostituire $acon $_GET[a](6), set short_open_tags=Oneerror_reporting=0
• o sostituire $acon array_slice($argv,1)(19), rimuovere <?(-2)
  e callphp -d error_reporting=0 -r '<code>' <value1> <value2> ...;echo""

versione (funzione, 62 byte)

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

• restituisce serie di falseper una vera e trueper falso; (output come stringa vuota o 1)
  dell'inserto !dopo $m[]=invertire
• C'è un altro modo per una funzione qualificato con 55 byte, anche.

test (sulla vecchia versione)

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 byte

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

Utilizza Falsecome vero, Truecome falso valore:

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

Potrebbe essere necessario import Data.Listutilizzare tails, ma tryhaskell.org esegue il codice così com'è.

Perl 5 + Perligata , 343 byte

315 byte, più 28 per -MLingua::Romana::Perligata

Usa come perl -MLingua::Romana::Perligata foo.pl; ingresso (da stdin) e di uscita (allo stdout) sono stringhe di numeri interi decimali sottolineatura-separati. Testato su Strawberry 5.20.2 con versione 0.6 di Perligata; Non so se funziona con Perligata versione 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

Ovviamente questo è chiaro come una campana. Nel caso in cui non lo sia, eseguirlo con -MLingua::Romana::Perligata=converteinvece di -MLingua::Romana::Perligataeperl , invece di eseguire lo script, genererà una traduzione in Perl normale:

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

Per un token-by-token analisi, l'uso -MLingua::Romana::Perligata=discribe .

Golf note:

• Non documentato (ma non sorprendente), non è necessario uno spazio dopo . .
• (Anche non sorprendente,) scindenon ha bisogno di un secondo argomento e usahoc .
• Ho dovuto usare ao aum tum nullum addementum daperché non riuscivo a otteneremorde a lavorare.
• Allo stesso modo, ho usato per ium in qis... ro I daperché non riuscivo a ottenerevanne a lavorare.
• Invece huic vestibulo perlegementum da, ci ho provato -pMLingua::Romana::Perligata, ma non sono riuscito a farlo funzionare.

Solo per i calci (anche se l'intera risposta era solo per i calci):

• Dopo aver pulito fino a 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 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..