15

_{_{Non abbiamo avuto nessuna bella, facile sfida da un po ', quindi eccoci qui.}}

Dato un elenco di numeri interi ciascuno maggiore di $0$ e un indice come input, genera la percentuale dell'elemento in corrispondenza dell'indice dato della somma totale dell'elenco.

L'output dovrebbe essere qualunque sia la rappresentazione naturale di float / interi nella tua lingua (unaria, decimale, numeri di Church ecc.). Se si sceglie di arrotondare in qualche modo l'output, deve avere almeno 2 decimali (quando ragionevole. $1.2$ non deve essere arrotondato, ma anche $1.20$ è perfettamente accettabile).

Gli indici possono essere 1-indicizzati o 0-indicizzati e saranno sempre entro i limiti dell'array.

Questo è code-golf , quindi vince il codice più corto in byte!

Esempi

Utilizzando 1-indicizzato e arrotondato a 2 dp

list, index                    =>         output
[1, 2, 3, 4, 5], 5             => 5 / 15    => 33.33
[7, 3, 19], 1                  => 7 / 29    => 24.14
[1, 1, 1, 1, 1, 1, 1, 1, 1], 6 => 1 / 9     => 11.11
[20, 176, 194, 2017, 3], 1     => 20 / 2410 => 0.83
[712], 1                       => 712 / 712 => 100

Oppure, come tre elenchi:

[[1, 2, 3, 4, 5], [7, 3, 19], [1, 1, 1, 1, 1, 1, 1, 1, 1], [20, 176, 194, 2017, 3], [712]]
[5, 1, 6, 1, 1]
[33.33, 24.14, 11.11, 0.83, 100]

— caird coinheringaahing
fonte

Post sandbox (ora eliminato)

— caird coinheringaahing

3

come possono esattamente essere emessi numeri interi come numeri unari / ecclesiali?

— Maniglia della porta

1

@Doorknob Forse un numero unario, il punto e un altro numero unario?

— Altamente radioattivo,

Poiché l'output può essere arrotondato al secondo decimale, potrebbe anche essere consentito l'output arrotondato per 100?

— Stringa non correlata

1

il test case 4 dovrebbe essere 20/2410

— attinat

6

APL (Dyalog Unicode) , ^{SBCS da} 9 byte

Funzione anonimo di tacita infissione. Accetta l'indice come argomento a sinistra e l'elenco come argomento a destra.

100×⌷÷1⊥⊢

Provalo online!

100 cento

× volte

⌷ l'elemento indicizzato

÷ diviso per

1⊥ la somma (lett. la valutazione base-1) di

⊢ l'argomento giusto

— Adamo
fonte

6

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

x=>y=>x[y]*100/x.Sum()

Provalo online!

— Incarnazione dell'ignoranza
fonte

6

Python 3 , 26 byte

lambda i,a:a[i]/sum(a)*100

Una funzione senza nome che accetta un numero intero (indice con indice 0) e un elenco che restituisce la percentuale.

Provalo online!

— Jonathan Allan
fonte

5

Gelatina , 7 byte

ị÷S}ȷ2×

Un collegamento diadico che accetta un indice intero a base singola a sinistra e un elenco di numeri a destra che fornisce la percentuale.

Provalo online!

Come?

ị÷S}ȷ2× - Link: integer, i; list, L
ị       - (i) index into (L)
   }    - use right argument:
  S     -   sum (L)
 ÷      - divide
    ȷ2  - literal 10^2 = 100
      × - multiply

— Jonathan Allan
fonte

1

Bello! Quello è byte per byte quello che avevo: P

— caird coinheringaahing

5

05AB1E , 6 byte

è²O/т*

Un programma completo che prende l'indice e poi l'elenco. Utilizza l'indicizzazione 0.

Provalo online!

Come?

è²O/т*
è      - index (input 1) into (input 2)
 ²     - push 2nd input
  O    - sum
   /   - divide
    т  - push 100
     * - multiply
       - print top of stack

— Jonathan Allan
fonte

4

R 28 byte

function(n,l)100*l[n]/sum(l)

Provalo online!

— niko
fonte

Non conosco R, ma questo non sembra funzionare (non sono sicuro di come testarlo su TIO con array arbitrari), in quanto si suppone di recuperare l'elemento di lin index n, non solo dividerlo per n(vedere la [7, 3, 19], 1testcase )

— caird coinheringaahing il

@cairdcoinheringaahing Il mio male, aveva un refuso (dimenticato il l[]giro del n)

— niko

C'è qualcosa nella pagina dei link di TIO che può formattarlo per te.

— SS Anne

4

C (gcc) , 64 byte

0-indicizzati. L'unica cosa divertente è stata la realizzazione che 1e2è un double, salvando un byte sopra 100.!

float f(v,n,t)int*v;{n=v[n];for(t=0;*v;t+=*v++);return n*1e2/t;}

Provalo online!

— ErikF
fonte

Provalo online! 59 usando C (clang)

— AZTECCO il

4

Java (JDK) , 47 byte

a->i->1e2*a[i]/java.util.Arrays.stream(a).sum()

Provalo online!

— Olivier Grégoire
fonte

Perché hai scritto 1e2invece di 100? È perché 100è un numero intero ed 1e2è considerato un numero in virgola mobile?

— Ismael Miguel,

1

@IsmaelMiguel Sì: 1e2porta il doppio tipo, che a[i]e la somma no. Poiché la sfida richiede di restituire numeri in virgola mobile, è qui che posso usarla.

— Olivier Grégoire,

Cambiarlo in un BiFunction <int [], Integer, Double> ed è possibile salvare 10 byte con questo: (a,i)->1e2*a[i]/IntStream.of(a).sum(). Modifica:> :( la mia povera freccia lambda

— Avi

@Avi L'importazione è ancora necessaria, quindi dovrei scrivere:, (a,i)->1e2*a[i]/java.util.stream.IntStream.of(a).sum()che è lungo 54 byte. La mia risposta attuale è lunga solo 47 byte. Inoltre, a->i->è un byte più breve di (a,i)->.

— Olivier Grégoire,

1

@Avi Sì, sono richiesti , e di solito è più breve scrivere il nome completo della classe anziché l'importazione, quindi è quello che faccio qui

— Olivier Grégoire,

3

Haskell , 20 anni 18 byte

i?a=a!!i/sum a*100

Un operatore diadico (? ) che prende l'indice (0-indicizzato) a sinistra e un elenco a destra che fornisce la percentuale.

Provalo online!

— Jonathan Allan
fonte

3

J , 10 byte

100*{%1#.]

Provalo online!

0-indicizzato

— Galen Ivanov
fonte

3

Wolfram Language (Mathematica) , 15 byte

100##[[]]/Tr@#&

Provalo online!

Inserisci come list, index

— attinat
fonte

##[[]]è stupendo!

— Greg Martin,

3

JavaScript (ES6), 30 byte

Prende come ingresso (array)(index), dove indice si basa-0.

a=>n=>a[n]*100/eval(a.join`+`)

Provalo online!

— Arnauld
fonte

3

MATL , 9 byte

)1Gs/100*

Provalo online!

Spiegazione

          implicitly take two inputs
)         get the entry within the first input at the index specified by the second
 1G       push the first input onto the stack again
   s      compute the sum 
    /     divide first entry of the stack by this number (the sum) 
     100* multiply by 100

Provalo online!

— flawr
fonte

3

PHP (7.4), 35 byte

fn($l,$i)=>100/array_sum($l)*$l[$i]

Provalo online!

L'indice di input è basato su 0.

— night2
fonte

3

K (oK) , 15 14 byte

-1 byte grazie a ngn!

{100*x[y]%+/x}

Provalo online!

0-indicizzato

— Galen Ivanov
fonte

1

(x@y)->x[y]

— ngn,

@ngn Grazie!

— Galen Ivanov,

2

Rosso , 31 29 byte

-2 byte grazie a ErikF

func[b i][1e2 * b/:i / sum b]

Provalo online!

— Galen Ivanov
fonte

1

(-2 byte) suggerisci di utilizzare 1e2invece di 100.0: Provalo online! . È abbastanza ordinato quante lingue possono usare questo trucco!

— ErikF,

@ErikF Grazie! Lo so in teoria, ma a quanto pare, ho dimenticato di usarlo :)

— Galen Ivanov

2

PowerShell , 34 byte

param($l,$n)$l|%{$i+=$_};$l[$n]/$i

Provalo online!

I parametri di vergogna sono così pericolosi in Powershell.

— Veskah
fonte

2

Scratch 3.0 24 23 blocchi / 239 228 byte

In alternativa nella sintassi SB

when gf clicked
set[s v]to(0
ask()and wait
repeat until<(answer)=(
add(answer)to[m v
ask()and wait
end
set[n v]to(item(length of(n))of(m
repeat(length of((m)-(1
change[s v]by(item(1)of[m v
delete (1)of[m v
end
say(((n)/(s))*(100

Salvato 11 byte grazie a @JoKing

Provalo da zero

Cronologia delle risposte

In alternativa nella sintassi SB

when gf clicked
set[s v]to(0
ask()and wait
repeat until<(answer)=(
add(answer)to[m v
ask()and wait
end
set[n v]to(item(length of(n))of(m
delete(n)of[m v
repeat(length of(m
change[s v]by(item(1)of[m v
delete (1)of[m v
end
say(((n)/(s))*(100

Provalo da zero

L'input ha la forma di:

item1
item2
...
itemN
index

Dovrei davvero smettere di farmi questo. Ma è molto divertente!

— Lyxal
fonte

Si può cambiare repeat length of mper length of m-1e risparmiare la delete n?

— Jo King,

No, perché se lo facessi, non calcolerebbe l'ultimo elemento.

— Lyxal,

Bene, se rimuovessi delete n of mcome ti avevo suggerito, sarebbe

— Jo King il

2

Pyth , 13 byte

c*100@hQeQshQ

Provalo online!

La prima volta che uso Pyth quindi probabilmente ci sono alcune grandi ottimizzazioni qui, ma non so dove siano ...

0-index, accetta input come list, index

— Franco
fonte

1

Perl 5 `-ap -MList::Util=Sum` , 19 byte

$_=100*$F[<>]/sum@F

Provalo online!

Prendi l'elenco, lo spazio separato sulla prima riga, l'indice (basato su 0) sulla seconda.

— Xcali
fonte

1

Japt , 8 byte

gV
*L/Vx

Provalo

— Incarnazione dell'ignoranza
fonte

1

TI-Basic , 12 byte (12 token)

Prompt X
Ans(X)_E2/sum(Ans

1-indicizzato

Inserisce l'elenco Anse richiede all'utente l'indice

Esempio di esecuzione

Spiegazione:

Prompt X         # Prompt the user for the index
Ans(X)_E2/sum(Ans
Ans(X)           # The value at the Xth index in the list
      _E2         # times 100
        /sum(Ans # Divided by the sum of the list
                 # The result of the last expression in a program is implicitly returned

— pizzapants184
fonte

1

Retina 0.8.2 , 102 byte

\d+
$*
^(1)+((?<-1>.(1+))+)
$3$2
,

\G1
10000$*
;(1+)\1
$1;$1$1
r`.*(\2)*;(1+)
$#1
+`^..?$
0$&
..$
.$&

Provalo online! Il link include casi di test. Accetta input come index;list,.... Spiegazione:

\d+
$*

Converti in unario.

^(1)+((?<-1>.(1+))+)
$3$2

Indice nell'elenco.

Somma l'elenco.

\G1
10000$*
;(1+)\1
$1;$1$1
r`.*(\2)*;(1+)
$#1

Moltiplicare il valore desiderato per 10000 e dividere per la somma con arrotondamento aggiungendo prima metà della somma.

+`^..?$
0$&

Assicurarsi che il risultato abbia almeno tre cifre.

..$
.$&

Inserire un punto decimale nella penultima posizione.

— Neil
fonte

1

Rubino , ²⁵ ²³ 21 byte

->a,i{1e2*a[i]/a.sum}

Provalo online!

— Giona
fonte

1

Perl 6 , 21 byte

{100*@^a[$^b]/@a.sum}

Provalo online!

La soluzione semplice, dal momento che non posso usare i parametri curry con il $bparametro da indicizzare. Una soluzione più divertente che non deve gestire due parametri utilizzando rotateinvece la funzione:

{100*.[0]/.sum}o&rotate

Provalo online!

Ma sfortunatamente è più lungo di due byte

— Jo King
fonte

1

Ottava , 21 byte

@(a,n)a(n)/sum(a)*100

Provalo online!

— tsh
fonte

1

MathGolf , 7 6 byte

§\Σ/♀*

Indicizzazione basata su 0.

Provalo online.

Spiegazione:

§       # Index the (implicit) second input-integer into the first (implicit) input-list,
        # which apparently doesn't pop the list
 \      # Swap so this list is at the top of the stack now
  Σ     # Take the sum of that list
   /    # Divide the earlier number we indexed by this sum
    ♀*  # Multiply it by 100
        # (after which the entire stack joined together is output implicitly as result)

— Kevin Cruijssen
fonte

1

Icona , 53 byte

procedure f(L,i)
s:=0;s+:=!L&\z
return 1e2*L[i]/s
end

Provalo online!

L'unica cosa interessante qui è trovare la somma. Icona è stata una delle prime lingue ad avere generatori. !genera tutti i valori dell'elenco Lche vengono accumulati s. Normalmente dobbiamo scrivere every s+:=!L, ma ho usato il backtracking con &\z, che controlla se la zvariabile inesistente è non-null, che non lo è, ed estrae il valore successivo dall'elenco fino all'esaurimento.

— Galen Ivanov
fonte

1

Fattore , 46 byte

: f ( i l -- n ) dup [ nth ] dip sum / 1e2 * ;

Provalo online!

0-indicizzato

— Galen Ivanov
fonte

1

Lotto, 111 byte

@shift
@set s=%*
@call set/as=%s: =+%-%0,s=(%%%0*10000+s/2)/s,h=s%%%%10,t=s/10%%%%10,s/=100
@echo %s%.%t%%h%

Accetta input come indice ed elenco come argomenti della riga di comando. Nota: funziona solo per i valori di indice da 1a a 9causa delle limitazioni di Batch; potrebbe essere scritta una versione con indice 0 che sarebbe in grado di indicizzare i primi 10 elementi. Spiegazione:

@shift

Spostare l'indice su %0e l'elenco su %1... %9(o meno). Si noti tuttavia che Batch shiftnon influisce %*.

@set s=%*

Ottieni tutti i parametri, spazio separato.

@call set/as=%s: =+%-%0,s=(%%%0*10000+s/2)/s,h=s%%%%10,t=s/10%%%%10,s/=100

Cambia gli spazi in +s e valuta aritmeticamente, prendendo così la somma, ma sottraendo l'indice. Quindi indicizza nell'elenco, moltiplica per 10000, aggiungi metà della somma e dividi per la somma. Infine esegui divmod per 10 due volte per generare i decimali. (L' %operatore aritmetico ha un significato speciale in Batch e normalmente deve essere raddoppiato, ma callrichiede quindi un ulteriore raddoppio.)

@echo %s%.%t%%h%

Emette il risultato e le posizioni decimali.

— Neil
fonte

Trova la percentuale

Esempi

APL (Dyalog Unicode) , SBCS da 9 byte

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

Python 3 , 26 byte

Gelatina , 7 byte

Come?

05AB1E , 6 byte

Come?

R 28 byte

C (gcc) , 64 byte

Java (JDK) , 47 byte

Haskell , 20 anni 18 byte

J , 10 byte

Wolfram Language (Mathematica) , 15 byte

JavaScript (ES6), 30 byte

MATL , 9 byte

Spiegazione

PHP (7.4), 35 byte

K (oK) , 15 14 byte

Rosso , 31 29 byte

PowerShell , 34 byte

Scratch 3.0 24 23 blocchi / 239 228 byte

Cronologia delle risposte

Pyth , 13 byte

Perl 5 -ap -MList::Util=Sum , 19 byte

Japt , 8 byte

TI-Basic , 12 byte (12 token)

Retina 0.8.2 , 102 byte

Rubino , 25 23 21 byte

Perl 6 , 21 byte

Ottava , 21 byte

MathGolf , 7 6 byte

Icona , 53 byte

Fattore , 46 byte

Lotto, 111 byte

APL (Dyalog Unicode) , ^{SBCS da} 9 byte

Perl 5 `-ap -MList::Util=Sum` , 19 byte

Rubino , ²⁵ ²³ 21 byte