15

_{_{Não enfrentamos nenhum desafio fácil e agradável há algum tempo, então aqui vamos nós.}}

Dada uma lista de números inteiros maiores que $0$ e um índice como entrada, imprima a porcentagem do item no índice fornecido da soma total da lista.

A saída deve ser qualquer que seja a representação natural de números flutuantes / números inteiros no seu idioma (unário, decimal, numerais da igreja etc.). Se você optar por arredondar a saída de qualquer forma, ela deve ter no mínimo 2 casas decimais (quando razoável. $1.2$ não precisa ser arredondado, mas $1.20$ também é perfeitamente aceitável).

Os índices podem ser indexados 1 ou 0 e sempre estarão dentro dos limites da matriz.

Isso é código-golfe , então o código mais curto em bytes vence!

Exemplos

Usando 1 indexado e arredondado para 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

Ou, como três listas:

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

Postagem em sandbox (agora excluída)

— caird coinheringaahing 29/09/19

3

como exatamente os não-inteiros podem ser produzidos como números unários / de igreja?

— Maçaneta

1

@ Doorknob Talvez um número unário, o ponto e outro número unário?

— HighlyRadioactive

Como a saída pode ser arredondada para duas casas decimais, também pode ser permitido gerar vezes arredondadas 100?

— String não relacionada

1

caso de teste 4 deve ser 20/2410

— attinat 29/09/19

6

APL (Dyalog Unicode) , ^{SBCS de} 9 bytes

Função de infixo tácito anônimo. Leva o índice como argumento à esquerda e lista como argumento à direita.

100×⌷÷1⊥⊢

Experimente online!

100 cem

× vezes

⌷ o elemento indexado

÷ dividido por

1⊥ a soma (lit. a avaliação de base 1) de

⊢ o argumento certo

— Adão
fonte

6

C # (compilador interativo do Visual C #) , 22 bytes

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

Experimente online!

— Modalidade de ignorância
fonte

6

Python 3 , 26 bytes

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

Uma função sem nome que aceita um número inteiro (índice indexado 0) e uma lista que retorna a porcentagem.

Experimente online!

— Jonathan Allan
fonte

5

Geléia , 7 bytes

ị÷S}ȷ2×

Um link diádico que aceita um índice inteiro com base à esquerda e uma lista de números à direita que produz a porcentagem.

Experimente online!

Quão?

ị÷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

Agradável! Isso é byte por byte que eu tinha: P

— caird coinheringaahing

5

05AB1E , 6 bytes

è²O/т*

Um programa completo tendo o índice e depois a lista. Usa indexação 0.

Experimente online!

Quão?

è²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 bytes

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

Experimente online!

— niko
fonte

Eu não conheço R, mas isso não parece funcionar (não sei como testá-lo no TIO com matrizes arbitrárias), pois você deve recuperar o elemento lat no index n, não apenas dividir por n(veja a caixa de [7, 3, 19], 1teste )

— caird coinheringaahing

@cairdcoinheringaahing Meu mal, teve um erro de digitação (esqueci l[]on )

— niko #

Há uma coisa na página de link do TIO que pode formatar isso para você.

— SS Anne

4

C (gcc) , 64 bytes

Indexado a 0. A única parte divertida foi a conclusão de que 1e2é double, economizando um byte 100.!

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

Experimente online!

— ErikF
fonte

Experimente online! 59 usando C (clang)

— AZTECCO

4

Java (JDK) , 47 bytes

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

Experimente online!

— Olivier Grégoire
fonte

Por que você escreveu em 1e2vez de 100? É porque 100é inteiro e 1e2é considerado como um número de ponto flutuante?

— Ismael Miguel

1

@IsmaelMiguel Sim: 1e2carrega o tipo double, que a[i]e a soma não. Como o desafio exige retornar números de ponto flutuante, é onde eu posso usá-lo.

— Olivier Grégoire

Alterá-lo para um BiFunction <int [], Integer, Double> e você pode salvar 10 bytes com este: (a,i)->1e2*a[i]/IntStream.of(a).sum(). Edit:> :( minha pobre flecha lambda

— Avi

@ Avi A importação ainda é necessária, então eu teria que escrever:, (a,i)->1e2*a[i]/java.util.stream.IntStream.of(a).sum()que tem 54 bytes de comprimento. Minha resposta atual tem apenas 47 bytes. Além disso, a->i->é um byte menor que (a,i)->.

— Olivier Grégoire

1

@Avi Sim, eles são necessários , e é geralmente mais curto para escrever o nome completo da classe em vez da importação, de modo que o que eu faço aqui

— Olivier Grégoire

3

Haskell , 20 18 bytes

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

Um operador diádico ( ?) assumindo o índice (indexado 0) à esquerda e uma lista à direita que gera a porcentagem.

Experimente online!

— Jonathan Allan
fonte

3

J , 10 bytes

100*{%1#.]

Experimente online!

Indexado a 0

— Galen Ivanov
fonte

3

Wolfram Language (Mathematica) , 15 bytes

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

Experimente online!

Entrada como list, index

— attinat
fonte

##[[]]é incrível!

— Greg Martin

3

JavaScript (ES6), 30 bytes

Aceita entrada como (array)(index), onde o índice é baseado em 0.

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

Experimente online!

— Arnauld
fonte

3

MATL , 9 bytes

)1Gs/100*

Experimente online!

Explicação

          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

Experimente online!

— flawr
fonte

3

PHP (7.4), 35 bytes

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

Experimente online!

O índice de entrada é baseado em 0.

— Night2
fonte

3

K (oK) , 15 14 bytes

-1 byte graças a ngn!

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

Experimente online!

Indexado a 0

— Galen Ivanov
fonte

1

(x@y)->x[y]

— NGN

@ngn Obrigado!

— Galen Ivanov

2

Vermelho , 31 29 bytes

-2 bytes graças ao ErikF

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

Experimente online!

— Galen Ivanov
fonte

1

(-2 bytes) sugerem o uso em 1e2vez de 100.0: Experimente online! . É bem legal quantas línguas podem usar esse truque!

— ErikF 30/09/19

@ErikF Obrigado! Eu sei que isso na teoria, mas como parece, eu esqueci de usá-lo :)

— Galen Ivanov

2

PowerShell , 34 bytes

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

Experimente online!

Os parâmetros de vergonha são tão caros no Powershell.

— Veskah
fonte

2

Scratch 3.0 24 23 blocos / 239 228 bytes

Como alternativa na sintaxe 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

Guardado 11 bytes graças a @JoKing

Experimente no zero

Histórico de respostas

Como alternativa na sintaxe 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

Experimente no zero

A entrada está na forma de:

item1
item2
...
itemN
index

Eu realmente deveria parar de fazer isso comigo mesma. Mas é muito divertido!

— Jono 2906
fonte

Você pode mudar repeat length of ma length of m-1e salve-se o delete n?

— Jo rei

Não, porque se eu fizesse, não contabilizaria o último item.

— Jó 2906

Bem, se você remover o delete n of mque eu sugeri, então o faria

— Jo King

2

Pitão , 13 bytes

c*100@hQeQshQ

Experimente online!

Primeira vez usando Pyth, provavelmente há algumas otimizações bastante grandes aqui, mas não sei onde elas estão ...

Índice 0, recebe a entrada como list, index

— sincero
fonte

1

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

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

Experimente online!

Pegue a lista, o espaço separado na primeira linha e o índice (com base em 0) na segunda.

— Xcali
fonte

1

Japonês , 8 bytes

gV
*L/Vx

Tente

— Modalidade de ignorância
fonte

1

TI-Basic , 12 bytes (12 tokens)

Prompt X
Ans(X)_E2/sum(Ans

Indexado 1

Leva a lista Anse solicita ao usuário o índice

Exemplo de execução

Explicação:

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 bytes

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

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

Experimente online! O link inclui casos de teste. Toma entrada como index;list,.... Explicação:

\d+
$*

Converta para unário.

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

Índice na lista.

Soma a lista.

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

Multiplique o valor desejado por 10000 e divida pela soma com arredondamento adicionando primeiro metade da soma.

+`^..?$
0$&

Verifique se o resultado possui pelo menos três dígitos.

..$
.$&

Insira um ponto decimal na segunda última posição.

— Neil
fonte

1

Ruby , ²⁵ ²³ 21 bytes

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

Experimente online!

— Jonah
fonte

1

Perl 6 , 21 bytes

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

Experimente online!

A solução simples, pois não posso usar parâmetros ao curry com o $bparâmetro sendo indexado. Uma solução mais divertida que não precisa manipular dois parâmetros usando a rotatefunção:

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

Experimente online!

Mas infelizmente é mais dois bytes

— Brincadeira
fonte

1

Oitava , 21 bytes

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

Experimente online!

— tsh
fonte

1

MathGolf , 7 6 bytes

§\Σ/♀*

Indexação baseada em 0.

Experimente online.

Explicação:

§       # 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

Ícone , 53 bytes

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

Experimente online!

A única coisa interessante aqui é encontrar a soma. Icon foi um dos primeiros idiomas a ter geradores. !gera todos os valores da lista Lque são acumulados s. Normalmente precisamos escrever every s+:=!L, mas usei o retorno com &\z, que verifica se a zvariável inexistente é non-null, o que não é, e extrai o próximo valor da lista até a exaustão.

— Galen Ivanov
fonte

1

Fator , 46 bytes

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

Experimente online!

Indexado a 0

— Galen Ivanov
fonte

1

Lote, 111 bytes

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

Recebe entrada como índice e lista como argumentos da linha de comando. Nota: Funciona apenas para valores de índice de 1a 9devido a limitações do lote; poderia ser escrita uma versão indexada em 0, capaz de indexar os 10 primeiros elementos. Explicação:

@shift

Mude o índice para %0e a lista para %1... %9(ou menos). Observe, porém, que os lotes shiftnão afetam %*.

@set s=%*

Obtenha todos os parâmetros, com espaço separado.

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

Altere os espaços para se +avalie aritmeticamente, obtendo a soma, mas subtraindo o índice. Em seguida, indexe na lista, multiplique por 10000, adicione metade da soma e divida pela soma. Por fim, execute divmod por 10 duas vezes para gerar as casas decimais. (O %operador aritmético tem um significado especial no Lote e normalmente precisa ser duplicado, mas, em callseguida, requer uma duplicação adicional.)

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

Produza o resultado e as casas decimais.

— Neil
fonte

Encontre a porcentagem

Exemplos

APL (Dyalog Unicode) , SBCS de 9 bytes

C # (compilador interativo do Visual C #) , 22 bytes

Python 3 , 26 bytes

Geléia , 7 bytes

Quão?

05AB1E , 6 bytes

Quão?

R 28 bytes

C (gcc) , 64 bytes

Java (JDK) , 47 bytes

Haskell , 20 18 bytes

J , 10 bytes

Wolfram Language (Mathematica) , 15 bytes

JavaScript (ES6), 30 bytes

MATL , 9 bytes

Explicação

PHP (7.4), 35 bytes

K (oK) , 15 14 bytes

Vermelho , 31 29 bytes

PowerShell , 34 bytes

Scratch 3.0 24 23 blocos / 239 228 bytes

Histórico de respostas

Pitão , 13 bytes

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

Japonês , 8 bytes

TI-Basic , 12 bytes (12 tokens)

Retina 0.8.2 , 102 bytes

Ruby , 25 23 21 bytes

Perl 6 , 21 bytes

Oitava , 21 bytes

MathGolf , 7 6 bytes

Ícone , 53 bytes

Fator , 46 bytes

Lote, 111 bytes

APL (Dyalog Unicode) , ^{SBCS de} 9 bytes

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

Ruby , ²⁵ ²³ 21 bytes