Beschreibung

Chicken McNugget-Zahlen sind Zahlen, die als Summe von 6, 9 oder 20 ausgedrückt werden können - die Anfangsgrößen der berühmten Chicken McNuggets- Schachteln, die von McDonald's verkauft werden. In dieser Summe kann eine Zahl mehrmals vorkommen, so auch 6 + 6 = 12eine solche Zahl, und die Zahl muss mindestens eine der genannten Größen "enthalten". Die ersten Chicken McNugget-Nummern sind:

6
9
6 + 6 = 12
6 + 9 = 15
9 + 9 = 6 + 6 + 6 = 18
20
6 + 6 + 9 = 21
...

Herausforderung

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu schreiben, die bei einer positiven ganzen Zahl bestimmt, ob diese Zahl auf die beschriebene Weise ausgedrückt werden kann, und daher eine solche Chicken-McNugget-Zahl ist. Es sollte dann basierend auf seiner Entscheidung einen wahren oder falschen Wert ausgeben.

Testfälle

6 -> true
7 -> false
12 -> true
15 -> true
21 -> true
40 -> true
42 -> true

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes und es gelten die Standardlücken!

Python, 27 Bytes

lambda n:0x82492cb6dbf>>n&1

Probieren Sie es online!

Python 3 , 24 Bytes

lambda n:0<=n--n%3*20!=3

Probieren Sie es online!

Erläuterung

Mit 6und 9allein kann man alle ganzen Zahlen teilbar machen, durch 3die größer ist als 3, wie in ovs 'Kommentar zur Herausforderung angegeben . Es wird davon ausgegangen, dass man auch machen kann 0. Abschließend kann man machen 0,6,9,12,15,....

Mit einer Instanz 20kann man machen: 20,26,29,32,35,....

Mit zwei Instanzen 20kann man machen: 40,46,49,52,55,....

Drei Instanzen sind nie notwendig, z 3 x 20 = 10 x 6.

Beachten Sie, dass die Fälle, in denen no 20benötigt wird, auch durch 3 teilbar sind. die Fälle, in denen man 20gebraucht wird, lassen einen Rest von 2; In den Fällen, in denen zwei 20benötigt werden, verbleibt ein Rest von 1.

Die Anzahl der 20benötigten kann daher mit berechnet werden (-n)%3. Dann n-(((-n)%3)*20)entfernen wir die 20benötigte Anzahl aus der Anzahl. Wir prüfen dann, ob diese Zahl nicht negativ ist, aber nicht 3.

Python 2 , 28 Bytes

lambda n:-n%3-n/20<(n%20!=3)

Probieren Sie es online!

Jelly , 11 Bytes

ṗ3’æ.“©µÞ‘ċ

Probieren Sie es online!

Wie es funktioniert

ṗ3’æ.“©µÞ‘ċ  Main link. Argument: n

ṗ3           Cartesian power; yield all 3-tuples over [1, ..., n].
  ’          Decrement all coordinates.
     “©µÞ‘   Yield [6, 9, 20].
   æ.        Take the dot product of each 3-tuple and [6, 9, 20].
          ċ  Count the occurrences of n (Positive for Chicken McNuggets numbers).

Haskell , 36 Bytes

f n|n<1=n==0
f n=any(f.(n-))[6,9,20]

Probieren Sie es online!

Erläuterung

Diese Lösung ist so einfach wie möglich. In der ersten Zeile wird angegeben, dass es sich bei einer Zahl unter 1 um eine McNugget-Zahl handelt, wenn n==0. Das heißt, das 0ist eine McNugget-Zahl und nicht alle negativen Zahlen.

Die zweite Zeile gibt an, dass es sich bei allen anderen Nummern num eine McNugget-Nummer handelt, wenn es sich bei einer der Nugget-Größen um eine McNugget-Nummer handelt.

Dies ist eine ziemlich einfache rekursive Suche.

Python 3 , 48 46 42 Bytes

lambda n:n+50in b'2345679:<=?@BCEHIKNQTW]'

Probieren Sie es online!

Schalter Trueund False.

Jelly , 11 Bytes

_20$%3$¿o>3

Probieren Sie es online!

Port meiner Python-Antwort , aber leicht modifiziert: subtrahieren 20bis teilbar durch 3, dann prüfen, ob es gehört, 0,6,9,...indem 0es der Eingabe zugeordnet wird (mithilfe von or), und dann prüfen, ob es größer ist als 3.

Die einzigen drei Zahlen, die 0nach Abschluss des ersten Schritts erzeugt werden 0, 20sind oder 40, wobei die erste außerhalb des Bereichs liegt und der Rest größer als ist 3.

Mathematica, 53 Bytes

!Flatten@Table[Tr/@Tuples[{6,9,20},i],{i,#}]~FreeQ~#&

Mathematica, 30 Bytes

{6,9,20}~FrobeniusSolve~#!={}&

Probieren Sie es auf Wolfram Sandbox.

Mathematica, 20 Bytes

0<=#-20Mod[-#,3]!=3&

Anonyme Funktion. Nimmt eine Zahl als Eingabe und gibt sie zurück Trueoder Falseals Ausgabe. Logik kopiert von der Antwort von Leaky Nun , mit einigem zusätzlichen Missbrauch von Inequality.

x86-64-Maschinencode, 22 Byte

48 B8 41 92 34 6D DB F7 FF FF 83 F9 40 7D 03 48 D3 E8 83 E0 01 C3

Die obigen Bytes definieren eine Funktion im 64-Bit-x86-Maschinencode, die bestimmt, ob der Eingabewert eine Chicken McNugget-Nummer ist. Der einzelne positive Ganzzahlparameter wird im ECXRegister gemäß der unter Windows verwendeten 64-Bit-Aufrufkonvention von Microsoft übergeben. Das Ergebnis ist ein Boolescher Wert, der im EAXRegister zurückgegeben wird.

Ungolfed Assembler-Mnemonik:

; bool IsMcNuggetNumber(int n)
; n is passed in ECX
    movabs  rax, 0xFFFFF7DB6D349241   ; load a 64-bit constant (the bit field)
    cmp     ecx, 64
    jge     TheEnd                    ; if input value >= 64, branch to end
    shr     rax, cl
TheEnd:
    and     eax, 1                    ; mask off all but LSB
    ret

Offensichtlich spielt dies eine große Rolle für Anders Kaseorgs Lösung in Python , da es auf einem Bitfeld basiert, das die Werte darstellt, die Chicken McNugget-Zahlen sind. Insbesondere wird jedes Bit in diesem Feld, das einer gültigen Chicken McNugget-Nummer entspricht, auf 1 gesetzt. Alle anderen Bits werden auf 0 gesetzt. (Dies betrachtet 0 als eine gültige Chicken McNugget-Nummer. Wenn Ihnen das nicht gefällt, ist Ihre Präferenz eine Einzelbit-Modifikation entfernt.)

Wir beginnen damit, diesen Wert einfach in ein Register zu laden. Es ist ein 64-Bit-Wert, für dessen Codierung bereits 8 Byte erforderlich sind. Außerdem benötigen wir ein Ein-Byte-REX.W-Präfix, sodass wir tatsächlich einen erheblichen Verschwender-Aufwand in Bezug auf Bytes haben. Dies ist jedoch das Herzstück der Lösung Ich denke, es lohnt sich.

Dann verschieben wir das Feld um den Eingabewert nach rechts. ^* Schließlich maskieren wir alle außer dem niedrigsten Bit, und das wird unser boolesches Ergebnis.

Da Sie jedoch nicht mehr als die tatsächliche Anzahl von Bits im Wert verschieben können, funktioniert dies nur für Eingaben von 0 bis 63. Um eine höhere Eingabewerte zu unterstützen, legen wir einen Test an der Spitze der Funktion, die Zweige auf den Boden des Eingangswert> = 64. Das einzige , was interessant daran ist , die wir Vorspannung das Bit-Feld konstant RAX, und dann Zweig bis auf den Befehl, der das Bit niedrigster Ordnung maskiert, wodurch sichergestellt wird, dass immer 1 zurückgegeben wird.

Probieren Sie es online!
_{(Der dortige C-Funktionsaufruf ist mit einem Attribut versehen, das bewirkt, dass GCC ihn gemäß der von meinem Assemblycode verwendeten Microsoft-Aufrufkonvention aufruft. Wenn TIO MSVC bereitgestellt hätte, wäre dies nicht erforderlich.)}

__
_{* Als Alternative zu einer Verschiebung hätten wir den x86- BTBefehl verwenden können, aber das ist 1 Byte länger für die Codierung, also kein Vorteil. Es sei denn, wir mussten eine andere Aufrufkonvention verwenden, die den Eingabewert im ECXRegister nicht bequem übergab . Dies wäre ein Problem, da sein Quelloperand für eine dynamische Verschiebungszählung SHR erforderlich istCL . Daher würde eine andere Aufrufkonvention erfordern, dass wir MOVden Eingabewert von jedem Register, an das er übergeben wurde, editieren ECX, was uns 2 Bytes kosten würde. Der BTBefehl kann ein beliebiges Register als Quelloperand verwenden, und das zu einem Preis von nur 1 Byte. In dieser Situation wäre es also vorzuziehen.BTSetzt den Wert des entsprechenden Bits in das Übertragsflag (CF), so dass Sie einen SETCBefehl verwenden würden, um diesen Wert in einem Ganzzahlregister abzurufen, ALso dass er an den Aufrufer zurückgegeben werden könnte.}

Alternative Implementierung, 23 Bytes

Hier ist eine alternative Implementierung, die Modulo- und Multiplikationsoperationen verwendet, um zu bestimmen, ob der Eingabewert eine Chicken McNugget-Zahl ist.

Es verwendet die AMD64-Aufrufkonvention von System V , die den Eingabewert im EDIRegister übergibt . Das Ergebnis ist immer noch ein Boolescher Wert, der in zurückgegeben wird EAX.

Beachten Sie jedoch, dass dies im Gegensatz zum obigen Code ein inverser Boolescher Wert ist (zur Vereinfachung der Implementierung). Es wird zurückgegeben, falsewenn der Eingabewert eine Chicken McNugget-Nummer ist oder truewenn der Eingabewert keine Chicken McNugget-Nummer ist.

                    ; bool IsNotMcNuggetNumber(int n)
                    ; n is passed in EDI
8D 04 3F            lea    eax, [rdi+rdi*1]   ; multiply input by 2, and put result in EAX
83 FF 2B            cmp    edi, 43
7D 0E               jge    TheEnd             ; everything >= 43 is a McNugget number
99                  cdq                       ; zero EDX in only 1 byte
6A 03               push   3
59                  pop    rcx                ; short way to put 3 in ECX for DIV
F7 F1               div    ecx                ; divide input value by 3
6B D2 14            imul   edx, edx, 20       ; multiply remainder of division by 20
39 D7               cmp    edi, edx
0F 9C C0            setl   al                 ; AL = (original input) < (input % 3 * 20)
                 TheEnd:
C3                  ret

Das Hässliche daran ist, dass Eingabewerte> = 43 explizit von einem Vergleichs- und Verzweigungspunkt oben behandelt werden müssen. Es gibt natürlich auch andere Möglichkeiten, die keine Verzweigung erfordern, z. B. den Algorithmus von Caird Coinheringaahing. Die Codierung würde jedoch viel mehr Bytes in Anspruch nehmen. Dies ist also keine vernünftige Lösung. Ich vermisse wahrscheinlich einen Bit-Twiddling-Trick, der dazu führen würde, dass dies eleganter abläuft und weniger Bytes enthält als die obige bitfeldbasierte Lösung (da das Codieren des Bitfelds selbst so viele Bytes erfordert), aber ich habe dies untersucht eine Weile und kann es immer noch nicht sehen.

Na ja, versuchen Sie es online !

05AB1E, 17 16 Bytes

ŽGç₂в©IED®âO«]I¢

Probieren Sie es online!

Erläuterung

  ŽGç₂в                 The list [6, 9, 20]
       ©                Store this list in register_c
        IE              Loop <input> number of times
           ®â           Cartesian product stack contents with list in register_c
             O          Sum up the contents of each sub array
          D   «         List duplicated before taking Cartesian product, concat
               ]        End for loop
                I¢      Count occurences of input

JavaScript (ES6), 69 64 Byte

n=>'ABCDEFHIKLNOQRTWXZ]`cfl'.includes(String.fromCharCode(n+65))

f=
n=>'ABCDEFHIKLNOQRTWXZ]`cfl'.includes(String.fromCharCode(n+65))

<input onkeydown=a.innerHTML=f(this.value)>
<pre id=a>

falseAnsonsten Ausgaben für Chicken McNugget-Nummern true.

Java, 21 57 24 Bytes

Probieren Sie es online!

Golf gespielt:

n->(n-=n*2%3*20)>=0&n!=3

Ungolfed:

import java.util.*;

public class ChickenMcNuggetNumbers {

  private static final Set<Integer> FALSE_VALUES = new HashSet<>(Arrays.asList(
    new Integer[] { 0, 1, 2, 3, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 22, 23,
    25, 28, 31, 34, 37, 43 }));

  public static void main(String[] args) {
    for (int i = 0; i < 45; ++i) {
      System.out.println(i + " -> expected=" + !FALSE_VALUES.contains(i)
        + ", actual=" + f(n->(n-=n*2%3*20)>=0&n!=3, i));
    }
  }

  public static boolean f(java.util.function.Function<Integer, Boolean> f, int n) {
    return f.apply(n);
  }
}

Python 2 , 51 Bytes

-1 Byte dank @LeakyNun

lambda n:max(n>43,25<n>n%3>1,5<n>n%3<1,n in[20,40])

Probieren Sie es online! Fußzeile druckt alle Nicht-McNugget-Nummern

Pyth , 15 Bytes

fg.{CM"     "{T./

Probieren Sie es online!

Die Zeichenfolge enthält die Zeichen, die den Codepunkten 6, 9 und 20 entsprechen.

Haskell, 64 56 Bytes

Ich habe keine kleinen Tricks gemacht, aber bei den anderen Antworten könnte es tatsächlich kürzer sein, das BitsModul zu importieren und diese Methoden zu verwenden. Dieser Ansatz prüft viel direkter.

f x=(\l->elem x[i*6+j*9+k*20|i<-l,j<-l,k<-l,x/=0])[0..x]

Javascript, 92 78 72 Bytes

* 14 Bytes gespart dank @Jonasw

a=>!(a in[0,1,2,3,4,5,7,8,10,11,13,14,16,17,19,22,23,25,28,31,34,37,43])

Verwendet die Tatsache, dass "alle Ganzzahlen McNugget-Zahlen außer 1, 2, 3, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 22, 23, 25, 28, 31, 34 sind , 37 und 43. von @ LeakyNuns Kommentar

APL (Dyalog) , 19 Bytes

⊢∊6 9 20+.×⍨∘↑∘⍳3⍴⊢

mit ⎕IO←0

Gleicher Algorithmus mit Dennis 'Antwort

Probieren Sie es online!

Retina , 26 Bytes

.+
$*
^(1{6}|1{9}|1{20})+$

Probieren Sie es online!

Add ++ , 35 Bytes

D,f,@,A6$%0=@20$%0=A3$%0=A8<A43<s1<

Probieren Sie es online!

Schau ma, keine while-Schleifen. Oder Streicher. Oder Listen. Oder wirklich alles, was hilft, Bytes zu sparen. Aber hauptsächlich, weil Add ++ nicht weiß, was eines davon ist.

3 Monate später stellte ich fest, dass dies ungültig war und korrigierte es. Irgendwie hat das 13 Bytes gekostet. Dies ist eine Funktion, die ein Argument verwendet und prüft, ob dieses Argument eine Chicken McNugget-Zahl ist oder nicht.

Wie es funktioniert

D,f,@,                        - Create a monadic (one argument) function called f (example argument: 3)
A                             - Push the argument again; STACK = [3 3]
 6                            - Push 6;                  STACK = [3 3 6]
  $                           - Swap the top two values; STACK = [3 6 3]
   %                          - Modulo;                  STACK = [3 3]
    0                         - Push 0;                  STACK = [3 3 0]
     =                        - Are they equal?          STACK = [3 0]
      @                       - Reverse the stack;       STACK = [0 3]
       20                     - Push 20;                 STACK = [0 3 20]
         $                    - Swap the top two values; STACK = [0 20 3]
          %                   - Modulo;                  STACK = [0 3]
           0                  - Push 0;                  STACK = [0 3 0]
            =                 - Are they equal?          STACK = [0 0]
             A                - Push the argument;       STACK = [0 0 3]
              3               - Push 3;                  STACK = [0 0 3 3]
               $              - Swap the top two values; STACK = [0 0 3 3]
                %             - Modulo;                  STACK = [0 0 0]
                 0            - Push 0;                  STACK = [0 0 0 0]
                  =           - Are they equal?          STACK = [0 0 1]
                   A          - Push the argument;       STACK = [0 0 1 3]
                    8         - Push 8;                  STACK = [0 0 1 3 8]
                     <        - Less than;               STACK = [0 0 1 0]
                      A       - Push the argument;       STACK = [0 0 1 0 3]
                       43     - Push 43;                 STACK = [0 0 1 0 3 43]
                         <    - Less than;               STACK = [0 0 1 0 0]
                          s   - Sum;                     STACK = [1]
                           1  - Push 1;                  STACK = [1 1]
                            < - Less than;               STACK = [0]

Excel, 87 Bytes

=AND(OR(MOD(A1,3)*MOD(A1,20)*IF(A1>43,MOD(A1-40,3),1)*IF(A1>23,MOD(A1-20,3),1)=0),A1>5)

Alternativ 92 Bytes:

=CHOOSE(MOD(A1,3)+1,A1>3,IF(A1>43,MOD(A1-40,3)=0,A1=40),IF(A1>23,MOD(ABS(A1-20),3)=0,A1=20))

PHP, 69 + 1 Bytes

for($n=$argn;$n>0;$n-=20)if($n%3<1)for($k=$n;$k>0;$k-=9)$k%6||die(1);

geht mit 1für eine Chicken McNugget Nummer,0 sonst.

Laufen Sie als Pipe mit -noder versuchen Sie es online .

Python 2 , 61 Bytes

lambda n:n in[int(c,36)for c in'1234578ABDEGHJMNPSV']+[37,43]

Probieren Sie es online!

Mathematica, 59 Bytes

!Select[IntegerPartitions@#,{6,9,20}~SubsetQ~#&]=={}&&#!=0&

Javascript 37 Bytes

Nimmt eine positive Ganzzahl nund gibt sie truefür Chicken McNugget-Zahlen und falsefür andere aus.

F=n=>!(n<0||(n%6&&!F(n-9)&&!F(n-20)))

Erläuterung

F=n=>!(            // negate the internal test for non-Chicken McNugget numbers
    n<0 || (       // if n < 0, or
        n%6 &&     // if n % 6 is truthy,
        !F(n-9) && // and n-9 is not a Chicken McNugget number
        !F(n-20)   // and n-20 is not a Chicken McNugget number
                   // then n is not a Chicken McNugget number
    )
)

Die Rekursion in dieser Funktion ist abscheulich und für jede ausreichend große Funktion nüberschreiten Sie die Grenzwerte für die Aufrufliste. In der folgenden Version werden diese Beschränkungen numgangen, indem überprüft wird, ob sie größer sind als die größte Nicht-Chicken-McNugget-Zahl (43 Byte [Bonuspunkte für die größte Nicht-Chicken-McNugget-Zahl?]):

F=n=>n>43||!(n<0||(n%6&&!F(n-9)&&!F(n-20)))

F=n=>n>43||!(n<0||(n%6&&!F(n-9)&&!F(n-20)))

$('#input').on('keyup', () => $('#output').text(F(parseInt($('#input').val(), 10))))

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<input type="text" id="input" />
<span id="output"></span>

JavaScript ES5, 46 Byte

n=>n>5&&(!(n%20)||(n<24?!(n%3):n<44?n%3-1:1));

Explizite boolesche Antwort, 50 Bytes:

n=>!!(n>5&&(!(n%20)||(n<24?!(n%3):n<44?n%3-1:1)));

Unbeholfen, aber es erledigt den Job. Gibt falseoder 0für jeden Wert zurück, der nicht 0, 1, 2, 3, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 22, 23, 25, 28, 31, 34 ist , 37, oder 43, und true, -1oder 1für alles andere.

Explizite Lösung kehrt zurück trueoder falsenur.

n=>!!(                                          ); forces Boolean type (optional)
      n>5                                          false for 0, 1, 2, 3, 4, 5 (and negative inputs)
            !(n%20)                                explicit true for 20, 40
                      n<24?!(n%3)                  false for 7, 8, 10, 11, 13, 14, 16, 17, 19, 22, 23
                                  n<44?n%3-1       false for 25, 28, 31, 34, 37, 43

Clojure 33 Bytes

Ein guter schneller Versuch: #(-> %(rem 20)(rem 9)(rem 6)(= 0))

Pari / GP , 48 Bytes

0ist falsch. alles andere ist wahr.

n->n*Vec(1/(1-x^6)/(1-x^9)/(1-x^20)+O(x^n++))[n]

Probieren Sie es online!