Matematica a Manhattan

12

Definisco i seguenti operatori:

L'aggiunta di Manhattan a + M b, per i numeri a una cifra, è il risultato della concatenazione di b su a. Quindi, a + M b = 10a + b. Pertanto, l'operatore generale + M è definito in questo modo:

a + M b = 10a + b

Manhattan sottrazione a - M b, per numeri a una cifra, è il risultato della rimozione dell'ultima b da a. Pertanto, l'operatore - M è definito in questo modo nello pseudocodice:

a - M b = a rimuovi l'ultimo b

Manhattan Moltiplicazione a × M b è il risultato della sostituzione di tutte le istanze di b in a con b istanze di b. Ergo, × M è definito in pseudocodice come:

a × M b = a -> s / b / <b copie di b> / g

Manhattan Division a ÷ M b è definita in termini di × M :

1: M b = il primo carattere di b
a ÷ M b = a × M (1 ÷ M b)

Tenendo presente tutto ciò, creare un interprete che valuterà le espressioni infix che utilizzano i seguenti operatori (ovvero a + b, non a b +o + a b)

+    Addition
-    Subtraction
/    Division
*    Multiplication
*M   Manhattan Multiplication
/M   Manhattan Division
+M   Manhattan Addition
-M   Manhattan Subtraction

Ogni operatore di Manhattan ha una precedenza di ordine superiore rispetto alla sua controparte normale.

Casi test:

> 5 +M 10 + 3
63      // 5*10 + 10 + 3 => 60 + 3
> 10 *M 2
10      // no 2s in 10
> 10 *M 1
10      // one 1 in 10 replaced once
> 23 *M 3
2333    // 23 has one 3, which is replaced with three 3s
> 23 *M 2
223     // 23 has one 2, which is replaced with two 2s
> 232 *M 2
22322   // 232 has two 2s, which are replaced with two 2s
> 232 *M 23
23...(23 times)...232   // ...
> 123 *M 2 * 3
3669    // 1223 * 3 => 3669
> 5 + 3 +M 2
37      // 5 + (3 +M 2) => 5 + 32 => 37
> 150 /M 3
150     // 150 ÷M 3 => 150 ×M 3 => 150
> 150 /M 53
1555550 // 150 ÷M 53 => 150 ×M 5 => 1555550
> 50 -M 0
5
> 500 -M 0
50
> 5234 -M 5
234
> 12 +M 633 *M 3
6333453 // = 12 +M 6333333 = 120 + 6333333 = 6333453

Questo è un codice-golf , quindi vince il programma più breve in byte.

Classifiche

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

# Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostra snippet di codice

code-golf  math  number-theory 
— Conor O'Brien
fonte
13
Perché stai usando i simboli Unicode ×e ÷invece di ASCII *e /?
— ASCIIThenANSI,
1
Perché è 232 ×M 23uguale 23232? Non dovrebbe essere uguale a 23 copie di 23seguito da un 2?
— senshin,
1
@ASCIIThenANSI Vedo perché l'hai chiesto. La scelta è arbitraria. A meno che non ci siano problemi urgenti con la mia scelta, non credo che lo cambierò.
— Conor O'Brien,
4
Rende arbitrariamente più difficile la partecipazione delle lingue senza un buon supporto Unicode, il che non è molto divertente, se la sfida non riguarda Unicode.
— Lynn,
2
Questa domanda non ha ricevuto abbastanza attenzione perché non è ben specificata. Definisci l'aggiunta per i numeri delle cifre di sngle, quindi il tuo primo esempio ha numeri di 2 cifre. Mi arrendo ...
— edc65,

Risposte:

5

Dyalog APL , 104 81 79 93 75 byte

Modifica: ora gestisce 4342343 -M 34→ 43423correttamente.

M←{⍎(5|⌊⍺⍺2)⊃'⍺×M⍣(⍺≠1)⍎⊃b'(b⎕R(⍵⍴'&')⊢a)'10⊥⍺⍵'(('(.*)',b←⍕⍵)⎕R'\1'⊢a←⍕⍺)}

sfondo

Ciò estende APL per includere l'operatore di Manhattan. Un operatore nella terminologia APL è un modificatore di funzioni (ad es ÷.). Un esempio di operatore è ⍨che modifica le funzioni per scambiare i loro argomenti in questo modo 3 = 2 ÷⍨ 6. Allo stesso modo, Mmodifica le funzioni aritmetiche di base come parenti di Manhattan. Si noti che poiché la lingua risultante è un'estensione di APL, rimane la rigorosa precedenza da destra a sinistra di APL.

Spiegazione

La struttura generale è M←{⍎(5|⌊⍺⍺2)⊃... }che applica la funzione ( +o -o ×o ÷) a 2 e utilizza il risultato per scegliere quale stringa valutare. Le stringhe sono:

3 per -M: (('(.*)',b←⍕⍵)⎕R'\1'⊢a←⍕⍺)
 regex rimuove l'ultima occorrenza di b (stringa rep. Di arg. Destra) in a (stringa rep. Di arg. Sinistra)

2 per + M: '10⊥⍺⍵'
 valuta gli argomenti come cifre di base 10

1 per × M: (b⎕R(⍵⍴'&')⊢a)
 sostituisce le occorrenze di b con la e commerciale b (ovvero regex per la

0 per ÷ M: '⍺×M⍣(⍺≠1)⍎⊃b'
 ⍎⊃b prima cifra di b
 ⍺×M⍣(⍺≠1) applicata ⍺ × M se ⍺ ≠ 1

⊃ di queste quattro stringhe, seleziona il numero:

(5|⌊⍺⍺2)mod-5 del piano della funzione applicata a 2, ovvero:
 3 = 5 | ⌊-2
 2 = 5 | ⌊+2
 1 = 5 | ⌊×2perché × 2 ⇔ sgn (2) ⇔ 1
 0 = 5 | ⌊÷2perché ÷ 2 ⇔ 1 ÷ 2 ⇔ 0,5

Mille grazie al mio caro amico ngn per i trucioli fantastici.

— Adamo
fonte
1
Questo va bene. Si adatta a ciò che avevo desiderato.
— Conor O'Brien,
Bene, allora modificherò il post.
— Adám,
@ CᴏɴᴏʀO'Bʀɪᴇɴ Potrei aver perso il bonus, ma ora è sicuramente il più breve.
— Adám,
oops, mi sono dimenticato di questo.
— Conor O'Brien,
@ CᴏɴᴏʀO'Bʀɪᴇɴ Hai dimenticato? Ho appena modificato oggi, rendendolo più breve di quello accettato.
— Adám,
12

Perl, 100 99 98 byte

Codice 97 byte + riga comandi 1 byte

s/ |.*\K(\d)(\d*)-M\1|\+M/\2/g+s/(\d+)\*M(.)/$1=~s@$2@$&x$&@erg/e+s#/(M.)\d+#*\1#&&redo,$\=eval}{

Esempio di utilizzo:

echo "123 *M 2 * 3 + 150 /M 53" | perl -p entry.pl
— Jarmex
fonte
Se accorcia il codice, devi solo usare *Mper xMe /Mper <div>M.
— Conor O'Brien,
Congratulazioni per la generosità!
— Conor O'Brien,
7

Python, 644 byte

import operator as o,re
x,q,t,r,w='*/+-M';mm,md,ma,ms='*M /M +M -M'.split()
n=lambda x:x
a=lambda a,b:str(10*int(a)+int(b))
v=lambda a,b:a[::-1].replace(b,'',1)[::-1]
m=lambda a,b:a.replace(b,b*int(b))
d=lambda a,b:m(a,b[0])if a>0 else b[0]
def p(s):s=s.group();ss=s.split();l=s.split(ss[1]);h={mm:m,md:d,ma:a,ms:v,x:o.mul,q:o.div,t:o.add,r:o.sub}.get(ss[1],n);return str(h(*map(int if h in[o.mul,o.div,o.add,o.sub]else n,map(u,map(str.strip,l)))))
def u(s):z=r'\d+ (?:\{0}{2}|\{1}{2}) \d+';return re.sub(z.format(t,r,''),p,re.sub(z.format(t,r,w),p,re.sub(z.format(x,q,''),p,re.sub(z.format(x,q,w),p,re.sub(r'\((.*)\)',u,s)))))
print u(input())

Accetta input su STDIN (racchiuso tra virgolette). Usa regex per abbinare e analizzare le operazioni. Tutto il lavoro viene eseguito sulle stringhe e il casting da e verso gli ints viene utilizzato solo quando si eseguono normali operazioni matematiche.

Sono abbastanza sicuro che questo potrebbe essere ulteriormente approfondito, quindi ci lavorerò nei prossimi giorni.

— Mego
fonte
Non vedo un co f.
— RK.
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.