language agnostic - Código de golf: módulo de división
language-agnostic code-golf (29)
Reto:
Sin usar el operador de división de módulo ya provisto por su idioma, escriba un programa que tome dos entradas enteras de un usuario y luego muestre el resultado del primer módulo de número dividido por el segundo número. Supongamos que toda la entrada es positiva.
Ejemplo:
Input of first number:2
Input of second number:2
Result:0
Quién gana:
En caso de que no sepa cómo funciona Code Golf, el ganador es la persona que escribe este programa con la menor cantidad de caracteres.
Bash, 21 caracteres
echo $(($1-$1/$2*$2))
C, 226 caracteres
Entrada tardía: decidí ir por el menor número de caracteres , evitando las operaciones aritméticas por completo . En su lugar, uso el sistema de archivos para calcular el resultado:
#include <stdio.h>
#define z "%d"
#define y(x)x=fopen(#x,"w");
#define g(x)ftell(x)
#define i(x)fputs(" ",x);
main(a,b){FILE*c,*d;scanf(z z,&a,&b);y(c)y(d)while(g(c)!=a){i(c)i(d)if(g(d)==b)fseek(d,0,0);}printf(z,g(d));}
C: 52
main(a,b){scanf("%d%d",&a,&b);printf("%d",a-a/b*b);}
CSS: 107 caracteres :)
CSS (ungolfed):
li {
counter-increment: a;
}
li:after {
content: counter(a);
}
li:nth-child(3n) { /* replace 3 with 2nd input ("b" in "a % b") */
counter-reset: a;
counter-increment: none;
}
HTML adjunto: <ol> <li></li> <li></li> <li></li> <!-- etc. --> </ol>
Salida:
Salida http://img155.imageshack.us/img155/4643/modd.png
Esto no funciona en IE (¡sorpresa sorpresa!).
Esquema: 38
(define(m a b)(- a(*(quotient a b)b)))
F #, 268 caracteres
¿Gané?
printf "Input of first number:"
let x = stdin.ReadLine() |> int
printf "Input of second number:"
let y = stdin.ReadLine() |> int
let mutable z = x
while z >= 0 do
z <- z - y
// whoops, overshot
z <- z + y
// I''m not drunk, really
printfn "Result:%d" z
Golfscript, 6 7 13 caracteres:
2*~/*-
Uso (única forma de ingresar en golfscript):
echo 14 3 | ruby golfscript.rb modulo.gs
2
Explicación:
2*~ #double the input string and eval (so now 14 3 14 3 are on the stack)
/ #int divide 14 / 3, gives quotient
*- #multiply that result by 3, subtract from 14, gives remainder
Haskell, 30 caracteres
m a b=a-last((a-b):[b,2*b..a])
Este es mi primer código de golf, no dudes en comentar sobre el código y publicar mejoras. ;-)
Sé que no ganaré, pero solo quería compartir mi solución utilizando listas.
Java. Solo por diversión
Suponiendo que s[0] s[1] son ints . No estoy seguro de que esto valga nada, pero fue un poco de diversión.
Tenga en cuenta que esto no sufrirá el efecto de bucle (números grandes) sino que solo funcionará en números enteros. Además, esta solución es igual de rápida, no importa cuán grandes sean los números. Un gran porcentaje de las respuestas proporcionadas generará una gran pila recursiva o tomará un tiempo infinitamente largo si se da un gran número y un pequeño divisor.
public class M
{
public static void main(String [] s)
{
int a = Integer.parseInt(s[0]);
int b = Integer.parseInt(s[1]);
System.out.println(a-a/b*b);
}
}
Java: 127 caracteres
import java.util.*;enum M{M;M(){Scanner s=new Scanner(System.in);int a=s.nextInt(),b=s.nextInt();System.out.println(a-a/b*b);}}
Tenga en cuenta que el programa funciona, pero también lanza
Exception in thread "main" java.lang.NoSuchMethodError: main
después de que se ingresan las entradas y después de que se emite la salida.
Respuesta, 5 caracteres
2?/*-
Ejecutar utilizando:
RePeNt mod.rpn 17 3
RePeNt "2?/*-" 17 3
RePeNt es un lenguaje de juguete basado en la pila que hice yo mismo cuando cada operador / comando / bucle se ingresa en Notación Polaca Inversa (RPN). Liberaré al intérprete cuando lo haya ordenado un poco.
Command Explanation Stack
------- ----------- -----
n/a The program takes 2 parameters ( 17 3 ) and pushes them 17 3
onto the stack
2 Pushes a 2 onto the stack 17 3 2
? Pops a number (x) off the stack + copies the last x 17 3 17 3
stack items onto the stack
/ Divides on stack 17 3 5
* Multiplies on stack 17 15
- Subtracts on stack 2
Unefunge-98: 14 13 22 caracteres
&:7p&:'' //*-.@
Unefunge es la instancia unidimensional de Funge-98: http://quadium.net/funge/spec98.html
Explicación (Comando <- Explicación [Pila]):
& <- Get integer input of value A and store on stack.
[A]
: <- Duplicate top of stack.
[A A]
7 <- Push 7 on stack. Used for the `p` command.
[A A 7]
p <- Pop top two values (7 then A). Place the character whose ASCII value
is A at position 7 in the code (where the space is).
[A]
& <- Get integer input of value B and store on stack.
[A B]
: <- Duplicate top of stack.
[A B B]
'' <- Jump over next character and grap the ASCII value of the jumped character.
[A B B A]
<- Because of the `p` command, this is actually the character whose ASCII
value is A at this point in the code. This was jumped over by the
previous instruction.
/ <- Swap top two values of stack.
[A B A B]
/ <- Pop top two values (B then A). Push (A/B) (integer division) onto stack.
[A B (A/B)]
* <- Pop top two values ((A/B) then B). Push (B*(A/B)) onto stack.
[A (B*(A/B))]
- <- Pop top two values ((B*(A/B)) then A). Push (A-(B*(A/B))) onto stack.
[(A-(B*(A/B)))]
. <- Pop top value and print it as an integer.
[]
@ <- Exit program.
El código probado está incompleto (pero lo suficientemente completo) El intérprete de Unefunge-98 que escribí para probar el código:
module Unefunge where
import Prelude hiding (subtract)
import qualified Data.Map as Map
import Control.Exception (handle)
import Control.Monad
import Data.Char (chr, ord)
import Data.Map (Map)
import System.Environment (getArgs)
import System.Exit (exitSuccess, exitFailure, ExitCode (..))
import System.IO (hSetBuffering, BufferMode (..), stdin, stdout)
-----------------------------------------------------------
iterateM :: (Monad m) => (a -> m a) -> m a -> m b
iterateM f m = m >>= iterateM f . f
-----------------------------------------------------------
data Cell = Integer Integer | Char Char
-----------------------------------------------------------
newtype Stack = Stack [Integer]
mkStack = Stack []
push :: Integer -> Stack -> Stack
push x (Stack xs) = Stack (x : xs)
pop :: Stack -> Stack
pop (Stack xs) = case xs of
[] -> Stack []
_:ys -> Stack ys
top :: Stack -> Integer
top (Stack xs) = case xs of
[] -> 0
y:_ -> y
-----------------------------------------------------------
data Env = Env {
cells :: Map Integer Cell
, position :: Integer
, stack :: Stack
}
withStack :: (Stack -> Stack) -> Env -> Env
withStack f env = env { stack = f $ stack env }
pushStack :: Integer -> Env -> Env
pushStack x = withStack $ push x
popStack :: Env -> Env
popStack = withStack pop
topStack :: Env -> Integer
topStack = top . stack
-----------------------------------------------------------
type Instruction = Env -> IO Env
cellAt :: Integer -> Env -> Cell
cellAt n = Map.findWithDefault (Char '' '') n . cells
currentCell :: Env -> Cell
currentCell env = cellAt (position env) env
lookupInstruction :: Cell -> Instruction
lookupInstruction cell = case cell of
Integer n -> pushInteger n
Char c -> case c of
''/'''-> fetch
''//'-> swap
''0'' -> pushInteger 0
''1'' -> pushInteger 1
''2'' -> pushInteger 2
''3'' -> pushInteger 3
''4'' -> pushInteger 4
''5'' -> pushInteger 5
''6'' -> pushInteger 6
''7'' -> pushInteger 7
''8'' -> pushInteger 8
''9'' -> pushInteger 9
'' '' -> nop
''+'' -> add
''-'' -> subtract
''*'' -> multiply
''/'' -> divide
''#'' -> trampoline
''&'' -> inputDecimal
''.'' -> outputDecimal
'':'' -> duplicate
''p'' -> put
''@'' -> stop
instructionAt :: Integer -> Env -> Instruction
instructionAt n = lookupInstruction . cellAt n
currentInstruction :: Env -> Instruction
currentInstruction = lookupInstruction . currentCell
runCurrentInstruction :: Instruction
runCurrentInstruction env = currentInstruction env env
nop :: Instruction
nop = return
swap :: Instruction
swap env = return $ pushStack a $ pushStack b $ popStack $ popStack env
where
b = topStack env
a = topStack $ popStack env
inputDecimal :: Instruction
inputDecimal env = readLn >>= return . flip pushStack env
outputDecimal :: Instruction
outputDecimal env = putStr (show n ++ " ") >> return (popStack env)
where
n = topStack env
duplicate :: Instruction
duplicate env = return $ pushStack (topStack env) env
pushInteger :: Integer -> Instruction
pushInteger n = return . pushStack n
put :: Instruction
put env = return env'' { cells = Map.insert loc c $ cells env''}
where
loc = topStack env
n = topStack $ popStack env
env'' = popStack $ popStack env
c = Char . chr . fromIntegral $ n
trampoline :: Instruction
trampoline env = return env { position = position env + 1 }
fetch :: Instruction
fetch = trampoline >=> /env -> let
cell = currentCell env
val = case cell of
Char c -> fromIntegral $ ord c
Integer n -> n
in pushInteger val env
binOp :: (Integer -> Integer -> Integer) -> Instruction
binOp op env = return $ pushStack (a `op` b) $ popStack $ popStack env
where
b = topStack env
a = topStack $ popStack env
add :: Instruction
add = binOp (+)
subtract :: Instruction
subtract = binOp (-)
multiply :: Instruction
multiply = binOp (*)
divide :: Instruction
divide = binOp div
stop :: Instruction
stop = const exitSuccess
tick :: Instruction
tick = trampoline
-----------------------------------------------------------
buildCells :: String -> Map Integer Cell
buildCells = Map.fromList . zip [0..] . map Char . concat . eols
eols :: String -> [String]
eols "" = []
eols str = left : case right of
"" -> []
''/r'':''/n'':rest -> eols rest
_:rest -> eols rest
where
(left, right) = break (`elem` "/r/n") str
data Args = Args { sourceFileName :: String }
processArgs :: IO Args
processArgs = do
args <- getArgs
case args of
[] -> do
putStrLn "No source file! Exiting."
exitFailure
fileName:_ -> return $ Args { sourceFileName = fileName }
runUnefunge :: Env -> IO ExitCode
runUnefunge = iterateM round . return
where
round = runCurrentInstruction >=> tick
main :: IO ()
main = do
args <- processArgs
contents <- readFile $ sourceFileName args
let env = Env {
cells = buildCells contents
, position = 0
, stack = mkStack
}
mapM_ (`hSetBuffering` NoBuffering) [stdin, stdout]
handle return $ runUnefunge env
return ()
Clojure: 30 caracteres
#(if(>%2%1)%1(recur(-%1%2)%2)))
DC: 7 caracteres (quizás 5;)
??37axp
Utilizado de la siguiente manera:
echo "X/nY" | dc -e "??37axp"
[Y, haciendo referencia a otros ejemplos anteriores, si se permite insertar entradas en el código, puede tener 5 caracteres:
37axp
como en:
dc -e "17 3 37axp"
Solo pensé que vale la pena mencionar]
DC: 8 caracteres
odO/O*-p
$ echo ''17 3 odO/O*-p'' | dc
2
J, 10 caracteres
([-]*<.@%)
Uso:
10 ([-]*<.@%) 3
1
J, 17 caracteres (con entrada como lista)
({.-{:*[:<.{.%{:)
Uso:
({.-{:*[:<.{.%{:) 10 3
1
({.-{:*[:<.{.%{:) 225 13
4
Explicación:
Tomé un tótem y lo convertí en una sonrisa, y funcionó.
JavaScript, 11 caracteres
a-b*(0|a/b)
Se asume que los enteros de entrada están contenidos en las variables a y b :
a = 2;
b = 2;
alert(a-b*(0|a/b)); // => 0
PHP, 49 caracteres
Suponiendo que la cadena de consulta ingresa en forma de script.php?a=27&b=7 y las etiquetas cortas están activadas:
<?echo($a=$_GET[''a''])-(int)($a/$b=$_GET[''b''])*$b;
(Eso podría reducirse en cuatro sacando las comillas simples, pero eso arrojaría avisos).
Con el vile register_globals activado, puedes reducirlo a 25 caracteres :
<?echo $a-(int)($a/$b)*b;
Perl, 33 caracteres
La lectura de las entradas probablemente podría acortarse aún más.
($a,$b)=@ARGV;print$a-$b*int$a/$b
Uso
$ perl -e "($a,$b)=@ARGV;print$a-$b*int$a/$b" 2457 766
159
Python: 25 caracteres
Se comporta con números negativos, idénticamente al operador de módulo. Toma dos números separados por comas.
x,y=input()
print x-x/y*y
Ruby (32):
p(a=gets.to_i)-a/(b=gets.to_i)*b
Ruby: 36 caracteres
a,b=gets.split.map(&:to_i);p a-a/b*b
Rebmu : 10 caracteres (sin E / S) y 15 caracteres (con E / S)
Si no se requiere E / S como parte de la fuente del programa y está dispuesto a pasar los argumentos con nombre, entonces podemos obtener 10 caracteres:
>> rebmu/args [sbJmpDVjKk] [j: 20 k: 7]
== 6
Si se requiere E / S entonces eso lo lleva a 15:
>> rebmu [rJrKwSBjMPdvJkK]
Input Integer: 42
Input Integer: 13
3
Pero usar la multiplicación y división no es tan interesante (o ineficiente) como esta solución de 17 caracteres:
rJrKwWGEjK[JsbJk]
Que bajo el capó se convierte en el equivalente:
r j r k w wge j k [j: sb j k]
Documentado
r j ; read j from user
r k ; read k from user
; write out the result of...
w (
; while j is greater than or equal to k
wge j k [
; assign to j the result of subtracting k from j
j: sb j k
]
; when a while loop exits the expression of the while will have the
; value of the last calculation inside the loop body. In this case,
; that last calculation was an assignment to j, and will have the
; value of j
)
Claro que no ganaré, pero aquí va nada:
<?php
$a=readline("#1:");
$b=readline("#2:");
while($b<=$a)$a-=$b;
echo "Result: $a";
Common Lisp, 170 caracteres (incluyendo sangría):
(defun mod-divide()
(flet((g(p)(format t"Input of ~a number:"p)(read)))
(let*((a(g"first"))(b(g"second")))
(format t "Result:~d~%"(- a(* b(truncate a b)))))))
Versión antigua (187 caracteres):
(defun mod-divide()
(flet((g(p)(format t"Input of ~a number:"p)(read)))
(let*((a(g"first"))(b(g"second")))
(multiple-value-bind(a b)(truncate a b)(format t "Result:~d~%"b)))))
En rubí con 38 caracteres.
p (a=gets.to_i)-((b=gets.to_i)*(a/b))
No es un ganador :(
Java, 110 caracteres
class C{public static void main(String[]a){Long x=new Long(a[0]),y=x.decode(a[1]);System.out.print(x-x/y*y);}}
Sé que ya hay dos respuestas de Ruby, pero ¿por qué no? obtener la entrada de esta manera es un enfoque lo suficientemente diferente como para eliminar algunos caracteres.
Ruby 1.8.7+, 29 caracteres
a,n=*$*.map(&:to_i);p a-a*n/n
$ ruby a.rb 10 3 1
Perl 25 personajes
<>=~/ /;say$`-$''*int$`/$''
uso:
echo 15 6 | perl modulo.pl
3