Ihre Herausforderung besteht darin, eine Funktion oder ein Programm zu erstellen, das "Ja" ausgibt, wenn eine bestimmte Zahl durch 13 teilbar ist, und "Nein" ausgibt, wenn dies nicht der Fall ist.

Regeln:
- Die Nummer 13 darf nirgendwo verwendet werden.
- Auch für 13 gibt es keine Cop-Out-Synonyme (wie bei 15 - 2).
- Bonuspunkte werden für das Nichtverwenden des Moduls vergeben, zusätzlicher Bonus für das Nichtverwenden der Division.

Scoring:
- Ihre Punktzahl wird die Anzahl der Bytes im Code sein (Leerzeichen nicht von Ihrem Bonus multipliziert enthalten).
- Wenn Sie das Modul nicht verwendet haben, beträgt der Bonus 0,90. Wenn Sie die Division nicht verwendet haben, beträgt der Bonus 0,90.
- Wenn Sie auch nicht verwendet haben, ist dieser Bonus 0,80.
- Je niedriger Ihre Punktzahl, desto besser.

Die Eingabe ist immer eine ganze Zahl größer als 0 und kleiner als 2 ^ 32.
Ihre Ausgabe sollte ein einfaches "Ja" oder "Nein" sein.

Erläuterungen:
- Die Verwendung einer Umgehungsmethode zum Generieren der Nummer 13 zur Verwendung ist akzeptabel. Einfache arithmetische Synonyme wie (10 + 3) sind nicht erlaubt.
- Die Funktion oder das Programm muss buchstäblich "Ja" oder "Nein" ausgeben, wenn die angegebene Zahl durch 13 teilbar ist.
- Wie immer werden clevere Lösungen empfohlen, die jedoch nicht erforderlich sind.

Java ( 60,8 59,2 Punkte )

void t(int n){System.out.print(Math.cos(.483321946706122*n)>.9?"yes":"no");}

Punktzahl: (76 - 2 Leerzeichen) Zeichen * 0,8 = 59,2

ASM - 16-Bit-x86 auf der WinXP-Befehlsshell

ausführbar - 55 Bytes * 0,8 = 44

Quelle - 288 Zeichen * 0,8 = 230,4

Die Nummer 13 erscheint nicht einmal in der zusammengestellten .com-Datei.

Mit A86 zusammenbauen.

    mov si,82h
    xor ax,ax
    xor cx,cx
a:  imul cx,10
    add cx,ax
    lodsb
    sub al,48
    jnc a
    inc cx
h:  mov dl,a and 255
c:  loop g
    sub dl,a and 255
    jz e
    mov dl,4
e:  add dl,k and 255
    mov dh,1
    mov ah,9
    int 21h
    ret
g:  inc dl
    cmp dl,c and 255
    jne c
    jmp h
k:  db 'yes$no$'

Python 3.x: 54 * 0,8 = 43,2

Es mag ein Cop-Out sein, eine Zeichenkette mit der Länge 13 zu haben, aber hier ist es:

print('no' if any((' ' * int(input())).split('             ')) else 'yes')

Es funktioniert, indem eine Zeichenfolge mit n Leerzeichen erstellt wird (die Auswahl des Begrenzungszeichens ist willkürlich, ich habe jedoch aus offensichtlichen Gründen Leerzeichen gewählt) und 13-Leerzeichen-Teilzeichenfolgen aufgeteilt werden, bis eine Zeichenfolge mit n% 13 Leerzeichen übrig bleibt.

GolfScript, 32 Zeichen

~){.14base{+}*.@<}do('no''yes'if

Ich wollte etwas anderes als alle anderen ausprobieren, also berechnet meine Lösung die digitale Wurzel der Zahl zur Basis 14 , indem sie die Zahl wiederholt zur Basis 14 konvertiert und die Ziffern summiert, bis das Ergebnis nicht mehr kleiner wird. Dies entspricht im Wesentlichen der Berechnung des Restmoduls 13, mit der Ausnahme, dass das Ergebnis im Bereich von 1 bis 13 anstelle von 0 bis 12 liegt.

Da es schwierig wäre, zu überprüfen, ob die digitale Wurzel gleich 13 ist, ohne die Zahl 13 selbst zu verwenden (oder eine lahme Umgehung wie 12 + 1), erhöhe ich die eingegebene Zahl vor der Schleife um eins und dekrementiere das Ergebnis anschließend. Auf diese Weise ist das Ergebnis für Zahlen, die durch 13 teilbar sind, tatsächlich Null, was viel einfacher zu überprüfen ist.

Hier ist eine kommentierte Version des Programms:

~              # evaluate the input, turning it from a string to a number
)              # increment by one
{              # start of do-loop 
    .          # make a copy of the previous number, so we can tell when we're done
    14 base    # convert the number to base 14
    { + } *    # sum the digits
    . @ <      # check if the new number is less than the previous number...
} do           # ...and repeat the loop if so
(              # decrement the result by one
'no' 'yes' if  # output 'no' if the result is non-zero, 'yes' if it's zero

Dieses Programm wird Griff tatsächlich jede nicht negativen Ganzzahleingaben, da GolfScript Bignum-Arithmetik verwendet. Natürlich können extrem große Eingaben zu viel Zeit und / oder Speicher beanspruchen.

Der Code verwendet weder Module noch Divisionen direkt, obwohl er den Basisumwandlungsoperator von GolfScipt verwendet, der mit ziemlicher Sicherheit intern Divisionen und Restbeträge vornimmt. Ich überlasse es GigaWatt, zu entscheiden, ob ich für den Bonus qualifiziert bin oder nicht.

C 68 × 0,8 = 54,4

Nach 24 Antworten hat sich noch niemand diesen offensichtlichen Algorithmus ausgedacht:

f(x){puts("no\0yes"+3*((x*330382100LL>>32)-(~-x*330382100LL>>32)));}

JavaScript (27.9)

Aktuelle Version (31 Zeichen * 0,90 Bonus = 27,9).

alert(prompt()*2%26?'no':'yes')

Demo: http://jsfiddle.net/9GQ9m/2/

Edit 1: Verzichten Sie auf den zweiten Bonus, indem Sie das Modul verwenden, um die Punktzahl erheblich zu senken und eine forSchleife zu vermeiden . Beseitigen ~~und speichern Sie auch zwei Zeichen (danke @copy).

Ältere Version (48 Zeichen * 0,80 Bonus = 38,4)

for(n=~~prompt()*2;n-=26>0;);alert(n?'no':'yes')​

BrainFuck

Ergebnis: 200 * 0,8 = 160

>++++++[>++++++++<-]>>,[<[-<+>>-<]<[->+<]>>>[->++++++++++<]>[-<+>]<<[->+<],]++++
+++++++++>[>+<-<-[>>>]>>[[-<<+>>]>>>]<<<<]>[<<<[-<++>]<++++++++++++++.+.>]<<[[-<
++++++<++++++++>>]<-----.<---.>------.>]

Liest von stdin. Wahrscheinlich nicht die cleverste Lösung, aber alles zu bekommen, was in BF funktioniert, ist schön. Es ist jedoch ziemlich kompakt.

Scala (38 * 0,9 = 34,2)

Ähnlich wie 0xD(hex) oder 015(oct).

ASCII- Wert von CRist 13.

def t(n:Int)=if(n%'\r'==0)"yes"else"no"

Haskell, 28 × 0,8 = 22,4

f x|gcd 26x>2="yes"|1<3="no"

Python:

f=lambda n:1==pow(8,n,79)

Z.B

[i for i in range(100) if f(i)]

gibt

[0, 13, 26, 39, 52, 65, 78, 91]

C, 54,4 = = 68 × 8 ×   80 × 8

char*f(c){char*s=" yes\0\rno";while(c&&*s++);return c>0?f(c-*s):++s;}

ECMAScript 6, 25 × 0,9 = 22,5

Ja, es ist eine langweilige Art, 13 zu werden.

n => n % '             '.length ? 'no' : 'yes'

APL ((21-1) × 0,8 = 16)

'yes' 'no'[1=⎕∨⌊⍟9*6]

⎕IOsollte auf 0 gesetzt werden, damit dies in Dyalog APL ordnungsgemäß funktioniert. Um 13 zu generieren, nehmen wir den Boden ( ⌊) des natürlichen Logarithmus ( ⍟) von 9 hoch 6 ( 9*6). Danach finden wir die GCD ( ∨) unserer Eingaben ( ⎕) und 13 und testen dann, ob diese gleich 1 sind. Dies wird verwendet, um ([...] den Vektor der Antworten ).

Wenn jemand pedantisch sein möchte, was die Erwähnung von Bytes in der Scoring-Spezifikation betrifft, lautet der Score für die UTF-8-codierte Version davon(29 - 1) × 0.8 = 22.4 . :)

C 88

Fibonacci-Trick.

f(n){return n<2?n:f(n-1)+f(n-2);}main(x){printf("%s",x%f(7)?"No":"Yes",scanf("%d",&x));}

Perl - 44 × 0,8 = 35,2

#!perl -p
map$_+=4*chop,($_)x10;$_=chop^$_*3?'no':yes

Den Shebang als ein Byte zählen.

Ich bin ein bisschen spät dran, aber ich dachte, ich würde den Algorithmus teilen, da ihn bis jetzt noch kein anderer Beitrag verwendet hat.

Dies funktioniert unter der Beobachtung, dass, wenn n durch 13 teilbar ist , ⌊ n / 10 ⌋ + n% 10 * 4 auch durch 13 teilbar ist . Die Werte 13 , 26 und 39 wechseln sich ab. Alle anderen Vielfachen von 13 erreichen schließlich einen dieser Werte in nicht mehr als log ₁₀ n Iterationen.

In anderen Basen

Zugegeben, chopist ein bisschen ein Cop-out. Bei einer Basis 10-Darstellung entspricht dies divmod. Der Algorithmus funktioniert aber auch in anderen Basen einwandfrei, zum Beispiel in Basis 4 oder 8.

Python-artiger Pseudocode des obigen Algorithmus (Basis 10):

def div13(n):
    while n > 40:
        q, r = n // 10, n % 10
        n = q + 4*r
    return n in [13, 26, 39]

In Basis 2:

def div13(n):
    while n > 40:
        q, r = n >> 1, n & 1
        n = q + 7*r
    return n in [13, 26, 39]

In Basis 4:

def div13(n):
    while n > 40:
        q, r = n >> 2, n & 3
        n = q + 10*r
    return n in [13, 26, 39]

In Basis 8:

def div13(n):
    while n > 40:
        q, r = n >> 3, n & 7
        n = q + 5*r
    return n in [13, 26, 39]

etc. Jede Basis kleiner als 13 funktioniert genauso gut.

Javascript: 59 * 0,8 = 47,2 (?)

Geige :

function r(n){
  for(c=0;n>c;n-=12,c++);
  return n==c?'yes':'no';
}

Einschließlich der Verbesserung von Mellamokb (57 * 0,8 = 45,6):

function r(n){
  for(c=0;n>c;n-=12,c++);
  return n-c?'no':'yes'
}

Perl: (51-4 Stellen) * 0,9 = 42,3

say+<>%(scalar reverse int 40*atan2 1,1)?'no':'yes'

40 * atan2 (1,1) -> 31,41592 (PI * 10)

Perl (19,8)

21 Bytes * .9

say2*<>%26?"no":"yes"

Hinweis: Mein erstes Perl-Programm überhaupt. Schwach getippt ist wohl gut fürs Golfen.

in C (K & R): 47 · 0,8 = 37,6

f(i){for(;i>0;i-=__LINE__);puts(i?"no":"yes");}

EDIT1: okay entfernte alle Abhängigkeiten von externen Funktionen, das oben genannte arbeitet, solange Sie diese Zeile auf die 13. Zeile der Datei setzen! :) Wenn __LINE__es in Ordnung ist, durch "Sagen" ersetzt zu werden, 0xdkönnen weitere 5 Zeichen gespeichert werden (Punktzahl: 33,6).

J - 22,4 ^{= 28 · 0,8}

Basierend auf der cleveren zyklischen Methode von mxmul .

f=:<:{('yes',~12 3$'no ')$~]

Beispiele:

   f 13
yes
   f 23
no
   f 13*513
yes
   f 123456789
no

JavaScript (108 minus 0 für Leerzeichen) => 108, x 0,8 (kein Modul, keine Division) = 86,4

b=b=>{a=z,a=a+"";return+a.slice(0,-1)+4*+a.slice(-1)};z=prompt();for(i=99;i--;)z=b();alert(b()-z?"no":"yes")

Diese Methode verwendet den folgenden Algorithmus: 1. Nehmen Sie die letzte Ziffer, multiplizieren Sie sie mit vier und addieren Sie sie zum Rest der abgeschnittenen Zahl. 2. Wiederholen Sie Schritt 1 für 99 Iterationen ... 3. Testen Sie ihn noch einmal mit Schritt 1. Wenn die resultierende Zahl selbst ist, haben Sie ein Vielfaches von 13 gefunden.

Vorheriges Update entfernt var und Umkehrlogik bei der Warnung zum Entfernen weiterer Zeichen unter Verwendung einer subtraktionsfalschen Bedingung.

Technisch gesehen ist das Endergebnis, dass Sie schließlich eine zweistellige Zahl wie 13, 26 oder 39 erreichen, die bei erneutem Durchlaufen von Schritt 1 13, 26 oder 39 ergibt. Das Testen auf die gleiche Iteration 100 bestätigt also die Teilbarkeit.

Cheddar, 20 Bytes (nicht konkurrierend)

Die Punktzahl beträgt 20 * 0,9 = 18

n->n*2%26?'no':'yes'

Eine klare Antwort.

Common Lisp (71 Bytes * 0,8) = 56,8

Eigentlich eine einfache Rekursion.

(defun w(x)(if(> x 14)(w(- x 13))(if(> 14 x 12)(print'yes)(print'no))))

Ungolfed:

(defun w (x)
  (if (> x 14)
      (w (- x 13))
      (if (> 14 x 12)
          (print 'yes)
          (print 'no))))

Rubin ( 50 48 * 0,9 = 43,2)

Intelligente Verwendung eval

eval x="p gets.to_i*3%x.length == 0? 'yes':'no'"

D 56 Zeichen, 80 Bonus = 44,8

bool d(double i){
    return modf(i*0,0769230769,i)<1e-3;
}

Dies könnte ein Cop-Out mit 1/13 gewesen sein, und ein Double kann jede 32-Bit-Zahl genau speichern

edit: Dies funktioniert durch Multiplizieren mit 1/13 und Überprüfen des Bruchteils, wenn dieser von 0 abweicht (wobei Rundungsfehler berücksichtigt werden), oder mit anderen Worten, indem der Bruchteil von i / 13 überprüft wird

Python 2.7

(20 - 1 Leerzeichen) * 0,9 (keine Unterteilung) = 17,1

print input()%015==0

ja / nein statt wahr / falsch: 31 * 0,9 (keine Division) = 27,9

print'yneos'[input()%015!=0::2]

nutzt Python int , um andere Basen von Strings in Basis-10-Ganzzahlen umzuwandeln. Sie können in beiden Versionen sehen, dass sie eine unterschiedliche (aber gleiche Zeichenlänge) Basis verwenden

Bearbeiten: 1 Zeichen speichern in Ja / Nein-Version

edit2: noch 2 chars rasiert!

edit3: danke nochmal an kommentare! noch mehr Zeichen, die durch die Verwendung von Pythons eingebauten Oktaldarstellungen ( 015== 13...) anstelle der Basisübersetzung von int abgeschnitten wurden

Perl, 95 · 0,8 = 76

$_=<>;
while($_>0){
$q=7*chop;
$d=3*($m=chop$q);
chop$d;
$_-=$d+$m}
if($_){print"no"}
else{print"yes"}

Die Zeilenumbrüche wurden zur Verdeutlichung hinzugefügt. Ich hätte diese Antwort wahrscheinlich viel kürzer machen können, aber ich bin der Meinung, dass diese Antwort eine einzigartige Methode darstellt, um das Problem anzugehen.

Python - Punktzahl 27.9

(31 Zeichen * 0,90) - verzichtet auf einen Bonus für kürzeren Code.

print'yneos'[2*input()%26>0::2]

ältere Version: (47 Zeichen * 0,80) - Vollständige Abzocke von Mellamokbs Javascript-Antwort, jedoch in Python.

n=2*input()
while n>0:n-=26
print'yneos'[n<0::2]

ältere Version: (60 Zeichen * 0,80)

n=input()
while n>12:
 for _ in'x'*12+'!':n-=1
print'yneos'[n>0::2]

ältere Version: (105 Zeichen * 0,80)

n=abs(input())
while n>12:n=abs(sum(int(x)*y for x,y in zip(`n`[::-1],n*(1,-3,-4,-1,3,4))))
print'yneos'[n>0::2]

In Q:

d:{$[0=x mod "I"$((string 6h$"q")[1 2]);`yes;`no]}
50*.9=45

Rechte lineare Grammatik - ∞ Punkte

S->ε
S->1A
S->0S
S->9I
S->3C
S->5E
S->4D
S->2B
S->7G
S->6F
S->8H
F->3K
K->0F
A->2L
K->1G
A->5B
A->0J
B->7A
J->5A
G->6K
G->8S
H->9K
F->5S
K->2H
I->6E
I->5D
J->4S
D->8I
B->6S
K->9B
F->6A
G->9A
K->6L
K->4J
C->1E
L->8K
E->5C
B->4K
C->0D
J->2K
D->2C
A->9F
J->7C
C->6J
C->8L
E->0K
L->0C
B->9C
E->2S
L->6I
I->0L
J->0I
B->2I
I->3B
H->1C
I->7F
C->4H
F->1I
G->4I
I->0G
C->3G
F->8C
D->0A
E->3A
I->9H
A->7D
C->2F
H->7I
A->8E
F->9D
E->8F
A->6C
D->6G
G->0E
D->5F
E->9G
H->2D
D->7H
H->3E
I->2A
K->3I
C->9S
C->7K
E->4B
D->1B
L->1D
J->9E
I->1S
E->1L
J->8D
D->9J
L->2E
J->3L
B->5L
B->8B
L->7J
L->9L
G->1F
A->4A
K->5K
B->3J
H->6H
E->7E
J->1J
D->4E
G->2G
J->6B
D->3D
E->6D
H->4F
I->4C
C->5I
F->0H
H->5G
K->7S
G->3H
L->5H
H->8J
A->3S
H->0B
B->1H
G->7L
K->8A
F->2J
F->7B
L->4G
F->4L
A->1K
B->0G
G->5J
L->3F

Abhängig davon, wie Sie es ausführen, wird "Ja" oder "Nein" ausgegeben.

Kein ernsthafter Eintrag, nur ein bisschen Spaß;)

BEARBEITEN: Vielleicht sollte ich ein bisschen erklären.

EIN Grammatik ist eine Reihe von Regeln (Produktionen), die eine Sprache definieren . Eine Sprache kann als alle möglichen Folgen eines Alphabets betrachtet werden, die den Regeln ihrer Grammatik entsprechen.

Hier ist das Alphabet die Menge aller Dezimalstellen. Nach den Regeln der Grammatik müssen alle Zeichenfolgen Dezimalzahlen bilden, die durch 13 teilbar sind.

Wir können die obige Grammatik verwenden, um zu testen, ob eine Zeichenfolge zu unserer Sprache gehört.

Die Regeln der Grammatik enthalten terminale Symbole (die Elemente in der Sprache sind) sowie nicht terminale Symbole, die rekursiv ersetzt werden.

An einem Beispiel lässt sich leichter erklären, was los ist:

Nehmen wir zum Beispiel an, dass die Zeichenfolge, die wir testen, 71955 ist.

Es gibt immer ein Startsymbol (das nicht endständig ist), in der obigen Grammatik ist dies 'S'. Zu diesem Zeitpunkt haben wir keine Zeichen aus unserer Zeichenfolge gelesen:

current pattern                    symbol read
S                                  ε

Nun lesen wir das erste Symbol in unserer Zeichenkette, das '7' ist, und suchen dann in der Grammatik nach einer Regel, die in unserem aktuellen Muster links neben dem '->' ein beliebiges Non-Terminal enthält hat unser Symbol auf der rechten Seite des "->". Zum Glück gibt es eine (S-> 7G), daher ersetzen wir die nicht-terminalen Symbole in unserem aktuellen Muster durch die rechte Seite der neuen Regel:

current pattern                    symbol read
7G                                 7

Jetzt haben wir das nicht-terminale 'G' in unserem Muster und das nächste zu lesende Symbol ist '1'. Deshalb suchen wir in unserer Grammatik nach einer Regel, die mit 'G-> 1 "beginnt. Wir finden, dass es eine gibt (G-> 1F), also ersetzen wir das Nicht-Terminal durch das RHS unserer neuen Regel:

current pattern                    symbol read
71F                                1

Wiederholen Sie diesen Vorgang:

Nächste Regel: F-> 9D

current pattern                    symbol read
719D                               9

Nächste Regel: D-> 5F

current pattern                    symbol read
7195F                              5

Nächste Regel: F-> 5S

current pattern                    symbol read
71955S                             5

Zu diesem Zeitpunkt haben wir keine Symbole mehr in unserer Zeichenfolge, aber wir haben ein anderes nicht-terminales Symbol darin. Wir sehen aus der ersten Regel in der Grammatik, dass wir 'S' durch die leere Zeichenkette (ε) ersetzen können: S-> ε

Auf diese Weise erhalten wir das aktuelle Muster: 71955ε, was 71955 entspricht.

Wir haben alle Symbole in unserer Zeichenfolge gelesen und das Muster enthält keine nicht-terminalen Symbole. Dies bedeutet, dass die Zeichenfolge zur Sprache gehört und daher 71955 tatsächlich durch 13 teilbar ist.

Dh das Ziel ist, pattern = string zu haben. Wenn Sie keine nicht-terminalen Symbole mehr haben, nachdem Sie alle Symbole in Ihrer Zeichenfolge gelesen haben, gehört die Zeichenfolge nicht zur Sprache. Wenn Ihre Zeichenfolge noch mehr zu lesende Symbole enthält, die Grammatik jedoch keine Regeln enthält, nach denen Sie fortfahren können, gehört die Zeichenfolge nicht zur Sprache.