Czy możesz mnie obezwładnić? (Sekcja rabusiów)

43

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.5Python 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
Adnan
źródło

Odpowiedzi:

8

Cheddar, 7 6 bajtów, Downgoat

(<<)&1

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

feersum
źródło
Alternatywnie (**)&2. Próbowałem 2&(**)i nie udało mi się. :(
Dennis
@Dennis (**)&2działa dla mnie dobrze: / ale to też działa.
Downgoat
14

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

jimmy23013
źródło
1
Tak, zrobiłem coś dziwnego z wyznacznikami ... Tak dobrze ukryty, że sam nie mogłem tego znaleźć!
Dennis
@Dennis Wiem o tym, ponieważ pewnego dnia próbowałem również rozszerzyć wyznacznik, i to właśnie dostajesz, jeśli chcesz, aby działał jako produkt krzyżowy. Ale zajęło mi to dużo czasu, ponieważ myślałem, że to może być dziwne i nie spodziewałem się, że ktoś
wymyśli
Czy naprawdę można je uznać za „bajty”? Punkty kodowe dla i są w zakresie UTF-16. Dzięki temu rozwiązaniu 6 bajtów zakłada kodowanie heterogeniczne, a 8 bajtów zakłada kodowanie homogeniczne. Pytam szczerze tutaj.
Jules
11

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:

wprowadź opis zdjęcia tutaj

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

wprowadź opis zdjęcia tutaj

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):

wprowadź opis zdjęcia tutaj

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 .

Martin Ender
źródło
Święta krowa! Spodziewałem się, że zostanę pobity przez ciebie, ale nie aż tak bardzo! 0.o
Niebieski,
@Blue Czy planujesz dodać swoje wyjaśnienie? Byłbym zainteresowany tym, jak to działa. :) Prędzej czy później dodam wyjaśnienie do tego, ale nie jestem pewien, czy znajdę dziś czas.
Martin Ender,
Tak, moje używa bardziej tradycyjnej metody obliczania. Zupełnie zapomniałem o &, który mógł zaoszczędzić trochę bajtów
Blue
7

Haskell, 5 4 bajtów, xnor

(^)1

Proste curry.

Leaky Nun
źródło
7

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.

Sp3000
źródło
6

Sesos, 14 11 bajtów, Leaky Nun

Oblicza n 2 . 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
Lynn
źródło
Fajnie, jesteś jeszcze niższy niż moja oryginalna wersja golfowa.
Leaky Nun
To oblicza 1 + 3 + … + (2n–1)zamiast n × n:)
Lynn
Użyłem również twojego podejścia
Leaky Nun
6

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.

feersum
źródło
5

Brachylog , 27 21 bajtów, Fatalize

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

Wypróbuj online!

Leaky Nun
źródło
Dobra robota! Używanie dzielenia liczb całkowitych zdecydowanie nie jest rozwiązaniem, które miałem na myśli (które jest jeszcze krótsze), nawet o tym nie myślałem tbh: p
Fatalize
5

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.

randomra
źródło
Zgrabna sztuczka z i:zerami dla wartości ujemnych. Moja wersja była +/@(]!2*-)i.,].
mil
5

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
mile
źródło
5

Bałwan, 50 44 bajtów, Klamka

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

Wypróbuj online!

Lynn
źródło
Bardzo dobrze. Jeszcze krótszy niż oryginał, który był ((}#1nG|#2nMNdE0nR2aGaZ::nM;aF;aM:nS;aF,nM*)).
Klamka
5

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

feersum
źródło
Ładnie zrobione, to właśnie miałem na myśli. Lubię te trzy słowa.
xnor
4

Python 2, 43 40, xsot

g=lambda n:n<2or-~sum(map(g,range(n)))/3
feersum
źródło
Co ciekawe, różni się to od tego, co pierwotnie miałem.
xsot
4

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.
Dennis
źródło
Używając tej metody możesz uzyskać 8 za pomocą hV~oX*o+. Moja 5 bajt Odpowiedź brzmiałaSDmX^
Niebieski
Ach, ~ojest fajnie. Nie mam jednak pojęcia, co to SDmX^robi.
Dennis
Zasadniczo wykorzystuje mieszaną konwersację podstawową w zakresie 1-indeksowanym względem kwadratu. Nie ma czegoś na OEIS
Blue
Och, wpływa mtylko na, Xa nie na ^? To wiele wyjaśnia.
Dennis
Tak, mi podobne używają tylko następnego węzła. Wszelkie komentarze na temat moich dokumentów itp.?
Blue
4

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

alephalpha
źródło
Cieszę się, że złamałeś go w wieku 4 lat, ponieważ była trywialna modyfikacja mojej publicznej, którą przegapiłem. Miły!
Emigna,
4

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!).

feersum
źródło
Dla porównania miałem: `` Ḥc_ × c @ + ¥ \ nr0ç @ €: '+ \ S
Sp3000
@ Sp3000 Aha, więc dlaczego tego nie opublikowałeś?
feersum
Więcej czasu na przemyślenie 6, zanim Dennis opublikuje w M: P
Sp3000
4

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 .

Dennis
źródło
4

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
Dennis
źródło
Ach, strzelaj. Miałem nadzieję, że nikt nie złapie golfa matematycznego, którego przegapiłem. +1
DLosc
4

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.

nimi
źródło
............... Jak
TuxCrafting
3

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
Lynn
źródło
To jest dokładnie moje rozwiązanie: D
Leaky Nun
3

Python, 39 17 bajtów, Zniszczalny arbuz

lambda n:n*-~n>>1
Leaky Nun
źródło
naprawdę bardzo dobrze, cieszę się, że widzę to rozwiązanie
Destructible Lemon
Po co komplikować prostą formułę z odpowiednią zmianą?
xsot
@xsot Ponieważ nie wiedziałem, jakiej wersji użył.
Leaky Nun
3

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

?!/$(@

Rozłożony:

 ? ! 
/ $ (
 @ .

Wypróbuj online!

Ten sam pomysł, nieco inny układ.

Martin Ender
źródło
Ahhh, bardzo miło! To było dokładnie to samo rozwiązanie :).
Adnan,
3

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.

feersum
źródło
3

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
Leaky Nun
źródło
To właśnie odpowiedź, o której myślałem, dobra robota!
Fatalize
3

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
mile
źródło
3

M, 9 8 bajtów, Dennis

Ḥrc’ḊḄḤ‘
feersum
źródło
Fajny pomysł z podwójnym przyrostem
mile
3

QBasic, 30 29 bajtów, DLosc

INPUT n:?(n MOD 2)*(n+.5)+n/2
feersum
źródło
Miły! (Chociaż nie do końca to, co miałem).
DLosc