Garciat

from fractions import Fraction

def fraccionalizar(mat):
	for f in xrange(len(mat)):
		for c in xrange(len(mat[0])):
			mat[f][c] = Fraction(mat[f][c])
	return mat

def mostrar(mat):
	for f in mat:

Garciat

/*

La primera idea que se me vino a la mente para
http://channel9.msdn.com/Events/GoingNative/2013/The-Way-of-the-Exploding-Tuple

No recomendaria su uso, pero es otra forma de atacar al reto.

*/
#include <cstring>
#include <tuple>

Garciat

#include <utility>
#include <typeinfo>

struct Base {
	virtual int f() = 0;
};

struct Derived1 : public Base {
	virtual int f() final override {
		return 42;

Garciat

import std.stdio, std.typetuple, std.traits;

template maxexp(T, uint base, T acc = T.max, uint i = 0)
	if (isIntegral!T && base > 1)
{
	static if (acc == 0)
	{
		enum maxexp = i - 1;
	}
	else

Garciat

#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

long ntimes = 0;
char data[] = {'0', '1'};

// llamadas de sistemas utilizadas:
// write, pthread_create, pthread_join, pthread_exit, exit

Garciat

data State = Q1 | Q2 deriving Show
data Sigma = Zer | One | Cee | Nan deriving Show
data Gamma = R | B | G deriving Show

delta _ _ [] = error "Finished!"

delta Q1 Zer (R:p) = (Q1, B:R:p)
delta Q1 Zer (B:p) = (Q1, B:B:p)
delta Q1 Zer (G:p) = (Q1, B:G:p)

Garciat

{-# LANGUAGE TypeFamilies #-}

import Control.Monad (mzero)

class Pushdown m where
  data State m :: *
  data Sigma m :: *
  data Gamma m :: *
  
  startState :: State m

Garciat

# iterable class

class naturals(object):
    def __init__(self, top):
        assert top >= 1, 'top >= 1'
        
        self._cur = 1
        self._top = top
    
    def __iter__(self):

Garciat

# hello.

def myrange(a, b):
    r = []
    while a < b:
        r.append(a)
        a += 1
    return r

for x in myrange(0, 10):

Garciat

module Program() =
  let main argv =
    printfn "%A" argv