Cosa ottieni quando moltiplichi 6 per 9? (42)

60

Amo la matematica. Ma non riesco a trovare un singolo calcolatore in grado di moltiplicarsi correttamente. Sembrano che tutto vada bene tranne 6 * 9 (è la domanda alla vita, all'universo e tutto! Come hanno potuto sbagliare ?!). Quindi voglio che tutti voi scriviate una funzione per me che può moltiplicare correttamente 2 numeri (e 6 * 9 è uguale a 42 anziché 54. 9 * 6 è uguale a 54).

Oh, e dovrò costruire la fonte in Minecraft così ... vincono meno byte!

Ricapitolare

  • Prendi 2 numeri come input (il tipo non ha importanza, ma saranno passati solo 2 elementi e l'ordine deve essere coerente. Quindi i flussi e le matrici sono ok fintanto che mantengono l'ordine in cui sono passati. Cioè, una mappa vinta funziona perché non preserva l'ordine)
  • Output multiplo di entrambi i numeri tranne se sono 6 e 9, quindi output 42 (l'ordine conta!)
    • PS. Non sono mai stato molto bravo con il conteggio, quindi penso che solo numeri interi da 0 a 99 siano numeri reali (il tipo usato non ha importanza)
  • Vince il minor numero di byte per lingua!

Classifica:

Mostra snippet di codice

code-golf  arithmetic 
— Tezra
fonte
1
@JonathanAllan Sì, sono state aggiunte regole per questo.
— Tezra,
73
Per coincidenza, l'ID domanda ha 42due volte in esso.
— Erik the Outgolfer,
1
se solo numeri interi fino a 99 sono numeri reali, ad esempio 9 * 11 è un prompt valido ma 10 * 10 no, giusto?
— Dark Wanderer,
14
@EriktheOutgolfer… e il 12 indica cosa sottrarre se l'input è 6 e 9.
— Adám,
11
@EriktheOutgolfer Anche se leggi l'ID al contrario.
— T. Sar - Ripristina Monica il

Risposte:

65

Mathematica, 15 byte

Il conteggio dei byte presuppone la codifica ANSI di Windows (CP-1252).

6±9=42
±n__:=1n

Definisce un operatore binario ±che risolve il problema. Definiamo semplicemente 6±9=42un caso speciale che ha la precedenza e quindi aggiungiamo una definizione di fallback che rende ±uguale alla moltiplicazione. Quest'ultimo utilizza un trucco da golf abbastanza interessante. Il motivo per cui funziona in realtà è piuttosto elaborato e dobbiamo esaminare le sequenze . Una sequenza è simile a ciò che è noto come splat in altre lingue. È fondamentalmente un "elenco" senza alcun wrapper. Ad esempio f[1, Sequence[2, 3, 4], 5]è davvero giusto f[1, 2, 3, 4, 5]. L'altro concetto importante è che tutti gli operatori sono solo zucchero sintattico. In particolare, ±può essere utilizzato come operatore unario o binario e rappresenta la testa PlusMinus. Così ±xè PlusMinus[x]ed a±bè PlusMinus[a,b].

Ora abbiamo la definizione ±n__. Questa è una scorciatoia per la definizione PlusMinus[n__]. Ma n__rappresenta una sequenza arbitraria di argomenti. Quindi questo in realtà aggiunge una definizione anche per l'utilizzo binario (e n-ary) PlusMinus. Il valore di questa definizione è 1n. In che modo questo moltiplica gli argomenti? Bene, 1nusa la moltiplicazione implicita di Mathematica per giustapposizione, quindi è equivalente a 1*n. Ma *è anche solo una scorciatoia per Times[1,n]. Ora, nè la sequenza di argomenti. Quindi, se invochiamo, a±bquesto diventerà effettivamente Times[1,a,b]. E questo è solo a*b.

Penso che sia abbastanza chiaro come questo abuso di sintassi ci consenta di definire un operatore binario usando la sintassi unaria. Ora potremmo anche fare il PlusMinus[2,3,4]calcolo 24(che può anche essere scritto come ±##&[2,3,4]o 2±Sequence[3,4]ma a quel punto sta solo diventando pazzo).

— Martin Ender
fonte
Mi piace particolarmente come questa sia sostanzialmente una patch per la mia "calcolatrice": 3 Per divertimento, funziona anche per *? : 3
— Tezra,
3
@Tezra bene, *è un operatore integrato, quindi dovresti Unprotectaggiungerlo per aggiungere ulteriori definizioni, ma Unprotect[Times];6*9=42dovrebbe funzionare (al momento non è possibile testarlo).
— Martin Ender,
1
Fare questo per l'operatore * è proprio così male ... Lo adoro! >: 3
— Tezra,
1
Come posso votare quando ce ne sono esattamente altri 42?!? Ecco il mio "futuro +1" da assegnare dopo che qualcun altro lo ha rotto! :-)
— The Vee,
1
@MartinEnder Aww; Ma è il più breve Mathematica, e il mio preferito finora. : 3
— Tezra,
25

C, 32 31 29 28 byte

-2 grazie a Digital Trauma
-1 grazie a musicman523

#define f(a,b)a^6|b^9?a*b:42

Abbastanza semplice. Dichiara una funzione macro fche accetta due argomenti ae b.
Se aè 6ed bè 9, ritorna 42. Altrimenti restituisci ax b.

Provalo online!

— MD XF
fonte
2
Utilizzare ^invece di ==e regolare un po 'la logica: #define f(a,b)a^6||b^9?a*b:42- salva 2 byte.
— Digital Trauma,
@DigitalTrauma Cheers: D
— MD XF
1
Penso che puoi usare |invece di ||salvare un altro byte, poiché ha ancora una precedenza inferiore rispetto a^
— musicman523
@ musicman523 Grazie! La modifica.
— MD XF,
1
Dovresti aggiornare anche la tua versione shortC per prendere queste modifiche
— musicman523
17

JavaScript (ES6), 20 byte

x=>y=>x-6|y-9?x*y:42

Spiegazione:

Iff x == 6 e y == 9, x-6|y-9sarà 0 (falsy) e 42 sarà il risultato.

Frammento:

f=

x=>y=>x-6|y-9?x*y:42

console.log(f(6)(9));
console.log(f(9)(6));
Espandi frammento

— Rick Hitchcock
fonte
4
Molto ben fatto; vorrei averci pensato. +1
— Shaggy,
14

Python 2 , 30 29 byte

Grazie a Jonathan Allan per aver salvato un byte!

lambda x,y:x*[y,7][6==x==y-3]

Provalo online!

— Adnan
fonte
2
Salvare un byte utilizzando il fatto che 6 * 7 è 42:lambda x,y:x*[y,7][6==x==y-3]
— Jonathan Allan il
@JonathanAllan Ohh, è pulito! Grazie! :)
— Adnan,
Questa soluzione funziona anche in Python 3
— AMK il
Esattamente quello che ho ottenuto! Non riesco a trovare alcun modo per golf ulteriormente.
— FlipTack,
12

05AB1E , 15 11 9 byte

-4 byte grazie a @Emigna

-2 byte grazie a @Adnan

P¹69SQi42

Provalo online!

Come funziona

P          # multiply input
 ¹         # push first number
  69       # the number 69
    S      # split per character
     Q     # equality for both inputs
       i42 # if so, print 42
           # otherwise print product
— Neil A.
fonte
È possibile salvare 4 byte con‚D96SQi42ëP
— Emigna il
@Emigna huh ... Perché ,all'inizio?
— Neil A.
Associare i 2 ingressi per confrontarli una sola volta come elenco.
— Emigna,
Suppongo che 6Qs9Q*avrebbe funzionato anche per lo stesso numero di byte.
— Emigna,
La modifica del formato di input consente di risparmiare 2 byte:P¹69SQi42
— Adnan,
10

Java (OpenJDK 8) ,24 22 byte

-2 byte grazie a @ OlivierGrégoire

a->b->a==6&b==9?42:a*b

Provalo online!

— Beluga vergognoso
fonte
3
Benvenuti in PPCG! Non so molto di Java, ma potresti rimuovere la System.out.println()chiamata e lasciare che la funzione restituisca il risultato?
— ETHproductions
2
@ LưuVĩnhPhúc non in Java, perché dovrei scrivere (a^6|b^9)==0poiché non esiste un confronto implicito "diverso da 0". Lo snippet di codice risultante sarebbe lungo 27 byte. Comunque, grazie per il suggerimento, e per favore dimmi se ho sbagliato il tuo suggerimento.
— Bashful Beluga,
1
@Riker no, non funziona così in Java. Ad esempio lo snippet int a = 5; if (a) do_some_stuff(); else do_other_stuff();genera un Type mismatch: cannot convert from int to booleanerrore di compilazione. Devono essere creati esplicitamente con valori booleani; fare riferimento a SO e ORACLE .
— Bashful Beluga,
3
È possibile utilizzare currying di risparmiare un byte, e si può sbarazzarsi del punto e virgola in quanto non fa parte del lambda di risparmiare un altro byte: a->b->a==6&b==9?42:a*b.
— Olivier Grégoire il
1
Solo una nota per cui lo 0 non è falso. Java è di tipo sicuro, quindi 0 è un numero intero non un valore booleano e non è consentito il typecasting non sicuro, quindi non è possibile utilizzare valori falsi
— Martin Barker,
6

Rubino, 24 byte

->a,b{a==6&&b==9?42:a*b}
— dkudriavtsev
fonte
a^6|b^9<1potrebbe funzionare come booleano. Difficile da testare sul mio smartphone.
— Eric Duminil,
1
@EricDuminil Sfortunatamente quell'espressione viene analizzata come (((a^6)|b)^9), cioè a.^(6).|(b).^(9), quindi non funzionerà correttamente. a-6|b-9==0funzionerebbe, ma non è più breve.
— Ventero,
@Ventero: non ci ho pensato. Grazie. a,b==6,9sarebbe bello, ma non funziona.
— Eric Duminil,
6

Brain-Flak , 158 154 148 140 138 126 byte

(({}<>)(((([()()()]<>)){})<({}{}({}))>{(()()()){}(<{}>)}{}))([()]{()(<{}>)}{})(({<{}>{}((<>))}{}){}<{}>{<({}[()])><>({})<>}{})

Provalo online!

Spiegazione

Questo codice è piuttosto semplice. Facciamo copie dei primi due oggetti in pila, sottraggiamo 6 dall'uno e 9 dall'altro. Prendiamo quindi noti due valori. Noi andquei valori, moltiplichiamo il risultato per 12. Moltiplica gli input e sottrai i due risultati.

— Mago del grano
fonte
2
Potresti voler capitalizzare note and(o ricominciare a scriverli), leggendo la tua descrizione piuttosto mi ha fatto inciampare.
— MD XF,
6

Factorio, 661 byte, 6 combinatori con 9 connessioni

Esiste un combinatore costante impostato sull'uscita A e B. Cambiarli per impostare l'ingresso.

Stringa di progetto (0.15.18):

0eNrNVm2O2jAQvcv8rEKFvSHLRuqPtrfYCkUhGWAkYkfOGDVCOUBv0bP1JLWTLQuB3U0QbfcPYvzxZt68eYr3sNxaLA0phngPlGlVQfxtDxWtVbr1a1yXCDEQYwEBqLTwUY4Z5WgmmS6WpFLWBpoASOX4HWLRBG8C+EScKr6MIJtFAKiYmLCrpw3qRNliicaleK2SAEpduata+fQObiI+zgKo/R+XIyeDWbcrA18IG71NlrhJd+RuuytPmInby1ucyq+uyFScnPHakWHrVg4VdScmnz2fPzQhjnxQlKlpS4zhk7ugLZd2BCTu0NS8IbXusMvalWgVJyuji4SUA4OYjcWmS606nm31wv8YzI+7SS66axbusHxh1zeITGaJ21C4w41XtyeHHCXH9D+o8eVUjYd3qoY47bc86rWPo158/yze2iCqPtxsmHx3r9ry3E6ylU9cTUv0aITDygwPZaaGeFMgUzbM99NBg/aMegPnV+gxRg6oLtFNZFsjfLhiJB+huZn1B87O7Crr/0Pnfz11vug5/9ePn+/E+2Hf++4beNHV8uzgRWWica6ejnDKiraM5oWXwhtC2CcVDo+FxfAWDfwc3Y9jLv4288cj5qG8IXU3Ie2zKj56xgXgZrNqOURhKGfR/GE6nzfNb7OMaxo=

L'uscita è il segnale Z e deve essere presa dai decisori superiore e inferiore.

Screenshot

— latias1290
fonte
waaa ... la prima volta che vedo mai una risposta factorio in ppcg xD
— V. Courtois,
2
— jimmy23013,
6

Gelatina , 8 7 byte

Vf96SạP

L'input è un array di due numeri interi: prima l'operando di destra, poi quello di sinistra.

Provalo online!

Come funziona

Vf96SạP  Main link. Argument: [b, a]

V        Cast [b, a] to string, then eval the resulting string.
         For [b, a] = [9, 6], this yields 96.
 f96     Filter with 96, yielding [96] if V returned 96, [] otherwise.
    S    Take the sum, yielding either 96 or 0.
      P  Compute the product of [b, a], yielding ba = ab.
     ạ   Compute the absolute difference of the results to both sides.
         When the sum is 0, this simply yields the product.
         However, when [b, a] = [9, 6], this yields 96 - 54 = 42.
— Dennis
fonte
Questo ha un grado di libertà pari a -1. Come ti vengono in mente queste coincidenze?
— lirtosiast
5

Factorio, 581 byte, 3 combinatori con 4 connessioni

Stringa di progetto (0.16.36):

0eNqllNtu4jAQht9lLldmldNCFWkvto/RCkUhGWAkYkfOGDVCefeOnV1Km7ACemPJ9vibf04+webgsLWkGfITUGV0B/nrCTra6fLgz7hvEXIgxgYU6LLxO2/HpeZFZZoN6ZKNhUEB6RrfII+HtQLUTEw44sKmL7RrNmjF4AyqsaIa7SVHQWs6eWq0dy+46OcvBT3ki1hc1GSxGi8T5XWwNYdig/vySPJYXvxFFnJXB0znT7dkOy4mYR3JspOTs6DRYoFHtD3vSe98XP/CFZ9xtsqe0mW29KdNW9qgOYffgjCOW3eHk+eR3fai1WkuttY0BWlhQM7W4TC61mPAIYzYLxbry6yS7FKxJFs54rANFdhZRP3VMBnWQk08ZvZ+ChpExqSCyX9bYVLCRfxRwbmabenAaK+03rX0/RnT5z7VJbroQnUH7HkGlq7OsDFtc8WYzWJ8WxbTs4rSEu8bZKpuGoXopkn4gH5vGEKiO/SMO5vbtCgDEjTCjwcm5AWGO4ZgknX16Tq7OhRfHiZXypU91PTRd6ZYdIjo8PnmF3+1AvmfuuBq+bRKYmnWKM2G4R1hAPnz

Il combinatore di costanti in basso a sinistra deve essere impostato sulle uscite A e B come input. L'uscita è il segnale Z dal combinatore aritmetico in basso a destra.

enter image description here

Top left: 2147483640 A, 2147483637 B
Top right: If everything = 2147483646 output B, input count
Bottom left: (input) A, (input) B
Bottom right: A * B -> Z
— jimmy23013
fonte
5

MATL , 11 byte

[BE]=?42}Gp

L'input è un array con i due numeri.

Provalo online!

Spiegazione

[BE]    % Push array [6, 9]
=       % Implicit input: array of two numbers. Compare with [6, 9] element-wise
?       % If the two entries are true
  42    %   Push 42
}       % Else
  G     %   Push input
  p     %   Product of array
        % Implicit end. Implicit display
— Luis Mendo
fonte
4

GW-BASIC , 55 byte

1INPUT A:INPUT B
2IF A=6THEN IF B=9THEN ?"42":END
3?A*B

Produzione:

output

La prima macchina di pcjs ha IBM BASIC, che è praticamente la stessa cosa. Per provarlo, vai laggiù, premi Runsulla macchina, premi Enter- Entere digita BASICAper entrare in modalità BASIC. Quindi inserisci il codice sorgente (verrà automaticamente stampato per te), digita RUN, inserisci due numeri interi e il gioco è fatto!

— MD XF
fonte
3
Sei sicuro che il bytecount sia corretto? GW-BASIC usa una codifica in cui alcune parole, come INPUT, sono codificate in meno byte di quanto suggeriscano i caratteri che le compongono. Il conteggio quindi mi sembra elevato.
@ ais523 Beh, l'ho passato wce ho ottenuto 55 ... Copia-incollato nel mio emulatore e aveva il comportamento previsto.
— MD XF,
3
Bene, il mio punto è che probabilmente stai segnando la tua richiesta più in alto di quanto deve essere. Ottieni GW-BASIC per salvare il file, quindi osserva le dimensioni del file risultante sul disco; dovrebbe essere più piccolo.
@ ais523 Salvato come OUT.BAS: i.stack.imgur.com/32eH1.png Bytecount è il valore medio.
— MD XF,
OK, non me lo aspettavo, ma immagino che sia una lavata in questa situazione. (O forse c'è più di un formato di salvataggio?)
4

Controllare , 34 33 byte

.:+&>#v
#>42#v#9-!\>6-!*?
 d* ##p

Check è il mio nuovo esolang. Utilizza una combinazione di semantica 2D e 1D.

L'input è costituito da due numeri passati attraverso gli argomenti della riga di comando.

Spiegazione

Lo stack inizia con gli argomenti della riga di comando su di esso. Chiamiamo gli argomenti ae b.

La prima parte, .:+&essenzialmente, duplica lo stack, lasciandolo come a, b, a, b. >spinge 0 nello stack (fa parte di un valore letterale numerico completato da 9).

#passa alla semantica 2D e vreindirizza l'IP verso il basso. L'IP si imbatte immediatamente in a #, che ritorna nuovamente alla semantica 1D.

9-!controlla se bè uguale a 9 (sottraendo 9 e prendendo il NOT logico). \>6-!quindi controlla se aè uguale a 6. Lo stack ora contiene a, b, 1, 1se e solo se b==9e a==6. La moltiplicazione con *prende l'AND logico di questi due valori, dando a, b, 1se gli input fossero 6e 9, ea, b, 0 altrimenti.

Successivamente, l'IP si imbatte in a ? . Questo passerà alla modalità 2D se il valore di stack superiore è diverso da zero e in caso contrario continuerà in modalità 1D.

Se il valore dello stack superiore era 1, ciò significa che gli altri valori dello stack sono 6e 9, quindi spingiamo 42 nello stack con >42e quindi passiamo al secondo# sull'ultima riga.

Se il valore dello stack superiore era 0, quindi l'esecuzione passa alla riga successiva. drimuove il 0(in quanto ?non lo fa), quindi moltiplichiamo i due input con *. Il## interruttori dentro e fuori della modalità 2D, non fare nulla.

I rami ora si sono uniti di nuovo. La pila contiene 6, 9, 1, 42o a*b. pstampa il valore dello stack superiore e quindi il programma termina, scartando il resto dello stack.

— Esolanging Fruit
fonte
Sembra un linguaggio elegante!
— Non un albero il
3

JavaScript (ES6), 25 byte

x=>y=>[x*y,42][x==6&y==9]
— ispido
fonte
3

Python 3 , 36 33 byte

lambda x,y:42if x==6==y-3else x*y

Provalo online!

— Martmists
fonte
1
Versione alternativa, stessa dimensione: lambda x:x[0]*x[1]if x!=(6,9)else 42. L'unica differenza è il tipo di input.
— musicman523,
Nevermind - la tua versione modificata è più breve :)
— musicman523
Il codice che hai pubblicato in realtà non funziona, quindi l'ho passato alla versione funzionante su TIO a cui ti sei collegato.
— ETHproductions
Funziona per me: In [1]: f = lambda x, y: 42if 6 == x == y-3else x * y In [2]: f (6,9) Out [2]: 42 In [3 ]: f (9,6) Out [3]: 54 @ETHproductions
— Martmists
@Martmists Allora ti mancava uno spazio, perché il tuo codice eraf=lambda x,y:42if6==x==y-3else x*y
— ETHproductions
3

APL (Dyalog) , 10 byte

×-12×6 9≡,

Provalo online!

× il prodotto (degli argomenti)

- meno

12× dodici volte

6 9≡ se (6,9) è identico a

, la concatenazione (degli argomenti)

— Adamo
fonte
Oh wow, l'ho appena visto e la mia risposta J è esattamente la stessa di questa: / tranne un byte in più
— Conor O'Brien,
@ ConorO'Brien Ha senso. J e tacit APL sono per lo più equivalenti, salvo per i primitivi multi-carattere di J (e che necessitano di Cap per un finale in cima).
— Adám,
3

R, 41 Penso di non sapere come contare i byte Sono nuovo: D

function(a,b){

if(a==6&b==9){42} else {a*b}

}

Definisco una funzione i cui argomenti sono aeb in questo ordine . Se a è uguale a 6 e b è uguale a 9, restituisce 42, altrimenti a a b

— R17
fonte
Benvenuti nel sito! :)
— DJMcMayhem
Benvenuto. Tieni conto che contano anche le nuove righe e gli spazi. Nel tuo caso, se rimuovi newline e spazi (che puoi) sono solo 41.
— Masclins
1
Puoi tagliare due byte usandoifelse(a==6&b==9,42,a*b)
— Masclins il
È possibile ridurre il tutto a 33 byte come function(a,b)`if`(a-6|b-9,a*b,42).
— rturnbull,
Questo è solo 41 byte dopo aver rimosso lo spazio bianco non necessario, unil quindi, è 47 byte.
— Pavel,
3

SPL , 356 byte

a.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]Ajax:Listen to your heart!Puck:Listen to your heart!Are you as big as the sum of a big big big cat and a cat?If so, am I as big as the sum of a big big cat and a big cat?If so, you are as big as the product of I and the sum of I and a cat.If not, you are as big as the product of you and I.Open your heart

Con newline e spazi:

a.                       *Title*
Ajax,.                   *Declare variable Ajax*
Puck,.                   *Declare variable Puck*
Act I:.
Scene I:.
[Enter Ajax and Puck]
Ajax: Listen to your heart!                  *Set Puck's value to user input*
Puck: Listen to your heart!                  *Set Ajax's value to user input*
      Are you as big as the sum of a big 
       big big cat and a cat?                *Is Ajax=9?* 
      If so, am I as big as the sum of a 
       big big cat and a big cat?            *Is Puck=6?* 
      If so, you are as big as the product 
       of I and the sum of I and a cat.      *If so, set Ajax=42* 
      If not, you are as big as the product 
       of you and I.                         *If not set Ajax=(Ajax)(Puck)*
      Open your heart                        *Print Ajax's value*
— William Taylor
fonte
3

ML standard (MLton) , 22 20 byte

Salvato 2 byte grazie a @Laikoni!

fun$6 $9=42| $x y=x*y

Provalo online!

Questo è il tipo di cosa per cui è destinato SML, motivo per cui batte C e Python.

La vecchia versione sembrava molto più bella. : P

— musicman523
fonte
— Laikoni,
@Laikoni Wow, non avevo idea che potresti usare $come identificatore! Perché questa compilazione non viene rimossa se si rimuove lo spazio tra |e $?
— musicman523,
SML distingue identificatori alfanumerici e simbolici , che possono essere molto utili per il golf. |$viene analizzato come un singolo identificatore simbolico, quindi tutto si rompe. Ho intenzione di scrivere presto una domanda di suggerimenti per SML e aggiungere una risposta su questi due tipi di identificatori.
— Laikoni,
2

Pyth, 12 byte

-*FQ*12q(6 9

Provalo online

Spiegazione

 -*FQ*12q(6 9
  *FQ             Take the product
        q(6 9)Q   Check if the (implicit) input is (6, 9)
 -   *12          If so, subtract 12
— Mnemonico
fonte
Soluzione intelligente. L'ho provato con dichiarazioni ternarie in 15:AQ?&q6Gq9G42*GH
— Tornado547
2

Retina , 36 byte

^6 9$
6 7
\d+
$*
1(?=1* (1+))|.
$1
1

Provalo online! Moltiplicazione unaria standard, modifica semplicemente l'input per gestire il caso speciale.

— Neil
fonte
2

Gelatina , 10 byte

⁼6,9ȧ42ȯ⁸P

Un collegamento monadico che prende un elenco dei due numeri.

Provalo online!

Come?

⁼6,9ȧ42ȯ⁸P - Link: list of numbers [a,b]
 6,9       - 6 paired with 9, [6,9]
⁼          - equals? (non-vectorising) (1 or 0)
     42    - literal answer, 42
    ȧ      - logical and               (42 or 0)
        ⁸  - link's left argument, [a,b]
       ȯ   - logical or                (42 or [a,b])
         P - product                   (42 or a*b)
— Jonathan Allan
fonte
Avresti potuto usare ?, come ho fatto io. ;)
— Erik the Outgolfer,
Ah perché ,è speciale in quanto fa parte del modello letterale regex, quindi 6,9viene analizzato come un singolo token e il veloce $può combinarlo con ⁼. Lo hai ragionato, o semplicemente provalo e noti che ha funzionato?
— Jonathan Allan,
1
L'ho ragionato.
— Erik the Outgolfer,
2

SILOS , 81 67 byte

readIO
J=i
readIO
a=(J-6)^2+(i-9)^2
a/a
a-1
a*12
x=J*i+a
printInt x

Provalo online!

In un certo senso, l'aggiunta funziona come un'interessante porta NAND in SILOS.

-14 byte grazie a @Leaky Nun

In sostanza creiamo un numero "a" che è 0 (falsa) se j è 6 e i = 9, quindi lo dividiamo per sottrarre uno e lo moltiplichiamo per 12 al fine di aggiungere al nostro prodotto.

Se "a" era 1 dopo aver sottratto uno e moltiplicato, diventa un no-op, tuttavia nel caso in cui a sia 0, 0/0 genera silenziosamente un errore (che viene catturato magicamente) a diventa 0, e quindi diventa -1 e finiamo per sottrarre 12 dal nostro prodotto.

— Rohan Jhunjhunwala
fonte
— Leaky Nun
— Perdente suora
@LeakyNun ooh, è intelligente.
— Rohan Jhunjhunwala,
In realtà, 0/0diventa 0.
— Leaky Nun,
@LeakyNun Volevo dire che diventa 0, e quindi diminuito. Fissaggio.
— Rohan Jhunjhunwala,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.