Uma lista de módulos numéricos, seus índices na lista


25

Um exemplo simples: pegue uma lista de números inteiros positivos como entrada e faça a saída dos números no módulo com base em 1 na lista.

Se os números inteiros de entrada estiverem {a, b, c, d, e, f, g}, a saída deve estar {a%1, b%2, c%3, d%4, e%5, f%6, g%7}onde %está o operador do módulo.


Casos de teste:

10  9  8  7  6  5  4  3  2  1
 0  1  2  3  1  5  4  3  2  1

8 18  6 11 14  3 15 10  6 19 12  3  7  5  5 19 12 12 14  5
0  0  0  3  4  3  1  2  6  9  1  3  7  5  5  3 12 12 14  5

1
0

1  1
0  1

Respostas:



9

Linguagem de script da operação Flashpoint , 73 bytes

f={l=_this;r=[];i=0;while{i<count l}do{r=r+[(l select i)%(i+1)];i=i+1};r}

Ligue para:

numList = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
hint format["%1\n%2", numList, numList call f];

Saída:


1
O que ... isso é uma coisa?
JAD

2
@JarkoDubbeldam Sim. O jogo permite que os jogadores criem seus próprios cenários, e há uma linguagem de script no jogo projetada para complementar o design da missão. No entanto, como o idioma é completo em Turing, você pode fazer praticamente o que quiser com ele.
Steadybox


7

Geléia , 2 bytes

%J

Experimente online!

Explicação:

%J
 J List 1 .. len(input). This is results in a list of the indexes.
%  Modulo.

Basicamente, o código modula a lista original pela lista de índices.


2
Assim que vi essa pergunta, pensei "que está %Jem Jelly, gostaria de saber se alguém respondeu com essa resposta?". Eu acho que alguém teve a mesma idéia:

1
@ ais523 Você acha que era o único? Pense de novo!
Erik the Outgolfer

6

R, 24 bytes de 18

pryr::f(x%%seq(x))

Avalia para a função:

function (x) 
x%%seq(x)

Que é usado seq_along()para criar um vetor do mesmo comprimento que x, iniciando em 1, e depois %%pegar o módulo.

O comportamento padrão de seqquando apresentado com um vetor seq(along.with = x)é a mesma saída que seq_along(x), mas 6 bytes mais curto.


seq(x)é algo útil de se ter por perto, já que estou sempre usando 1:length(x).
Giuseppe

@ Giuseppe Sim, fiquei um pouco surpreso também.
JAD

6

R, 27 bytes

x=scan();cat(x%%1:sum(1|x))

economizou 5 bytes graças a @Jarko

salvou mais 4 graças a @ Giuseppe

salvou mais 2 graças a @Taylor Scott

Guardado 2 mais graças a @returnbull


35 é - removido últimos paren desnecessários
Zahiro Mor

1
você não precisa do ' '(espaço) no final de cat; esse é o separador padrão
Giuseppe

2
você pode soltar 2 bytes para obter 33, reduzindo-o para x<-scan();cat(x%%1:length(x)," ")- oh, e algumas dicas de formatação, 1) você só precisa de 4 espaços à esquerda do seu código para que ele seja recuado e marcado 2) você pode adicionar um<!-- language-all: lang-r --> sinalizador antes que seu código seja destacado (embora isso mude pouco neste exemplo) 3) você não precisa dos colchetes em torno do nome do seu idioma 4) ah e não precisa fazer um comentário ao editar uma postagem
Taylor Scott

2
(1) Você pode usar em =vez de <-para salvar um byte. (2) A especificação diz "output" em vez de "print", então você provavelmente pode soltar o cat(), economizando 5 bytes. (3)sum(1|x) é um byte menor que length(x).
rturnbull

5

APL (Dyalog) , 5 bytes

⍳∘≢|⊢

Experimente online!

 os índices

 do

 o comprimento do argumento

| esse módulo

 o argumento


Sempre espantado que uma linguagem "mainstream" possa ser tão econômica. A maneira APL parece naturalmente ser golf code: por exemplo, (~T∊T∘.×T)/T←1↓⍳R ⍝ primes up to Roulife←{↑1 ω∨.∧3 4=+/,¯1 0 1∘.⊖¯1 0 1∘.⌽⊂ω} ⍝ Game of Life

@YiminRong Você pode fazer melhor: Primos a R: (⊢~∘.×⍨)1↓⍳Re GoL (na versão 16.0): K∊⍨⊢∘⊂⌺3 3onde K é uma constante.
Adám

@YiminRong Experimente o localizador de números primos aqui !
Adám

5

Cubix , 19 bytes

;ww.1I!@s%Ow;)Sow.$

Experimente online!

    ; w
    w .
1 I ! @ s % O w
; ) S o w . $ .
    . .
    . .

Assista

Uma implementação bastante direta.

  • 1 pressione 1 na pilha para iniciar o índice
  • I!@ obter a entrada inteira e parar se 0
  • s%Ow Troque o índice, modifique o resultado e altere a faixa
  • ;) remover índice de resultado e incremento
  • Sow pressione 32, espaço de saída e mude de faixa (descendo de o)
  • $O pular a saída
  • w;wtroque a faixa, remova 32 da pilha e troque a faixa na Ientrada

5

05AB1E , 2 bytes

ā%

Experimente online! ou Experimente todos os testes

ā  # Push the range(1, len(a) + 1)
 % # Mod each element in the input by the same one in this list

Interessante, pensei que seria DgL%legal.
Octopus Magic Urn

@carusocomputing Eu tinha originalmente gL%porque esqueci ā.
Riley

mente se aprofundando um pouco āpara mim? Eu acredito que eu nunca usei, é apenas como, for eachmas de uma 1 to n+1maneira como, vy<code>})mas implícita vy<code>})?
Magic Octopus Urn

@carusocomputing empurra uma matriz com valores 1 para o comprimento da matriz popped. É equivalente a gL. TIO
Riley

Também engana a entrada? Ou a entrada implícita agora é estendida automaticamente para a entrada mais próxima disponível?
Magic Octopus Urn


4

Estrelado , 75 70 bytes

      +`  , + +   *    +  + +      +*   +    *  .               + + .'

Experimente online!

Explicação

Este é um loop infinito que mantém a leitura dos números da entrada e aumenta um contador inicializado em 1 . Para cada par de entrada e contador, o módulo é calculado e impresso.

Para finalizar o loop quando a entrada estiver esgotada, o seguinte truque é usado. Quando não há mais entrada disponível, tentar ler mais um número fornece a 0. Assim, dividimos o número de leitura por si só e, se for, 0o programa termina com um erro. Caso contrário, descartamos o resultado e continuamos.

      +              Push 1. This is the initial value of the counter
`                    Mark label
  ,                  Read number from input and push it. Gives 0 if no more input
 +                   Duplicate top of the stack
 +                   Duplicate top of the stack
   *                 Pop two numbers and push their division. Error if divisor is 0
    +                Pop (discard) top of the stack
  +                  Swap top two numbers
 +                   Duplicate top of the stack
      +              Push 1
*                    Pop two numbers and push their sum. This increases the counter
   +                 Rotate stack down, to move increased counter to bottom
    *                Pop two numbers and push their modulus
  .                  Pop a number and print it as a number
               +     Push 10
 +                   Duplicate top of the stack
 .                   Pop a number (10) and print it as ASCII character (newline)
'                    If top of the stack is non-zero (it is, namely 10) go to label



3

Japonês, 5 4 bytes

®%°T

Tente


Explicação

     :Implicit input of array U
®    :Map over the array
%    :Modulo of the current element
°T   :T (0, initially) incremented by 1

1
Eu acho que você pode salvar um byte com ®%°T(na verdade, você ainda pode usar Yse você queria)
ETHproductions

Aha. Obrigado, @ETHproductions.
Shaggy

3

R, 22 bytes

pryr::f(x%%1:sum(x|1))

R executa 1: comprimento (x) antes de executar o módulo.


Nice encontrar com sum(x|1)!
JAD

1
Acabei de descobrir que usar em seq()vez de seq_along()faz a mesma coisa. Então isso é alguns bytes mais curtos novamente.
JAD

1
Eu ia lhe dizer isso, mas não tinha o representante para comentar. Fico feliz que você tenha entendido.
Shayne03




2

Excel VBA, 59 46 bytes

Golfe

VBE anônimo Função imediata da janela que pega uma string de matriz delimitada por espaço ( ) como entrada do intervalo [A1]e gera o módulo de números em seu índice baseado em 1 na lista inicial para a janela imediata do VBE

For Each n In Split([A1]):i=i+1:?n Mod i;:Next

Entrada / Saída:

[A1]="10 9 8 7 6 5 4 3 2 1" ''# or manually set the value
For Each n In Split([A1]):i=i+1:?n Mod i;:Next
 0  1  2  3  1  5  4  3  2  1 

SubVersão antiga de rotina

Sub-rotina que recebe a entrada como uma matriz passada e sai para a janela imediata do VBE.

Sub m(n)
For Each a In n
i=i+1
Debug.?a Mod i;
Next
End Sub

Entrada / Saída:

m Array(10,9,8,7,6,5,4,3,2,1)
 0  1  2  3  1  5  4  3  2  1 

Ungolfed

Option Private Module
Option Compare Binary
Option Explicit
Option Base 0 ''# apparently Option Base 1 does not work with ParamArrays

Public Sub modIndex(ParamArray n() As Variant)
    Dim index As Integer
    For index = LBound(n) To UBound(n)
        Debug.Print n(index) Mod (index + 1);
    Next index
End Sub

Entrada / Saída:

Call modIndex(10,9,8,7,6,5,4,3,2,1)
 0  1  2  3  1  5  4  3  2  1 

1

CJam , 9 bytes

{_,,:).%}

Bloco anônimo que espera uma matriz na pilha e a substitui pela matriz de saída.

Experimente online!

Explicação

{       }    e# Define block
 _           e# Duplicate
  ,          e# Length
   ,         e# Range, 0-based
    :)       e# Add 1 to each entry
      .%     e# Vectorized modulus

1

J, 9 bytes

>:@i.@#|[

1 ... n | lista original

| é mod


1

JavaScript (ES6), 22 bytes

a=>a.map((x,y)=>x%++y)



1

GNU APL 1.2, 9 bytes

(⍳⍴R)|R←⎕

O APL opera da direita para a esquerda, daí os parênteses.

R←⎕atribui entrada do usuário ao vetor R.

⍴Rfornece o comprimento do vetor; ⍳⍴Rfornece um vetor com todos os números de 1 a esse comprimento (portanto, os índices).

|é o operador mod ( a|byields b%a). O APL opera em matrizes; portanto, o trecho de código de um vetor contendo cada elemento da entrada do usuário modifica seu índice.



1

Pitão, 5

.e%bh

Teste online .

    hk     # 1-based index of (implicit) lambda variable
   b       # element
  %        # element mod (1-based index)
.e    Q    # enumerated map over (implicit) input


1

Braingolf , 18 bytes

V1R&,{v.m1+v%}&,=;

Experimente online!

Explicação

V1R&,{v.m1+v%}&,=;  Implicit input from commandline args
V1R                 Create stack2, push 1 to it, and return to stack1
   &,               Reverse stack1
     {.......}      Foreach loop, runs for each item in stack1
      v             Switch to stack2
       .m           Duplicate last item on stack and move duplicate to stack1
         1+         Increment last item on stack
           v%       Return to stack1, pop last 2 items and push modulus result
              &,    Reverse stack1
                =   Output stack1
                 ;  Suppress implicit output

1

Java 8 / C #, 39 bytes

a->{for(int i=0;i<a.length;a[i]%=++i);}

Experimente aqui.

Também funciona em C # substituindo ->por =>e lengthpor Length:

a=>{for(int i=0;i<a.Length;a[i]%=++i);}

Experimente aqui.

Explicação:

a->{                       // Method with integer-array parameter and no return-type
  for(int i=0;i<a.length;  //  Loop over the indexes of the array (0-indexed)
      a[i]%=++i            //   And replace every integer with itself mod (1+i)
  );                       //  End of loop
}                          // End of method

Modifica a matriz de entrada, daí a falta de retorno.


1
Essencialmente o que eu faria em C # 1, também poderia comentar sobre o seu funcionamento para C # também se você mudar ->para =>e capitalizar length.
TheLethalCoder
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.