Sezione ladri

La sezione poliziotti si trova qui .

Sfida

Il tuo compito è superare le richieste degli sbirri nella stessa lingua e nella stessa versione (ad esempio, Python 3.5 ≠ Python 3.4 , quindi non è consentito). Una sottomissione è superata quando la lunghezza in byte è inferiore alla sottomissione originale. Devi solo golfare almeno 1 byte per decifrare un invio. Ad esempio, se l'attività doveva eseguire 2 × n e l'invio era il seguente:

print(2*input())

Puoi superare il poliziotto nel modo seguente:

print 2*input()

O anche questo (poiché sono ammessi i lambda):

lambda x:2*x

Pubblica questo con la seguente intestazione:

##{language name}, <s>{prev byte count}</s> {byte count}, {cop's submission + link}

Per esempio:

Python 2, 16 12 byte, Adnan (+ collegamento all'invio)

lambda x:2*x

Calcola A005843 , (offset = 0).

In tal caso, hai infranto l'invio.

punteggio

La persona con cui ha superato il maggior numero di richieste è il vincitore.

Regole

• La presentazione del crack deve essere nella stessa lingua della presentazione del poliziotto.
• Lo stesso input dovrebbe risultare nello stesso output (quindi un (2) = 4 dovrebbe rimanere 4).
• Per linguaggi come Python, è possibile importare librerie che sono standard incluse nella lingua. (Quindi, nessun numpy / sympy ecc.)
• Input e output sono entrambi in decimale (base 10).

Nota

Questa sfida è finita. Il vincitore della sezione Ladri è feersum . I punteggi finali per il CnR sono mostrati di seguito:

• feersum : 16 crepe
• Dennis : 12 crepe
• Leaky Nun : 6 crepe
• Lynn : 4 crepe
• miglia : 3 crepe
• Martin Ender : 2 crepe
• Emigna : 2 crepe
• jimmy23013 : 1 crack
• Sp3000 : 1 crack
• randomra : 1 crack
• alephalpha : 1 crack
• nimi : 1 crack
• Anguria distruttibile : 1 crack
• Dom Hastings : 1 crack

Cheddar, 7 6 byte, Downgoat

(<<)&1

Sembra funzionare, ma è sempre possibile che io non capisca correttamente la lingua.

Jelly ,54 byte , George V. Williams

RÆḊḞ

Provalo qui.

Una funzione nascosta!

Se mi sono ricordato correttamente, ÆḊ(A) = sqrt (det (AA ^T )) è n! volte la misura di Lebesgue in n dimensioni di un simplex formato da n punto di input e l'origine nello spazio m dimensionale. Quando n = 1 degenera alla distanza euclidea. Non è poi così strano ...

Esagonia , 91 33 byte, Blu

1""?{\>{+/</+'+./_'..@'~&/!}'+=($

non piegato:

    1 " " ?
   { \ > { +
  / < / + ' +
 . / _ ' . . @
  ' ~ & / ! }
   ' + = ( $
    . . . .

Provalo online!

Sembra ancora un po 'golfabile ma ho pensato che l'avrei pubblicato prima che FryAmTheEggman mi battesse. ;)

Spiegazione

Ecco alcuni percorsi di esecuzione con codice colore:

Tuttavia, questi sono inutilmente contorti a causa del golf. Ecco lo stesso codice esatto con un layout più igienico:

Va meglio. E infine, ecco un diagramma di memoria, in cui la freccia rossa indica la posizione iniziale e l'orientamento del puntatore di memoria (MP):

La sostanza è che sto iterativamente calcolare i numeri di Fibonacci sui tre archi etichettati f (i) , f (i + 1) e f (i + 2) tenendo traccia della iteratore sui bordi A , B e C . Nel fare ciò, i ruoli di questi bordi vengono scambiati ciclicamente dopo ogni iterazione. Vediamo come succede ...

Il codice inizia sul percorso grigio che esegue alcune impostazioni iniziali. Si noti che f (i) ha già il valore iniziale corretto di 0.

1   Set edge f(i+1) to 1.
""  Move the MP to edge A.
?   Read input n into edge A.
)   Increment n.

Ora il percorso verde è il ciclo principale. _e >sono solo specchi.

(     Decrement n.
<     If the result is zero or less, continue on the red path, otherwise
      perform another iteration of the main loop.
{     Move the MP to edge f(i+2).
+     Add edges f(i) and f(i+1) into this edge, computing the next Fibonacci number.
'     Move the MP to the edge opposite A.
~     Multiply by -1 to ensure that it's non-positive (the edge may have a positive
      value after a few iterations).
&     Copy the current value of n from A.
'     Move back and to the right again.
+     Copy n by adding it to zero. Since we know that the other adjacent edge
      is always zero, we no longer need to use ~&.
'+'+  Repeat the process twice, moving n all the way from A to B.
=     Reverse the orientation of the MP so that it points at f(i) which now
      becomes f(i+2) for the next iteration.

In questo modo, il MP si sposta attorno alla tripletta interna dei bordi, calcolando i numeri di Fibonacci successivi fino a nraggiungere lo zero. Quindi finalmente viene eseguito il percorso rosso:

{}    Move the MP to f(i).
!     Print it.
@     Terminate the program.

Diagrammi generati con HexagonyColorer ed EsotericIDE di Timwi .

Haskell, 5 4 byte, xnor

(^)1

Curry semplice

Stack Cats, 14 13 byte, feersum

^]T{_+:}_

con le -nmbandiere per +4 byte. Provalo online!

Va bene, quel ciclo era pazzo. Ho provato diversi approcci, come forzare la bruta su un alfabeto ridotto e forzare la bruta 3x+2o 5x+4e cercare di estenderlo, ma non mi aspettavo che la soluzione contenesse effettivamente un ciclo.

Il modo migliore per vedere come funziona è aggiungere un Dflag per il debug (quindi esegui con -nmD) e attivare il debug per il link TIO sopra. Un {}ciclo ricorda la parte superiore dello stack all'inizio del ciclo ed esce quando la parte superiore dello stack è di nuovo quel valore. L'interno del loop fa sottrarre e ciclare in modo divertente i primi tre elementi dello stack, ed è così che il loop viene eseguito per così tante iterazioni.

Sesos, 14 11 byte, Leaky Nun

Calcola n ² . Provalo qui.

Discarica esadecimale:

0000000: 16c0f7 959d9b 26e83e ce3d                         ......&.>.=

Dall'assemblaggio:

set numin
set numout
get
jmp
  jmp, sub 1, fwd 1, add 1, fwd 1, add 2, rwd 2, jnz
  fwd 2, sub 1
  rwd 1, sub 1
  jmp, sub 1, rwd 1, add 1, fwd 1, jnz
  rwd 1
jnz
fwd 2
put

Purtroppo, 776 759 byte, anguria distruttibile

| |||||||| | |
|| |||||| |
||| |||| |
|||| || |
||||| || |
|||| |||| |
||| |||||| |
|| |||||||| |
| |||||||||| |
|| |||||||| |
||| ||||||| |
||||||||||| |
||||||||||| |
||||||||||| |
||||||||||| |
|||||||||| |
||||||||| |
||||||||| |
||||||||| |
||||||||| |
|||||||||| |
||||||||||| |
|||||||||||| |
||||||||||| |
|||||||||| |
||||||||| |
|||||||| |
||||||| |
|||||| |
||||| |
|||| |
||| |
|| |
| |
| |
| |
|| |
|| |
|| |
|| |
|| |
| |
| |
| |
|| |
||| |
|||| |
||||| |
|||||| |
||||||| |
|||||| |
||||||| |
|||||||| |
||||||||| |
|||||||||| |
||||||||||| |
|||||||||||| |
||||||||||| |
|||||||||| |
||||||||| |
|||||||| |
||||||| |
|||||| |
||||| |
|||| |
||| |
|| |
| |
| |
| |
| |
|| |
| |
|| |
||| |
||| |
|||| |
||| |
|| |
| |
| |
| |
|| |
|| |
|| |
|| |

Ho provato a leggere il codice sorgente per questa lingua ma era troppo confuso. Per prima cosa, ip[1]è un numero di riga mentre ip[0]è il numero di colonna, mentre le cpcoordinate vengono utilizzate al contrario. Tuttavia, a volte cpviene assegnato il valore di ip. Ho rinunciato a cercare di capire cosa stesse facendo il programma e ho trovato un modo per codificare la sequenza identica di istruzioni usando meno barre.

Brachylog , 27 21 byte, Fatalizza

yrb:1a:+a:[1]c*.
:2/.

Provalo online!

J, 17 12 byte, miglia

+/@(]!2*-)i:

Praticamente lo stesso dell'originale, solo più golfato. :)

i:avere una +1portata rispetto a i.è utile (e strano). Se si utilizza i.qui n=0sarà errato ma per fortuna lo i:risolve.

Provalo online qui.

M, 10 6 byte, Dennis

R×\³¡Ṫ

Dato n , si calcola il n ^° -level fattoriale di n . Questo è stato un esercizio divertente!

Il codice è in grado di funzionare come Jelly in modo da poterlo provare online .

Spiegazione

R×\³¡Ṫ  Input: n
R       Create the range [1, 2, ..., n]
   ³¡   Repeat n times starting with that range
 ×\       Find the cumulative products
     Ṫ  Get the last value in the list
        Return implicitly

Pupazzo di neve, 50 44 byte, maniglia della porta

((}#2nMNdE0nR1`wRaC2aGaZ::nM;aF;aM:`nS;aF*))

Provalo online!

Haskell, 15 14 byte, xnor

until odd succ

Ho trascorso un paio di ore infruttuose a imparare a decifrare la sintassi "inutile" ... untilHo trovato invece questo.

O per un meno melliflue 13 byte, until odd(+1).

Python 2, 43 40, xsot

g=lambda n:n<2or-~sum(map(g,range(n)))/3

Pyke, 11 9 byte, pesce fangoso

hVoeX*oe+

Provalo qui!

Come funziona

          Implicit input: n (accumulator), n (iterations)
h         Increment the number of iterations.
 V        Do the following n + 1 times.
  o         Iterator. Pushes its value (initially 0) and increments it.
   e        Perform integer division by 2.
            This pushes 0 the first time, then 1, then 2, etc.
    X       Square the result.
     *      Multiply the accumulator and the result.
      oe    As before.
        +   Add the result to the accumulator.
            This sets the accumulator to a(0) = 0 in the first iteration and
            applies the recursive formula in all subsequent ones.

05AB1E , 7 4, Emigna

LnOx

Dalla formula per la somma dei quadrati di numeri interi positivi 1 ^ 2 + 2 ^ 2 + 3 ^ 2 + ... + n ^ 2 = n (n + 1) (2 * n + 1) / 6, se moltiplichiamo entrambi i lati per 2 otteniamo Sum_ {k = 0..n} 2 * k ^ 2 = n (n + 1) (2 * n + 1) / 3, che è una formula alternativa per questa sequenza. - Mike Warburton (mikewarb (AT) gmail.com), 8 settembre 2007

Jelly, 22 21 byte, Dennis

_²×c×Ḥc¥@÷⁸÷’{S
‘µR+ç

Ho trascorso diverse ore a leggere il codice sorgente di Jelly per l'ultimo, quindi potrei anche usare questa "abilità". Spero che @Dennis condivida con noi le sue scoperte matematiche permettendo una formula più breve (supponendo che ci sia qualcosa e non solo strani trucchi di Jelly!).

J, 20 19 byte, miglia

[:+/2^~+/@(!|.)\@i.

Questo calcola il prodotto come una somma di numeri quadrati di Fibonacci, che vengono calcolati come una somma di coefficienti binomiali.

Per fortuna, @miles stesso ha pubblicato il codice per generare numeri di Fibonacci in questo commento .

Acc !! , 526 525 byte, DLosc

N
Count x while _%60-46 {
(_+_%60*5-288)*10+N
}
_/60
Count i while _/27^i {
_+27^i*(_/27^i*26-18)
}
_*3+93
Count i while _/27^i/27%3 {
_-i%2*2+1
Count j while _/3^(3*j+2-i%2)%3 {
_+3^(1+i%2)
Count k while _/3^(3*k+1+i%2)%3-1 {
_+3^(3*k+1+i%2)*26
}
}
}
Count i while _/27^i/3 {
_-_/27^i/3%27*27^i*3+_/3^(3*i+1+_%3)%3*3
}
_/3
Count i while _/100^i {
_*10-(_%100^i)*9
}
Count i while _/100^i/10 {
_+_/100^i/10%10
Count j while i+1-j {
_+(_%10-_/100^(j+1)%10)*(100^(j+1)-1)
}
}
_/100
Count j while _/100^j {
Write _/100^j%10+48
}

Non ho idea di come funzioni, ma sono stato in grado di individuare un piccolo miglioramento.

24c24
< _+_/100^i*100^i*9
---
> _*10-(_%100^i)*9

Haskell, 10 byte, xnor

gcd=<<(2^)

Esempio di utilizzo: map ( gcd=<<(2^) ) [1..17]-> [1,2,1,4,1,2,1,8,1,2,1,4,1,2,1,16,1].

Come funziona: Dalla pagina di OEIS vediamo che a(n) = gcd(2^n, n)o scritti nella sintassi Haskell: a n = gcd (2^n) n. Funzioni con il modello f x = g (h x) xpossono essere orientati verso-point gratuito con la funzione =<<: f = g =<< h, quindi gcd=<<(2^)che si traduce ritorna gcd (2^x) x.

Sesos, 14 9 byte, Leaky Nun

Calcola n mod 16 . Provalo qui.

Esadecimale:

0000000: 17f84a 750e4a 7d9d0f                              ..Ju.J}..

Montaggio:

set numin
set numout
set mask
get
jmp, sub 1, fwd 1, add 16, rwd 1, jnz
fwd 1
jmp, sub 16, fwd 1, add 1, rwd 1, jnz
fwd 1
put

Python, 39 17 byte, Anguria distruttibile

lambda n:n*-~n>>1

05AB1E, 9 4 byte, Emigna

>n4÷

Provalo online!

Calcola invece questa funzione:

Esagonia , 7 6 byte, Adnan

?!/$(@

non piegato:

 ? ! 
/ $ (
 @ .

Provalo online!

Stessa idea, layout leggermente diverso.

MATL, 11 10 byte, Luis Mendo

YftdAwg_p*

Invece di fare -1 ^ lunghezza (array) converte gli elementi in valori booleani (che sono sempre 1), li annulla e prende il prodotto degli elementi.

Jelly, 11 10, Dennis

Ḥ’_Rc’*@RP

Versione vettorializzata dello stesso approccio.

Provalo online!

05AB1E, 10 8 byte, Adnan

µNÂÂQ>i¼

Provalo online .

Brachylog, 11 10 byte, Fatalizza

yb:AcLrLc.

Provalo online!

Spiegazione

Brachylog è un linguaggio derivato da Prolog, la cui più grande capacità è quella di provare le cose.

Qui, dimostriamo queste affermazioni:

yb:AcLrLc.
yb:AcL       Inclusive range from 1 to input, concatenated with A, gives L
     LrL     L reversed is still L
       Lc.   L concatenated is output

Gelatina, 9 8 byte, Dennis

œċr0$L€Ḅ

Scusate! Non sono riuscito a trovare la soluzione desiderata.

Ciò si basa sul fatto che C(n+k-1, k)è il numero di modi per scegliere i kvalori ncon la sostituzione.

Nota: questo è inefficiente poiché genera i set possibili per contarli, quindi cerca di evitare di usare valori elevati di n online.

Provalo online o Verifica fino a n .

In seguito ho trovato un'altra versione di 8 byte che è abbastanza efficiente per calcolare n = 1000. Questo calcola i valori usando il coefficiente binomiale ed evita di generare le liste.

Ḷ+c’Ṛ;1Ḅ

Provalo online o Verifica fino a n .

Spiegazione

œċr0$L€Ḅ  Input: n
  r0$     Create a range [n, n-1, ..., 0]
œċ        Create all combinations with replacement for
          (n, n), (n, n-1), ..., (n, 0)
     L€   Find the length of each
       Ḅ  Convert it from binary to decimal and return

Ḷ+c’Ṛ;1Ḅ  Input: n
Ḷ         Creates the range [0, 1, ..., n-1]
 +        Add n to each in that range
   ’      Get n-1
  c       Compute the binomial coefficients between each
    Ṛ     Reverse the values
     ;1   Append 1 to it
       Ḅ  Convert it from binary to decimal and return

M, 9 8 byte, Dennis

Ḥrc’ḊḄḤ‘

QBasic, 30 29 byte, DLosc

INPUT n:?(n MOD 2)*(n+.5)+n/2