Sekcja rabusiów

Sekcja gliniarzy znajduje się tutaj .

Wyzwanie

Twoim zadaniem jest przebicie postów gliniarzy w tym samym języku i tej samej wersji (na przykład Python 3.5 ≠ Python 3.4 , więc nie jest to dozwolone). Przesłanie jest rozłożone na bok, gdy długość w bajtach jest krótsza niż pierwotne przesłanie. Musisz złamać golf przynajmniej 1 bajt , aby złamać zgłoszenie. Np. Jeśli zadaniem było wykonanie 2 × n , a przesłanie było następujące:

print(2*input())

Możesz przerobić policjanta, wykonując następujące czynności:

print 2*input()

Lub nawet to (ponieważ lambda są dozwolone):

lambda x:2*x

Opublikuj to z następującym nagłówkiem:

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

Na przykład:

Python 2, 16 12 bajtów, Adnan (+ link do przesłania)

lambda x:2*x

Oblicza A005843 , (przesunięcie = 0).

W takim przypadku złamałeś zgłoszenie.

Punktacja

Zwycięzcą jest osoba, która złamała najwięcej zgłoszeń.

Zasady

• Zgłoszenie crack musi być w tym samym języku, co zgłoszenie gliniarza.
• To samo wejście powinno skutkować tym samym wyjściem (więc a (2) = 4 powinno pozostać 4).
• W przypadku języków takich jak Python można importować biblioteki, które są standardowo zawarte w tym języku. (Więc nie ma numpy / sympy itp.)
• Wejścia i wyjścia są w systemie dziesiętnym (podstawa 10).

Uwaga

To wyzwanie jest zakończone. Zwycięzcą rabusiów sekcji jest feersum . Ostateczne wyniki dla CnR pokazano poniżej:

• feersum : 16 pęknięć
• Dennis : 12 pęknięć
• Leaky Nun : 6 pęknięć
• Lynn : 4 pęknięcia
• mile : 3 pęknięcia
• Martin Ender : 2 pęknięcia
• Emigna : 2 pęknięcia
• jimmy23013 : 1 crack
• Sp3000 : 1 crack
• randomra : 1 crack
• alephalpha : 1 crack
• nimi : 1 crack
• Destructible Watermelon : 1 crack
• Dom Hastings : 1 crack

Cheddar, 7 6 bajtów, Downgoat

(<<)&1

To wydaje się działać, ale zawsze jest możliwe, że nie rozumiem poprawnie języka.

Galaretka ,54 bajty , George V. Williams

RÆḊḞ

Wypróbuj tutaj.

Ukryta funkcja!

Jeśli dobrze zapamiętałem, ÆḊ(A) = sqrt (det (AA ^T )) to n! razy n wymiarowej Lebesgue'a z simplex utworzonym przez punkt n wejściowego i pochodzenia w m-wymiarowej przestrzeni. Gdy n = 1, degeneruje się do odległości euklidesowej. W końcu nie takie dziwne ...

Sześciokąt , 91 33 bajtów, niebieski

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

Rozłożony:

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

Wypróbuj online!

Nadal wygląda na golfa, ale pomyślałem, że opublikuję go, zanim FryAmTheEggman mnie pokona. ;)

Wyjaśnienie

Oto kilka ścieżek wykonania oznaczonych kolorami:

Są one jednak niepotrzebnie skomplikowane z powodu gry w golfa. Oto dokładnie ten sam kod z poprawnym układem:

Tak lepiej I na koniec, oto schemat pamięci, w którym czerwona strzałka wskazuje początkową pozycję i orientację wskaźnika pamięci (MP):

Istotą jest, że m iteracyjne obliczenie liczby Fibonacciego na trzech krawędziach znakowanych F (I) , C (i + 1) i f (i + 2) , podczas gdy śledzenie iteracyjnej na krawędziach A , B i C . W ten sposób role tych krawędzi są wymieniane cyklicznie po każdej iteracji. Zobaczmy, jak to się dzieje ...

Kod zaczyna się na szarej ścieżce, która wykonuje wstępną konfigurację. Zauważ, że f (i) ma już prawidłową wartość początkową 0.

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

Teraz zielona ścieżka jest główną pętlą. _i >są tylko zwierciadłami.

(     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.

W ten sposób MP przesuwa się wokół wewnętrznej tryplety krawędzi, obliczając kolejne liczby Fibonacciego, aż nosiągnie zero. Następnie wykonywana jest czerwona ścieżka:

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

Diagramy wygenerowane za pomocą HexagonyColorer Timwi i EsotericIDE .

Haskell, 5 4 bajtów, xnor

(^)1

Proste curry.

Stack Cats, 14 13 bajtów, feersum

^]T{_+:}_

z -nmflagami dla +4 bajtów. Wypróbuj online!

Okej, ta pętla była szalona. Próbowałem kilku podejść, takich jak brutalne wymuszanie na zredukowanym alfabecie i brutalne wymuszanie 3x+2lub 5x+4próby rozszerzenia, ale nigdy nie spodziewałem się, że rozwiązanie faktycznie zawiera pętlę.

Najlepszym sposobem, aby zobaczyć, jak to działa, jest dodanie Dflagi do debugowania (więc uruchom z -nmD) i włączenie debugowania dla powyższego łącza TIO. {}Pętli zapamiętuje wierzch stosu na początku pętli i wychodzi kiedy szczyt stosu jest to, że wartość ponownie. Wnętrze pętli zapewnia zabawę odejmując i zmieniając trzy górne elementy stosu. W ten sposób pętla może działać przez tak wiele iteracji.

Sesos, 14 11 bajtów, Leaky Nun

Oblicza n ² . Wypróbuj tutaj.

Zrzut szesnastkowy:

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

Od montażu:

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

Niestety, 776 759 bajtów, Zniszczalny Arbuz

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

Próbowałem odczytać kod źródłowy tego języka, ale było to zbyt mylące. Po pierwsze, ip[1]jest to numer linii, podczas gdy ip[0]jest to numer kolumny, podczas gdy cpwspółrzędne są używane na odwrót. Czasami jednak cpprzypisywana jest wartość ip. Zrezygnowałem z próby zrozumienia, co robi program i znalazłem sposób na zakodowanie identycznej sekwencji instrukcji przy użyciu mniejszej liczby pasków.

Brachylog , 27 21 bajtów, Fatalize

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

Wypróbuj online!

J, 17 12 bajtów, mil

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

Prawie tak samo jak oryginał, tylko bardziej golfowy. :)

i:posiadanie +1zasięgu w porównaniu do i.jest przydatne (i dziwne). Jeśli użyjesz i.tutaj, n=0będzie niepoprawne, ale na szczęście to i:rozwiąże.

Wypróbuj online tutaj.

M, 10 6 bajtów, Dennis

R×\³¡Ṫ

Biorąc pod uwagę, n , to oblicza n ^th -level silnia n . To było fajne ćwiczenie!

Kod może działać jako Jelly, więc możesz wypróbować go online .

Wyjaśnienie

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

Bałwan, 50 44 bajtów, Klamka

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

Wypróbuj online!

Haskell, 15 14 bajtów, xnor

until odd succ

Spędziłem bezowocne kilka godzin ucząc się rozszyfrować „bezsensowną” składnię ... untilZamiast tego znalazłem to.

Lub dla mniej miodopłynny 13 bajtów until odd(+1).

Python 2, 43 40, xsot

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

Ryba, 11 9 bajtów, błotniak

hVoeX*oe+

Wypróbuj tutaj!

Jak to działa

          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

Ze wzoru na sumę kwadratów liczb całkowitych dodatnich 1 ^ 2 + 2 ^ 2 + 3 ^ 2 + ... + n ^ 2 = n (n + 1) (2 * n + 1) / 6, jeśli pomnożymy obie strony o 2 otrzymujemy Sum_ {k = 0..n} 2 * k ^ 2 = n (n + 1) (2 * n + 1) / 3, co jest alternatywnym wzorem dla tej sekwencji. - Mike Warburton (mikewarb (AT) gmail.com), 08 września 2007

Galaretka, 22 21 bajtów, Dennis

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

Spędziłem kilka godzin czytając kod źródłowy Jelly dla ostatniego, więc równie dobrze mogę wykorzystać tę „umiejętność”. Mam nadzieję, że @Dennis podzieli się z nami swoimi odkryciami matematycznymi, pozwalając na krótszą formułę (zakładając, że istnieje coś, a nie tylko dziwne galaretki!).

J, 20 19 bajtów, mil

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

Oblicza to produkt jako sumę kwadratowych liczb Fibonacciego, które są obliczane jako suma współczynników dwumianowych.

Na szczęście sam @miles opublikował w tym komentarzu kod do generowania liczb Fibonacciego .

Acc !! , 526 525 bajtów, 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
}

Nie mam pojęcia, jak to działa, ale zauważyłem niewielką poprawę.

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

Haskell, 10 bajtów, xnor

gcd=<<(2^)

Przykład użycia: map ( gcd=<<(2^) ) [1..17]-> [1,2,1,4,1,2,1,8,1,2,1,4,1,2,1,16,1].

Jak to działa: Od strony OEIS widzimy, że a(n) = gcd(2^n, n)albo napisany w składni Haskell: a n = gcd (2^n) n. Funkcje z wzoru f x = g (h x) xmoże być włączany do punktu wolne za pomocą funkcji =<<: f = g =<< h, stąd gcd=<<(2^)co przekłada się z powrotem gcd (2^x) x.

Sesos, 14 9 bajtów, Leaky Nun

Oblicza n mod 16 . Wypróbuj tutaj.

Klątwa:

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

Montaż:

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 bajtów, Zniszczalny arbuz

lambda n:n*-~n>>1

05AB1E, 9 4 bajty, Emigna

>n4÷

Wypróbuj online!

Zamiast tego oblicza tę funkcję:

Sześciokąt , 7 6 bajtów, Adnan

?!/$(@

Rozłożony:

 ? ! 
/ $ (
 @ .

Wypróbuj online!

Ten sam pomysł, nieco inny układ.

MATL, 11 10 bajtów, Luis Mendo

YftdAwg_p*

Zamiast robić długość -1 ^ (tablica) konwertuje elementy na wartości boolowskie (które zawsze wynoszą 1), neguje je i przyjmuje iloczyn elementów.

Galaretka, 11 10, Dennis

Ḥ’_Rc’*@RP

Wektoryzowana wersja tego samego podejścia.

Wypróbuj online!

05AB1E, 10 8 bajtów, Adnan

µNÂÂQ>i¼

Wypróbuj online .

Brachylog, 11 10 bajtów, Fatalize

yb:AcLrLc.

Wypróbuj online!

Wyjaśnienie

Brachylog to języki wywodzące się z Prologu, których największą umiejętnością jest dowodzenie.

Tutaj potwierdzamy następujące stwierdzenia:

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

Galaretka, 9 8 bajtów, Dennis

œċr0$L€Ḅ

Przepraszam! Nie mogłem znaleźć twojego zamierzonego rozwiązania.

Opiera się to na tym, że C(n+k-1, k)jest wiele sposobów wyboru kwartości nz zamianą.

Uwaga: Jest to nieefektywne, ponieważ generuje możliwe zestawy w celu ich policzenia, dlatego staraj się unikać używania dużych wartości n online.

Wypróbuj online lub Zweryfikuj do n .

Później znalazłem inną 8-bajtową wersję, która jest wystarczająco wydajna, aby obliczyć n = 1000. To oblicza wartości przy użyciu współczynnika dwumianowego i pozwala uniknąć generowania list.

Ḷ+c’Ṛ;1Ḅ

Wypróbuj online lub Zweryfikuj do n .

Wyjaśnienie

œċ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 bajtów, Dennis

Ḥrc’ḊḄḤ‘

QBasic, 30 29 bajtów, DLosc

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