Cicli matematici inversi


18

Ispirato da questo

Nella sfida collegata, ci viene chiesto di applicare l'aggiunta agli elementi dell'originale e al contrario dell'array di input. In questa sfida, la renderemo leggermente più difficile, introducendo le altre operazioni matematiche di base.

Dato un array di numeri interi, scorrere +, *, -, //, %, ^, dove si //trova la divisione di numeri interi ed ^è esponente, mentre si applica al retro dell'array. Oppure, in altre parole, applicare una delle funzioni sopra a ciascun elemento di un array, con il secondo argomento che è il contrario dell'array, con la funzione applicata che scorre ciclicamente l'elenco sopra. Questo può essere ancora fonte di confusione, quindi facciamo un esempio.

Input:   [1, 2, 3, 4, 5, 6, 7, 8, 9]
Reverse: [9, 8, 7, 6, 5, 4, 3, 2, 1]

         [ 1,  2,  3,  4,  5,    6,  7,  8,  9]
Operand:   +   *   -   /   %     ^   +   *   -
         [ 9,  8,  7,  6,  5,    4,  3,  2,  1]

Result:  [10, 16, -4,  0,  0, 1296, 10, 16,  8]

quindi l'output per [1, 2, 3, 4, 5, 6, 7, 8, 9]sarebbe[10, 16, -4, 0, 0, 1296, 10, 16, 8]

Per coprire i casi angolari, l'ingresso non conterrà mai uno 0, ma può contenere qualsiasi altro numero intero nell'intervallo dall'infinito negativo all'infinito positivo. Se lo desideri, puoi inserire input come un elenco di stringhe che rappresentano le cifre.

Casi test

input => output

[1, 2, 3, 4, 5, 6, 7, 8, 9]     => [10, 16, -4, 0, 0, 1296, 10, 16, 8]
[5, 3, 6, 1, 1]                 => [6, 3, 0, 0, 1]
[2, 1, 8]                       => [10, 1, 6]
[11, 4, -17, 15, 2, 361, 5, 28] => [39, 20, -378, 7, 2, 3.32948887119979e-44, 9, 308]

Questo è un quindi vince il codice più breve (in byte)!



@AdmBorkBork Lo sta affrontando, l'ho sottolineato in chat.
Mr. Xcoder,

@AdmBorkBork corretto. L'ho perso nel mio generatore di test case
caird coinheringaahing

Il tuo terzo caso di test contiene ancora 0>.>
Mr. Xcoder

1
@DigitalTrauma per le lingue che per impostazione predefinita sono numeri interi, penso che l'output di 0 sia accettabile per numeri così piccoli.
caird coinheringaahing

Risposte:


6

Gelatina, 10 byte ( fork )

+×_:%*6ƭ"Ṛ

L'altro giorno stavo solo lavorando per implementare una rapida, quindi è abbastanza sorprendente vedere un suo utilizzo così presto. Esiste ancora solo come fork, quindi non puoi provarlo online.

Uscita campione

$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[1,2,3,4,5,6,7,8,9]'
[10, 16, -4, 0, 0, 1296, 10, 16, 8]
$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[5,3,6,1,1]'
[6, 3, 0, 0, 1]
$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[2,1,8]'
[10, 1, 6]
$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[11,4,-17,15,2,361,5,28]'
[39, 20, -378, 7, 2, 3.32948887119979e-44, 9, 308]

Spiegazione

+×_:%*6ƭ"Ṛ  Input: array
      6ƭ    Tie 6 dyads
+             Addition
 ×            Multiplication
  _           Subtraction
   :          Integer division
    %         Modulo
     *        Power
        "   Vectorize with
         Ṛ  Reverse

whaaaaaaaat dai davvero :( ma bello, questa rapida sembra abbastanza utile: D
HyperNeutrino

Questo deve essere portato a Jelly. +1 anche se potresti voler estendere ƭper supportare nilad (sostituire il valore) e monadi (applicare sull'argomento di sinistra)
Erik the Outgolfer,

@EriktheOutgolfer Funziona già con le monadi. Guarda gli esempi che ho pubblicato nella chat di Jelly. I nilad sono un caso diverso.
miglia,

@miles intendo proprio come si comportano i nilad qui .
Erik the Outgolfer,

@EriktheOutgolfer Ok ora supporta nilads, ma richiede di definirne la lunghezza e di utilizzare uno spazio tra i due. Esempio 2 1”q3ƭ€su [7,4,9,0]restituisce[2, 1, 'q', 2]
miglia

4

Buccia , 16 byte

Questa sfida favorisce le lingue che possono creare infiniti elenchi di funzioni. Forse no, evalFTW

zF¢+ë+*-÷e%^Ṡze↔

Provalo online!

Come?

  ¢+ë+*-÷e%^         The infinite list [+,*,-,÷,%,^,+,*,-,...
    ë+*-÷            The list [+,*,-,÷]
         e%^         The list [%,^]
   +                 Concatenated
  ¢                  Then repeated infinitely
               ↔     The input reversed e.g [9,8,7,6,5,4,3,2,1]
            Ṡze      Zipped with itself     [[9,1],[8,2],[7,3],[6,4],[5,5],[4,6],[3,7],[2,8],[1,9]]
zF                   Zipwith reduce, the list of functions and the list of lists.
                     [F+[9,1],F*[8,2],F-[7,3],F÷[6,4],F%[5,5],F^[4,6],F+[3,7],F*[2,8],F-[1,9]]
                     [10     ,16     ,-4     ,0      ,0      ,1296   ,10     ,16     ,8      ]

Soluzione alternativa a 17 byte:

ṠozIzI¢+ë+*-÷e%^↔

Per curiosità, perché non puoi farlo ë+*-÷%^? Perché fare il enecessario?
caird coinheringaahing

@cairdcoinheringaahing ëaccetta 4 argomenti, eaccetta 2. Non ce
n'è

3

05AB1E , 18 byte

Â"+*-÷%m"Ig×)øε`.V

Provalo online!

Spiegazione

                    # push a reversed copy of the input
 "+*-÷%m"            # push the list of operators
         Ig×         # repeat it input times
            )ø       # zip together
              ε      # apply to each triplet
               `     # push separately to stack
                .V   # evaluate

Ig∍se volessi usare il comando "newish" (non ho visto molto qui).
Magic Octopus Urn,

3

Utilità Bash + GNU, 53

tac $1|paste -d, $1 -|tr ',
' '
;'|paste -sd+*-/%^|bc

Questo script accetta un nome file come parametro della riga di comando.

Provalo online .

La cosa bella qui è che paste -dconsente di fornire un elenco di separatori, che vengono utilizzati ciclicamente. Il resto è solo ottenere l'input nel formato giusto per farlo.


Non riesce per l'ultimo caso di prova :( tio.run/…
Shaggy,


3

Gelatina , 15 byte

żṚj"“+×_:%*”ṁ$V

Provalo online! o vedi la suite di test .

Come?

żṚj"“+×_:%*”ṁ$V - Link: list of numbers, a       e.g. [5, 3, 6, 1, 1]
 Ṛ              - reverse a                           [1, 1, 6, 3, 5]
ż               - interleave                          [[5,1],[3,1],[6,6],[1,3],[1,5]
             $  - last two links as a monad:
    “+×_:%*”    -   literal list of characters        ['+','×','_',':','%','*']
            ṁ   -   mould like a                      ['+','×','_',':','%']
   "            - zip with the dyad:
  j             -   join                              ["5+1","3×1","6_6","1:3","1%5"]
              V - evaluate as Jelly code (vectorises) [6, 3, 0, 0, 1]

Salva un paio di byte conż“+×_:%*”;"ṚV
Erik the Outgolfer,

@EriktheOutgolfer che funziona solo se la lunghezza dell'input è esattamente 6. Penso che dovresti fare ż“+×_:%*”ṁ$;"ṚVche è anche di 15 byte.
Jonathan Allan,

ok a cosa stavo pensando ... Mi manca così tanto il "pareggio" :(
Erik the Outgolfer,


2

JavaScript (ES7), 68 67 byte

a=>[...a].map((v,i)=>(x=a.pop(),o='+*-/%'[i%6])?eval(v+o+x)|0:v**x)


Bella soluzione! Forse puoi spostare l'assegnazione tra oparentesi .pop()per salvare qualche byte.
Luca,

@Luke L'assegnazione a oviene anche utilizzata come condizione dell'operatore ternario. Ciò spezzerebbe questo schema.
Arnauld,

@Shaggy. Era la stessa identica prima risposta di Arnauld.

@ThePirateBay: Ah. Sui dispositivi mobili SE quindi non è possibile visualizzare le cronologie delle modifiche.
Shaggy,

2

Perl 6 ,67 66 byte

Salvato 1 byte grazie a @nwellnhof.

{map {EVAL ".[0] {<+ * - div % **>[$++%6]} .[1]"},zip $_,.reverse}

Provalo online!

Soluzione molto fantasiosa (e probabilmente cattiva). Chiude a zip l'argomento con se stesso invertito. L'elenco risultante viene quindi mappato con il blocco corrispondente EVALalla stringa a (operator) b. L'operatore viene scelto dall'elenco di stringhe <+ * - div % **>usando la variabile libera state(pensa staticin C - il valore persiste attraverso le chiamate del blocco) $. Questo viene creato per ogni blocco separatamente e impostato su 0. Puoi fare qualsiasi cosa ti piaccia, ma puoi fare riferimento solo una volta (ogni occorrenza di si $riferisce a un'altra variabile, in realtà). Quindi in $++%6realtà è 0 durante la prima chiamata, 1 durante la seconda, ... 5 durante la 6a, 0 durante la 7a e così via.

All'inizio ho provato a fare a meno di un EVAL. Gli operatori sono in realtà solo subs (= funzioni), ma i loro nomi sono così estremamente ungolfy ( &infix:<+>e così via) che ho dovuto rinunciare a quell'approccio.


map {EVAL ".[0] ... .[1]"},zip $_,.reverseè più corto di 1 byte.
nwellnhof,

@nwellnhof, grazie!
Ramillies,

2

Haskell , 74 117 105 byte

x#y=fromIntegral.floor$x/y
x%y=x-x#y
f u=[o a b|(o,a,b)<-zip3(cycle[(+),(*),(-),(#),(%),(**)])u(reverse u)]

Provalo online!

Risparmiato 12 byte grazie a @nimi

C'è sicuramente un modo migliore per raggiungere questo obiettivo.

EDIT 1. Esponente fisso per numeri interi; 2. C'è sicuramente un modo migliore, vedi il commento qui sotto: 95 91 byte

x#y=fromIntegral.floor$x/y
x%y=x-x#y
f=zipWith3($)(cycle[(+),(*),(-),(#),(%),(**)])<*>reverse

Provalo online!


zipWith3($)(cycle[(+),(*),(-),div,mod,(^)])<*>reverseÈ una versione più corta, ora eliminata.
H.Piz,

@ H.PWiz stavo cercando qualcosa del genere ma non ho avuto il tempo di guardare oltre. Perché l'hai eliminato? Credo che non sia vietato avere due diverse soluzioni nella stessa lingua, soprattutto quando una è molto meglio dell'altra ...
jferard,

@ H.PWiz Esponente fisso.
jferard,

Non è necessario per la hchiamata di o: o a be senza di ciò è possibile inline h( TIO ).
nimi,


1

J, 44 42 byte

Cancellato 44, yada yada ...

-2 byte grazie a @ ConorO'Brien

_2+/`(*/)`(-/)`(<.@%/)`(|~/)`(^/)\[:,],.|.

Provalo online!

Così tante parentesi e inserti ... Sicuramente c'è un modo migliore per farlo (magari usando insert anziché infix?)

Spiegazione

_2(+/)`(*/)`(-/)`(<.@%/)`(|~/)`(^/)\[:,],.|.  Input: a
                                       ],.|.  Join a with reverse(a)
                                      ,       Ravel (zip a with reverse(a))
_2                                 \          To non-overlapping intervals of 2
  (+/)`(*/)`(-/)`(<.@%/)`(|~/)`(^/)           Apply the cyclic gerund
   +/                                           Insert addition
        */                                      Insert subtraction
             -/                                 Insert division 
                  <.@%/                         Insert integer division
                          |~/                   Insert mod
                                ^/              Insert exponentiation

Alcune note:

J non ha divisione intera, quindi %componiamo -division con -floor >.. Mod ( |) di J fa l'ordine inverso di quello che ci aspetteremmo, quindi dobbiamo invertire il suo ordine usando ~-reflessivo.

Anche se ci stiamo spostando su intervalli di 2, dobbiamo usare /-insert per inserire i verbi per farli usare in modo diaadico poiché è così che funziona \-infix.


Mi piacerebbe anche sapere come evitare tutto ()e ripetuto /- Non sono stato in grado di capirlo ....
Giona

@Jonah, la cosa migliore che mi viene in mente è qualcosa di simile /a un array invertito (dato che opera all'indietro ...) con verbi simili (,+)`(,*)ma che non aiuta molto ... (anche che non funziona)
Cole

1
Il gerundio può essere+/`(*/)`...
Conor O'Brien l'

1

Rubino , 63 57 byte

->a{t=0;a.map{|x|eval [x,a[t-=1]]*%w(** % / - * +)[t%6]}}

Niente di speciale, davvero. Basta iterare sull'array, usare un indice come iteratore inverso, unire una stringa usando l'operatore giusto, valutare, risciacquare e ripetere.

Provalo online!


1

k , 40 byte

{_((#x)#(+;*;-;%;{y!x};{*/y#x})).'x,'|x}

Provalo online!

{                                      } /function(x)
                                     |x  /reverse x
                                  x,'    /zip concat with x
        ( ; ; ; ;     ;       )          /list of operations
         + * - %                         /add, mult, sub, div
                 {y!x}                   /mod (arguments need to be reversed)
                       {*/y#x}           /pow (repeat and fold multiply)
  ((#x)#                       )         /resize operations to length of x
                                .'       /zip apply
 _                                       /floor result

1

MATL ,27 23 byte

-4 byte grazie a @LuisMendo

tP+1M*1M-IM&\w1M^v"@X@)

Provalo online!

Spiegazione:

tP         % duplicate and flip elements
+          % push array of sums (element-wise)
1M*        % push array of products (element-wise)
1M-        % push array of subtractions (element-wise)
IM&\w      % push array of divisions and modulo (element-wise)
1M^        % push array of power (element-wise)
v          % vertically concatenate all arrays
"@X@)    % push to stack values with the correct index based on operator
           % (implicit) convert to string and display


0

R , 74 byte

function(l)Map(Map,c(`+`, `*`, `-`, `%/%`, `%%`,`^`),l,rev(l))[1:sum(l|1)]

Provalo online!

Questa è la risposta finale che mi è venuta in mente. Restituisce un elenco di lunghezza in length(l)cui ogni elemento è un elenco contenente l'elemento corrispondente. Un po 'schifoso ma sono tutti lì. Se ciò è inaccettabile, uno dei due Mappuò essere sostituito con mapplyper +3 byte.

Poiché gli operatori R sono tutte funzioni (la notazione infix è solo zucchero sintattico), ho provato a selezionarne una da un elenco; ad esempio, la soluzione a 94 byte di seguito.

Per provare a sbarazzarsi del ciclo, ho provato sapply, ma funziona solo con una singola funzione e un elenco di input. Poi ho ricordato la forma multivariata mapply, che assume una n-aryfunzione FUNe nargomenti successivi, applicando FUNal primo, secondo, ..., elementi di ciascuno degli argomenti, riciclando se necessario . C'è anche una funzione di involucro mapply, Mapche "fa alcun tentativo di semplificare il risultato" . Poiché è più corto di tre byte, è una buona opportunità per giocare a golf.

Così ho definito una funzione trinaria (come nella soluzione a 80 byte di seguito) che accetta una funzione come primo argomento e la applica al suo secondo e terzo. Tuttavia, ho capito che Mapè una funzione che prende una funzione come primo argomento e la applica a quelle successive. ! Neat

Infine, effettuiamo il sottoinsieme alla fine per assicurarci di restituire solo i primi length(l)valori.

R , 80 byte

function(l)Map(function(x,y,z)x(y,z),c(`+`, `*`, `-`, `%/%`, `%%`,`^`),l,rev(l))

Provalo online!

Questo non funziona, poiché restituirà 6 valori per elenchi con meno di 6 elementi.

R , 94 byte

function(l){for(i in 1:sum(l|1))T[i]=switch(i%%6+1,`^`,`+`,`*`,`-`,`%/%`,`%%`)(l,rev(l))[i]
T}

Provalo online!

Spiegazione (leggermente non golfizzata):

function(l){
 for(i in 1:length(l)){
  fun <- switch(i%%6+1,`^`,`+`,`*`,`-`,`%/%`,`%%`) # select a function
  res <- fun(l,rev(l))                             # apply to l and its reverse
  T[i] <- res[i]                                   # get the i'th thing in the result
 }
 T                                                 # return the values
}

Poiché ciascuna delle funzioni è vettorializzata, possiamo indicizzare alla fine ( res[i]). Questo è meglio evaldell'approccio seguente.

R , 100 byte

function(l)eval(parse(t=paste("c(",paste(l,c("+","*","-","%/%","%%","^"),rev(l),collapse=","),")")))

Provalo online!

Questo è l' evalapproccio più breve che ho trovato; perché dobbiamo raccogliere i risultati in un unico vettore, abbiamo bisogno di pasteun c( )giro tutte le espressioni, che aggiunge una tonnellata di byte inutili


0

Casio-Basic, 108 byte

{x+y,x*y,x-y,int(x/y),x-int(x/y)y,x^y}⇒o
dim(l)⇒e
Print seq(o[i-int(i/6)6+1]|{x=l[i+1],y=l[e-i]},i,0,e-1)

È stato doloroso. Soprattutto perché mod(x,y)restituisce xquando in realtà non dovrebbe, che mi ha costretto a fare il mio propria funzione MOD: da qui la x-int(x/y)y.

Passa ida 0 a length(l)-1, prendendo gli elementi successivi onell'elenco e facendo domanda l[i]per xe l[-i]per y. (gli indici negativi non funzionano però, quindi sottraggo idalla lunghezza dell'elenco e prendo quell'indice.)

107 byte per la funzione, +1 byte da aggiungere lnella casella dei parametri.


0

Java 8, 336 byte

import java.math.*;a->{int b[]=a.clone(),i=0,l=b.length,s,t;for(;i<l/2;b[i]=b[l+~i],b[l+~i++]=t)t=b[i];BigInteger r[]=new BigInteger[l],u,v;for(i=-1;++i<l;t=b[i],v=new BigInteger(t+""),r[i]=(s=i%6)<1?u.add(v):s<2?u.multiply(v):s<3?u.subtract(v):s<4?u.divide(v):s<5?u.remainder(v):t<0?u.ZERO:u.pow(t))u=new BigInteger(a[i]+"");return r;}

Provalo qui.

Sigh ..
Input as int[], output as java.math.BigInteger[].

Senza la regola " Per coprire i casi angolari, l'input non conterrà mai uno 0, ma potrebbe contenere qualsiasi altro numero intero nell'intervallo da infinito negativo a infinito positivo. ", Utilizzando numeri interi nell'intervallo -2147483648a 2147483647, sarebbe 186 byte (input as int[]e nessun output perché modifica questo array di input invece di salvare byte):

a->{int b[]=a.clone(),i=0,l=b.length,t,u,v;for(;i<l/2;b[i]=b[l+~i],b[l+~i++]=t)t=b[i];for(i=-1;++i<l;v=b[i],a[i]=(t=i%6)<1?u+v:t<2?u*v:t<3?u-v:t<4?u/v:t<5?u%v:(int)Math.pow(u,v))u=a[i];}

Provalo qui.

Spiegazione:

import java.math.*;            // Required import for BigInteger

a->{                           // Method with int[] parameter and BigInteger[] return-type
  int b[]=a.clone(),           //  Make a copy of the input-array
      i=0,                     //  Index-integer
      l=b.length,              //  Length of the input
      s,t;                     //  Temp integers
  for(;i<l/2;b[i]=b[l+~i],b[l+~i++]=t)t=b[i];
                               //  Reverse the input-array and store it in `b`
  BigInteger r[]=new BigInteger[l],
                               //  Result-array
             u,v;              //  Temp BigIntegers
  for(i=-1;                    //  Reset `i` to -1
      ++i<l;                   //  Loop over the array(s):
                               //    After every iteration:
      t=b[i],                  //     Set the current item of `b` in `t`
      v=new BigInteger(t+""),  //     And also set it in `v` as BigInteger
      r[i]=(s=i%6)<1?          //   If the index `i` modulo-6 is 0:
            u.add(v)           //    Add the items with each other
           :s<2?               //   Else-if index `i` modulo-6 is 1:
            u.multiply(v)      //    Multiply the items with each other
           :s<3?               //   Else-if index `i` modulo-6 is 2:
            u.subtract(v)      //    Subtract the items with each other
           :s<4?               //   Else-if index `i` modulo-6 is 3:
            u.divide(v)        //    Divide the items with each other
           :s<5?               //   Else-if index `i` modulo-6 is 4:
            u.remainder(v)     //    Use modulo for the items
           :                   //   Else (index `i` modulo-6 is 5):
            t<0?               //    If `t` is negative:
             u.ZERO            //     Simply use 0
            :                  //    Else:
             u.pow(t))         //     Use the power of the items
    u=new BigInteger(a[i]+""); //  Set the current item of `a` to `u` as BigInteger
                               //  End of loop (implicit / single-line body)
  return r;                    //  Return the result BigInteger-array
}                              // End of method
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.