Pari numeri nell'array secondario

16

Dato un array di numeri con length >=3elength % 3 == 0

[1, 2, 3, 4, ...]

Lo dividerai in sotto-matrici di lunghezza 3

[[1, 2, 3], [4, 5, ...], [...

E restituisce un array con

  • [0] => La quantità di casi nell'array secondario in cui tutti i numeri sono uguali
  • [1] => Nel caso in cui tutti i numeri nell'array secondario non siano uguali, la quantità di casi nell'array secondario in cui solo 2 numeri sono uguali

Esempi e casi di test:

  • Input: [2, 4, 2, 5, 5, 5, 4, 2, 1, 3, 3, 1]output[1, 2]

Questo è perché 

[[2, 4, 2], [5, 5, 5], [4, 2, 1], [3, 3, 1]]
  ^     ^    ^  ^  ^               ^  ^ 
   equal    all equal              equal

quindi 2 equale 1all equal

  • [3,5,6,5,5,7,6,6,8,7,7,7,3,4,2,4,4,3] => [1, 3]
  • [3,3,3,4,4,4,5,5,5,6,6,6,5,4,3] => [4, 0]
  • [3,4,5,6,7,8,9,8,7,6,5,4,3,2,1] => [0, 0]

Questo è code-golf , quindi vince la risposta più breve in byte.

PD: Mi scuso per il mio inglese.

code-golf  array-manipulation 
— Luis Felipe De Jesus Munoz
fonte
I numeri nei casi di test sono tutti positivi. È sempre così?
— Dennis,
@Dennis No. può essere numeri positivi e negativi.
— Luis felipe De jesus Munoz,

Risposte:

5

Ottava , 60 52 50 byte

@(x)sum(sum(~diff(sort(reshape(x,3,[]))))'==[2 1])

Provalo online!

Risparmiato 8 byte grazie a Luis!

Spiegazione:

Rimodella l'input in una matrice con 3 righe e la quantità appropriata di colonne. Quindi ordina ciascuna delle colonne e calcola la differenza tra gli elementi su righe diverse. Questo dà una matrice con due righe, dove numeri identici avranno uno zero e numeri diversi avranno un numero positivo. Questo è negato, in modo che tutti gli elementi uguali lo siano 1e tutti gli ineguali lo siano 0. Abbiamo poi riassumere ciascuna di queste colonne, dandoci una delle tre alternative: 0 = All elements are unequal, 1 = Two elements are equale 2 = All elements are equal. Quindi controlliamo quanti sono >1e quanti sono esattamente ==1.

— Stewie Griffin
fonte
4

JavaScript (ES6), 70 byte

f=([a,b,c,...d],t=p=0)=>1/a?f(d,t+!(a-b&&a-c?b-c||++p:b-c&&++p)):[t,p]

Provalo online!

Come?

Estraggiamo ricorsivamente ogni tripletta [a, b, c] dall'array di input e aggiorniamo due contatori t (tris) e p (coppia), usando la seguente formula:

t =
t + !(a - b && a - c ? b - c || ++p : b - c && ++p)

Vi sono 5 casi possibili che sono dettagliati di seguito, da "tutti uguali" a "tutti distinti".

a b c | a-b && a-c | b-c | b-c || ++p | b-c && ++p | t +=
------+------------+-----+------------+------------+------------
4 4 4 | false      | 0   | n/a        | 0          | !0    --> 1
4 4 5 | false      | ≠0  | n/a        | ++p        | !++p  --> 0
4 5 4 | false      | ≠0  | n/a        | ++p        | !++p  --> 0
5 4 4 | true       | 0   | ++p        | n/a        | !++p  --> 0
4 5 6 | true       | ≠0  | ≠0         | n/a        | !(≠0) --> 0
— Arnauld
fonte
Se l'output può avere più di solo [0]e [1]indici "Nota: restituisce un array di 3 elementi con [0]e [1]restituendo i valori appropriati e [2]restituendo un valore fittizio (il numero di 3 liste senza alcun elemento in comune). Questo è totalmente valido secondo le regole attuali ". codegolf.stackexchange.com/a/166082/31257 62 bytea=>a.map(_=>++r[--new Set(a.slice(i,i+=3)).size],r=[i=0,i])&&r
— guest271314
3

Pyth, 13 14 12 11 byte

/Lml{kcQ3S2

Provalo qui

Spiegazione

/Lml{kcQ3S2
      cQ3        Split the input into groups of 3.
  ml{k           Deduplicate and get the length of each.
/L               Count the number...
         S2      ... of 1s and 2s.
Non riesce per il 3 ° test (ha bisogno di alcuni pari e di tre triple uguali)
— Jonathan Allan
3

05AB1E , 10 byte

3ôεÙg}12S¢

Provalo online!

Spiegazione

3ô          # split input into groups of 3
  ε  }      # for each triple
   Ù        # remove duplicates
    g       # and get the length
      12S¢  # count the number of 1s and 2s in the result
— Emigna
fonte
3

ok , 17 16 byte

+/(1 2=#=:)'0N3#

Provalo online!

            0N3# /reshape into groups of 3 (see ngn's comment)
  (       )'     /for each group:
        =:       /    make a map from number -> indices
       #         /    count number of keys/values
   1 2=          /    check if the count is equal to 1 or 2 
+/               /sum together the columns

Per k , la versione 17 byte è: +/(1 2=#=:)'0N 3#.

— zgrep
fonte
0N 3-> 0N3(grazie a una stranezza di analisi in OK)
— ngn
3

R , 70 byte

function(v,x=lengths(by(v,seq(0,a=v)%/%3,table)))c(sum(x<2),sum(x==2))

Provalo online!

Versione precedente :

R , 82 byte

function(v,a=!1:2){for(i in lengths(by(v,seq(0,a=v)%/%3,table)))a[i]=a[i]+1;a[-3]}

Provalo online!

R , 93 byte

function(v,a=table(lengths(by(v,0:(length(v)-1)%/%3,unique)))[c('1','2')])`[<-`(a,is.na(a),0)

Provalo online!

— digEmAll
fonte
1
Eventualmente il porting della risposta Octave sarà più efficiente, ma a=!1:2è un po 'più breve.
— Giuseppe,
@Giuseppe: grazie e ho salvato altri 5 byte usando seq(0,a=v)invece di 0:(length(v)-1);) Sfortunatamente non conosco l'ottava quindi non riesco a leggere facilmente quella risposta ...
— digEmAll
@Giuseppe: cambiato approccio e salvato molti byte :)
— digEmAll
Ottimo approccio! Ho avuto qualcosa di più corto applying uniquema fallisce per il terzo caso di test. Il tuo byapproccio è più sicuro
— JayCe
@JayCe: fortunatamente R 3.2.0 ha introdotto la funzione di lunghezze che consente di risparmiare molti byte ... ma dovrebbero introdurre una definizione di funzioni lambda in cortocircuito in R, al fine di essere più competitivi nel codice golf: D
— digEmAll
3

Java (JDK 10) , 116 byte

l->{int r[]={0,0,0},i=0,a,b,c;for(;i<l.length;b=l[i++],c=l[i++],r[a==b?b==c?0:1:b==c|a==c?1:2]++)a=l[i++];return r;}

Provalo online!

Nota: restituisce un array di 3 elementi con [0]e [1]restituendo i valori appropriati e [2]restituendo un valore fittizio (il numero di 3 elenchi senza elementi in comune). Questo è totalmente valido secondo le regole attuali.

— Olivier Grégoire
fonte
2

PowerShell , 106 byte

param($a)for(;$a){$x,$y,$z,$a=$a;if($x-eq$y-and$y-eq$z){$i++}else{$j+=$x-eq$y-or$y-eq$z-or$z-eq$x}}+$i,+$j

Provalo online!

Esattamente quello che dice sulla latta. Passa sopra l'input $a. Ogni iterazione, si stacca $x,$y,$zcome i successivi tre elementi. I test ifsono tutti uguali e, in tal caso, incrementi $i. Else, aumenta $jse almeno una coppia è uguale. Una volta completato il ciclo, output $ie $jcome numeri interi.

Quindi ... molti ... dollari ...

— AdmBorkBork
fonte
2

Retina 0.8.2 , 68 byte

(.+)¶(.+)¶(.+)
;$1;$2;$3;$1;
%M`(;\d+)(?=\1;)
s`((1)|(3)|.)+
$#3 $#2

Provalo online! Il collegamento include casi di test con intestazione per convertire nel formato desiderato di un valore per riga. Spiegazione:

(.+)¶(.+)¶(.+)
;$1;$2;$3;$1;

Raccogliere tre valori su ogni riga con separatori e duplicare il primo alla fine.

%M`(;\d+)(?=\1;)

Conta il numero di coppie di duplicati.

s`((1)|(3)|.)+
$#3 $#2

Contare il numero di 3s e 1s.

— Neil
fonte
2

Lisp comune, 113 byte

(lambda(l &aux(a 0)(b 0))(loop for(x y z)on l by #'cdddr do(if(= x y z)(incf a)(if(/= x y z)()(incf b))))`(,a,b))

Provalo online!

Utilizzato il fatto che in Common Lisp (= x y z)dà true se tutti e tre gli elementi sono uguali e (/= x y z)true se nessuna coppia di numeri è uguale.

— Renzo
fonte
2

Japt, 14 13 byte

2õ@ò3 x_â ʶX

Provalo

Spiegazione

2õ                :Range [1,2]
  @               :Pass each X through a function
   ò3             :  Split input to arrays of length 3
       _          :  Pass each through a function
        â         :    Remove duplicates
          Ê       :    Get length
           ¶X     :    Test for equality with X
      x           :  Reduce by addition
— ispido
fonte
2

Python 2 , 77 72 65 byte

lambda a:map([len(set(t))for t in zip(*[iter(a)]*3)].count,(1,2))

Provalo online!

7 byte salvati tramite un trucco intelligente da xnor

— Chas Brown
fonte
È possibile generare un elenco di terzine più corto di zip(*[iter(a)]*3).
— xnor
@xnor: Very nice; Mi chiedevo se ci fosse un modo più breve ...
— Chas Brown,
2

Retina , 23 byte

S2,3,` 
%Cq`\S+
*\C`1
2

Provalo online!

Spiegazione

S2,3,`

Dividi l'input in corrispondenza di ogni terzo spazio iniziando dal 2 ° (basato su 0), ovvero suddividendo l'input in gruppi di tre.

%Cq`\S+

Su ogni riga ( %) conta il numero ( C) di unico (q valori ) ( \S+).

*\C`1

Contare il numero di se 1stamparli con un avanzamento riga finale (\ ), ma farlo a secco (* ) in modo da non perdere il risultato precedente.

2

Contare il numero di 2s (e stamparli automaticamente).

— Martin Ender
fonte
2

J , 16 15 byte

-1 byte grazie a Cole!

1#.1 2=/_3#@=\]

Provalo online!

Praticamente lo stesso approccio della maggior parte delle soluzioni.

Spiegazione:

        _3    \]  - split the input into sublists of lenght 3
          #@~.    - for each triplet remove duplicates and take the length 
   1 2=/          - compare with 1 and 2
1#.               - add up
— Galen Ivanov
fonte
#@~.->#@=
— Cole
1

Stax , 14 byte

ü┬─*HTÜ╫\Ä╢qm♥

Esegui ed esegui il debug

— Wastl
fonte
[3,5,6,5,5,7,6,6,8,7,7,7,3,4,2,4,4,3]uscite [2,3]invece[1,3]
— Luis felipe De jesus Munoz,
[3,3,3,4,4,4,5,5,5,6,6,6,5,4,3]uscite [1,0]invece[4,0]
— Luis felipe De jesus Munoz,
[3,4,5,6,7,8,9,8,7,6,5,4,3,2,1]uscite [5,0]invece[0,0]
— Luis felipe De jesus Munoz
@LuisfelipeDejesusMunoz fixed
— wastl
Al momento non mostra alcun output per [1,1,1]. Se lo usi al 2(posto di 1Tesso, riduci / riduci sempre esattamente la dimensione 2.
— ricorsivo dal
1

Elisir , 92 byte

fn a->import Enum;c=map chunk(a,3),&(length uniq&1);{count(c,&(&1==1)),count(c,&(&1==2))}end

Innanzitutto, taglia l'elenco in lunghezza lunghezza 3 chunk(a,3)

In secondo luogo, converte trova la lunghezza di ciascun elemento, unificata; map chunk(a,3),&(length uniq&1).

Infine, restituisce un array costituito dal numero di volte in cui l'elenco risultante è uguale a uno count(c,&(&1==1))e il numero di volte in cui l'elenco risultante è uguale a duecount(c,&(&1==2)) .

Provalo online!

— Okx
fonte
0

Tcl , 111 byte

proc S {L a\ 0 e\ 0} {lmap {x y z} $L {expr {$x-$y|$y-$z?$x==$y|$y==$z|$x==$z?[incr e]:0:[incr a]}}
list $a $e}

Provalo online!

Tcl , 112 byte

proc S {L a\ 0 e\ 0} {lmap {x y z} $L {expr {$x-$y||$y-$z?$x==$y|$y==$z|$x==$z?[incr e]:0:[incr a]}}
list $a $e}

Provalo online!

Tcl , 114 byte

proc S {L a\ 0 e\ 0} {lmap {x y z} $L {expr {$x==$y&&$y==$z?[incr a]:$x==$y|$y==$z|$x==$z?[incr e]:0}}
list $a $e}

Provalo online!

— sergiol
fonte
0

Tcl , 98 byte

proc A l {set 1 0;set 2 0
foreach a\ b\ c $l {incr [llength [lsort -u "$a $b $c"]]}
return $1\ $2}

Provalo online!

usando l' -uniqueopzione di lsortcomando. Ho chiamato 1e le 2mie variabili per comodità, difficile sembra abbastanza insolito codificare set 1 0:)

— david
fonte
0

C # (compilatore interattivo Visual C #) , 108 byte

x=>new[]{1,2}.Select(n=>x.Select((v,i)=>(v,g:i/3)).GroupBy(y=>y.g,y=>y.v).Count(y=>y.Distinct().Count()==n))

Provalo online!

Meno golf ...

// x is the input list of ints
x=>x
  // 1 distinct number means 3/3 are the same
  // 2 distinct number means 2/3 are the same
  new[]{1,2}
  // iterate over the outer array to get an index
  .Select(n=>x
    // iterate over the whole list with an index
    // and break into groups of size 3
    .Select((v,i)=>v,g:i/3))
    .GroupBy(y=>y.g,y=>y.v)
     // count the distinct values in each group
     // and get the result based on outer array value
    .Count(y=>y.Distinct().Count()==n))
— dana
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.