DouKaku? Language detail: Python

pythonなので、未定義の symmetric_groupとsignatureだけ書きました。なんかイマイチ……

def permutations(xs):
    if not xs: yield []
    for i, x in enumerate(xs):
        for ys in permutations(xs[:i] + xs[i+1:]):
            yield [x] + ys

symmetric_group = lambda n: list(permutations(range(n)))

def signature(sym):
    v, count = sym[:], 1
    for i in range(len(sym) - 1):
        for j in range(len(sym) - 1, i, -1):
            if v[j] < v[j-1]:
                v[j],v[j-1] = v[j-1],v[j]
                count *= -1
    return count

島の数をカウントする (Nested Flatten)

# -*- coding: utf-8 -*-

from random import randint

m, n = 4, 3

A = ''.join([''.join([u'□' if randint(0, 1) else u'■' for j in range(n)])+'\n' for i in range(m)])

a = [[0 if A[i*(n+1)+j] == u'□' else 1 for j in range(n)] for i in range(m)]
#for i in a:
#  print i

def f(i, j):
  k = a[i][j]
  a[i][j] = -1
  if i > 0 and a[i-1][j] == k: f(i-1, j)
  if j > 0 and a[i][j-1] == k: f(i, j-1)
  if i < m-1 and a[i+1][j] == k: f(i+1, j)
  if j < n-1 and a[i][j+1] == k: f(i, j+1)

r = [0, 0]
for i in range(m):
  for j in range(n):
    if a[i][j] != -1:
      r[a[i][j]] += 1
      f(i, j)

print A
print 'white: %d\nblack: %d' % tuple(r)

行列式の計算 (Nested Flatten)

n×nの2次元配列を引数にとり、これを行列とみなして行列式を返す関数を作成してください。

行列・線形代数のライブラリ等を使用しないことが条件です。

参考：http://ja.wikipedia.org/wiki/%E8%A1%8C%E5%88%97%E5%BC%8F

# -*- coding: utf-8 -*-

#   定義に基づく実装例


#   対称群
def symmetric_group(n):
    #   配列 [0, 1, .., (n-1)] を並び替えてできる
    #   すべての配列の組み合わせを返します。

#  置換の符号
def signature(sym):
    #   配列 [0, 1, .., (n-1)] の符号を +1とします。
    #   互換（2つの要素を交換）すると符合が変わります。
    #   配列 [0, 1, .., (n-1)] から
    #   奇数回の互換で得られる配列の符号は -1、
    #   偶数回の互換で得られる配列の符号は +1 になります。

#  行列式
def determinant(mat):
    det = 0;
    deg = len(mat)
    for s in symmetric_group(deg):
        term = signature(s)
        for i in range(deg):
            term *= mat[i][s[i]]
        det += term
    return det

inline/embeded bytecode assembly (Nested Flatten)

marshal.dumps(compile(duff, "<script>", "single")) とかやって生成させたバイト列にコメントをつけただけです。こんなんじゃダメっすよねえ……

Pythonバイトコードアセンブラのようなものはあるようですね。ディスアセンブルは標準のdisでできるのですが。

#!/usr/bin/env python
import marshal

# def duff(src):
#     next = iter(src).next
#     while True:
#         yield next()
#         yield next()
#         yield next()
#         yield next()
#         yield next()
#         yield next()
#         yield next()
#         yield next()

exec marshal.loads(
"\x63"              # TYPE_CODE
"\x00\x00\x00\x00"  #   co_argcount: 0
"\x00\x00\x00\x00"  #   co_nlocals: 0
"\x01\x00\x00\x00"  #   co_stacksize: 1
"\x40\x00\x00\x00"  #   co_flags
"\x73"              #   co_code: TYPE_STRING
"\x0D\x00\x00\x00"  #   length of string: 13
"\x64\x00\x00"      #     LOAD_CONST 0
"\x84\x00\x00"      #     MAKE_FUNCTION 0
"\x5A\x00\x00"      #     STORE_NAME 0
"\x64\x01\x00"      #     LOAD_CONST 1
"\x53"              #     RETURN_VALUE
"\x28"              #   co_consts: TYPE_TUPLE
"\x02\x00\x00\x00"  #   length of tuple: 2
"\x63"              #     TYPE_CODE
"\x01\x00\x00\x00"  #       co_argcount: 1
"\x02\x00\x00\x00"  #       co_nlocals: 2
"\x02\x00\x00\x00"  #       co_stacksize: 1
"\x63\x00\x00\x00"  #       co_flags
"\x73"              #       co_code: TYPE_STRING
"\x62\x00\x00\x00"  #       length of string: 98
"\x74\x00\x00"      #         LOAD_GLOBAL 0
"\x7C\x00\x00"      #         LOAD_FAST 0
"\x83\x01\x00"      #         CALL_FUNCTION 1
"\x69\x01\x00"      #         LOAD_ATTR 1
"\x7D\x01\x00"      #         STORE_FAST 1
"\x78\x4C\x00"      #         SETUP_LOOP 76
"\x74\x02\x00"      #         LOAD_GLOBAL 2
"\x6F\x44\x00"      #         JUMP_IF_FALSE 68
"\x01"              #         POP_TOP
"\x7C\x01\x00"      #         LOAD_FAST 1
"\x83\x00\x00"      #         CALL_FUNCTION 0
"\x56"              #         YIELD_VALUE
"\x01"              #         POP_TOP
"\x7C\x01\x00"      #         LOAD_FAST 1
"\x83\x00\x00"      #         CALL_FUNCTION 0
"\x56"              #         YIELD_VALUE
"\x01"              #         POP_TOP
"\x7C\x01\x00"      #         LOAD_FAST 1
"\x83\x00\x00"      #         CALL_FUNCTION 0
"\x56"              #         YIELD_VALUE
"\x01"              #         POP_TOP
"\x7C\x01\x00"      #         LOAD_FAST 1
"\x83\x00\x00"      #         CALL_FUNCTION 0
"\x56"              #         YIELD_VALUE
"\x01"              #         POP_TOP
"\x7C\x01\x00"      #         LOAD_FAST 1
"\x83\x00\x00"      #         CALL_FUNCTION 0
"\x56"              #         YIELD_VALUE
"\x01"              #         POP_TOP
"\x7C\x01\x00"      #         LOAD_FAST 1
"\x83\x00\x00"      #         CALL_FUNCTION 0
"\x56"              #         YIELD_VALUE
"\x01"              #         POP_TOP
"\x7C\x01\x00"      #         LOAD_FAST 1
"\x83\x00\x00"      #         CALL_FUNCTION 0
"\x56"              #         YIELD_VALUE
"\x01"              #         POP_TOP
"\x7C\x01\x00"      #         LOAD_FAST 1
"\x83\x00\x00"      #         CALL_FUNCTION 0
"\x56"              #         YIELD_VALUE
"\x01"              #         POP_TOP
"\x71\x12\x00"      #         JUMP_ABSOLUTE 18
"\x01"              #         POP_TOP
"\x57"              #         POP_BLOCK
"\x64\x00\x00"      #         LOAD_CONST 0
"\x53"              #         RETURN_VALUE
"\x28"              #       co_consts: TYPE_TUPLE
"\x01\x00\x00\x00"  #       length of tuple: 1
"\x4E"              #         TYPE_NONE
"\x28"              #       co_names: TYPE_TUPLE
"\x03\x00\x00\x00"  #       length of tuple: 3
"\x74"              #         TYPE_INTERNED
"\x04\x00\x00\x00"  #         length of string: 4
"\x69\x74\x65\x72"  #           "iter"
"\x74"              #         TYPE_INTERNED
"\x04\x00\x00\x00"  #         length of string: 4
"\x6E\x65\x78\x74"  #           "next"
"\x74"              #         TYPE_INTERNED
"\x04\x00\x00\x00"  #         length of string: 4
"\x54\x72\x75\x65"  #           "True"
"\x28"              #       co_varnames: TYPE_TUPLE
"\x02\x00\x00\x00"  #       length of tuple: 2
"\x74"              #         TYPE_INTERNED
"\x03\x00\x00\x00"  #         length of string: 3
"\x73\x72\x63"      #           "src"
"\x52"              #         TYPE_STRINGREF
"\x01\x00\x00\x00"  #         index: 1
"\x28"              #       co_freevars: TYPE_TUPLE
"\x00\x00\x00\x00"  #       length of tuple: 0
"\x28"              #       co_cellvars: TYPE_TUPLE
"\x00\x00\x00\x00"  #       length of tuple: 0
"\x73"              #       co_filename: TYPE_STRING
"\x08\x00\x00\x00"  #       length of string: 8
"\x3C\x73\x63\x72\x69\x70\x74\x3E"   # "<script>"
"\x74"              #       co_name: TYPE_INTERNED
"\x04\x00\x00\x00"  #       length of string: 4
"\x64\x75\x66\x66"  #         "duff"
"\x02\x00\x00\x00"  #       co_firstlineno: 2
"\x73"              #       co_lnotab: TYPE_STRING
"\x14\x00\x00\x00"  #       length of string: 20
"\x00\x01\x0F\x01\x0A\x01\x08\x01"    # XXX: see codeobject.c
"\x08\x01\x08\x01\x08\x01\x08\x01"    # about co_lnotab.
"\x08\x01\x08\x01"                    #
"\x4E"              #     TYPE_NONE
"\x28"              #   co_names: TYPE_TUPLE
"\x01\x00\x00\x00"  #   length of tuple: 1
"\x52"              #     TYPE_STRINGREF
"\x04\x00\x00\x00"  #     index: 4
"\x28"              #   co_varnames: TYPE_TUPLE
"\x00\x00\x00\x00"  #   length of tuple: 0
"\x28"              #   co_freevars: TYPE_TUPLE
"\x00\x00\x00\x00"  #   length of tuple: 0
"\x28"              #   co_cellvars: TYPE_TUPLE
"\x00\x00\x00\x00"  #   length of tuple: 8
"\x73"              #   co_filename: TYPE_STRING
"\x08\x00\x00\x00"  #   length of string: 8
"\x3C\x73\x63\x72\x69\x70\x74\x3E"   # "<script>"
"\x73"              #   co_name: TYPE_STRING
"\x08\x00\x00\x00"  #   length of string: 8
"\x3C\x6D\x6F\x64\x75\x6C\x65\x3E"   # "<module>"
"\x02\x00\x00\x00"  #   co_firstlineno: 2
"\x73"              #   co_lnotab: TYPE_STRING
"\x00\x00\x00\x00"  #   length of string: 0
)

print list(duff(range(10)))

疑似並行処理 (Nested Flatten)

スレッドを使わない擬似並行処理です。
一行Pythonで119 bytes.

一行にするとループやgeneratorが使えないため、
lambdaのリストを巡回することで代用しています。

1 2	import sys;F=lambda x:(lambda:sys.stdout.write(chr(x))); [[p()for p in q]for q in [(F(i+48),F(i+65))for i in range(10)]]

いちおう擬似並行処理といえるかな。

def f(s):
  for i in s:
   print i,
   yield i

def run(ths):
  while ths:
    for th in ths:
      try:
        th.next()
      except StopIteration:
        ths.remove(th)

run([f('ABCDEFGHIJ'), f(range(1,11))])

ちょっと修正
無駄にめんどくさい事してた・・orz

if __name__ == '__main__':
  strArr = [range(1,10), 'ABCDEFGHIJ']                                           
  for str in strArr:
    p = Process(target = printStr, args=(str,))
    p.start()

1-10とA-Jのスマートな書き方がわからなかった。
sleep(0.01)を入れて、交互になるようにしてあります。
そうしないと、2つめのプロセス作る前に
Print終わってしまう気がする。＜交互にならない

#!/usr/bin/env python                                                            
# coding:utf-8

from multiprocessing import Process
import time
def printStr(str):
  for i in str:
    print i
    time.sleep(0.01) # 出力を緩慢に

if __name__ == '__main__':                                                       
  strArr = [[i for i in range(1,10)],
                ['A','B','C','D','E','F','G','H','I','J']]
  for str in strArr:
    p = Process(target = printStr, args=(str,))
    p.start()

import stackless

def put_iterator(it):
    for i in it:
        print i
        stackless.schedule()

stackless.tasklet(put_iterator)('ABCDEFGHIJ')
stackless.tasklet(put_iterator)(range(1,11))

stackless.run()

import threading
import time

def p(x):
    print x
    time.sleep(0.001)

threads = [ threading.Thread(target=lambda ls: map(p, ls), args=(ls,))
            for ls in (range(1,11), "ABCDEFGHIJ")]
for th in threads: th.start()
for th in threads: th.join()

漢数字で九九の表 (Nested Flatten)

さらに縮めて282bytes.
埋め込みSJIS文字列の持たせ方を変えました。

1
2
3

S,I,Z='  ',True,ord;A=Z(' ');P,F=range(Z('*')-A),lambda h,l:chr((Z(h)-A)*(A>>I)+Z(l)-A);
Q,T=P[I:],[F(a,b)+F(c,d)for(a,b,c,d)in'(!%* ((.* )#/! (.$/ (.&, (,-, )(%* (.+% )$** (+.#'.split()];
print'\n'.join([S.join([[([S]+T[I:])[m]+T[n]for m in P for n in P][i*j]for i in Q])for j in Q])

UTF-8なPython使いへの嫌がらせか！と思ったら、
# coding: UTF
でUTF-8認識してくれるらしいですね。
http://www.python.jp/doc/2.4/lib/standard-encodings.html
の「別名」欄にあったのでやってみたらできました。

index使うのはズルいですかねぇ。

#!/usr/bin/python
# encoding: UTF

num_ten = u"　一二三四五六七八九"
num_one = u"〇一二三四五六七八九"

nums = [i+j for i in num_ten for j in num_one]

for i in num_ten[num_ten.find(u"一"):]:
        for j in num_one[num_one.find(u"一"):]:
                print nums[num_ten.index(i)*num_one.index(j)],
        print ""

'('と')'の対応 (Nested Flatten)

入力の'('と')'の対応をとってください。

ただし、コード中に'('と')'を含まないでください。

漢字の九九にinspireされました。

import sys
start = sys.argv[1]
end = sys.argv[2]
to_test = sys.argv[3]
print start
print end
print to_test

stack = []
while to_test:
  print stack
  head = to_test[0]
  to_test = to_test[1:]
  if head == start:
    stack += [head]
  if head == end:
    if stack:
      stack = stack[:-1]
    else:
      stack = [True]
      break
if stack:
  print False
else:
  print True

世界時計 (Nested Flatten)

http://www.python.jp/doc/2.4/lib/module-datetime.html

必要な詳細仕様を備えたタイムゾーン機能を提供するのはアプリケーションの責任です。世界各国における時刻の修正に関する法則は合理的というよりも政治的なものであり、全てのアプリケーションに適した標準というものが存在しないのです。

というわけで、 http://www.python.jp/doc/2.4/lib/datetime-tzinfo.html にある http://www.python.jp/doc/2.4/lib/tzinfo-examples.txt をtzinfoexample.pyとしてimportする。

実行結果

2008-10-29 23:03:41.965442

2008-10-29 14:03:41.965468

2008-10-29 06:03:41.965479-08:00

import datetime
from tzinfoexamples import Pacific
print datetime.datetime.now()
print datetime.datetime.utcnow()
print datetime.datetime.now(Pacific)

漢数字で九九の表 (Nested Flatten)

結果はブラウザで閲覧します。

#!/usr/bin/python
# -*- coding=us-ascii-*-

def zero():
    return len(())
def succ(n):
    return n+len(((),))

ZERO = zero()
ONE = succ(ZERO)
TWO = succ(ONE)
THREE = succ(TWO)
FOUR = succ(THREE)
FIVE = succ(FOUR)
SIX = succ(FIVE)
SEVEN = succ(SIX)
EIGHT = succ(SEVEN)
NINE = succ(EIGHT)

K_ZEOR = (ONE,TWO,TWO,NINE,FIVE)
K_ONE = (ONE,NINE,NINE,SIX,EIGHT)
K_TWO = (TWO,ZERO,ONE,ZERO,EIGHT)
K_THREE = (ONE,NINE,NINE,SEVEN,SEVEN)
K_FOUR = (TWO,TWO,TWO,THREE,FIVE)
K_FIVE = (TWO,ZERO,ONE,ONE,SIX)
K_SIX = (TWO,ZERO,EIGHT,FOUR,FIVE)
K_SEVEN = (ONE,NINE,NINE,SEVEN,ONE)
K_EIGHT = (TWO,ZERO,EIGHT,FOUR,THREE)
K_NINE = (TWO,ZERO,ZERO,SIX,ONE)

KANJI_NUMS = (K_ZEOR, K_ONE, K_TWO, K_THREE, K_FOUR, 
              K_FIVE, K_SIX, K_SEVEN, K_EIGHT, K_NINE)

BASE = len(KANJI_NUMS)

def tuple_to_code(t):
  return '&#' + ''.join(['%i'%s for s in t]) + ';'

def alabic_to_jp(alabic):
  d, m = divmod(alabic, BASE)
  if d:
    return alabic_to_jp(d) + tuple_to_code(KANJI_NUMS[m])
  else:
    return tuple_to_code(KANJI_NUMS[m])

print "<html><table>"
for i in range(BASE):
  print "<tr>",
  for j in range(BASE):
    if i and j:
      print "<td>", alabic_to_jp(i*j), "</td>",
  print "</tr>"
print "</table></html>"

alabic_to_jpをalabic2jpと書いていた自分を発見して吹きそうになった。

succとentity referenceを利用したコードも着想はしたが面倒なのでやめた。

def succ(n):
return n + len(((),))
を作って、%sで数字の文字列を作り、結果はブラウザでみるということです。
「〇一二三四五六七八九」を埋め込まなくてすみますが、code generatorでも作らないとbfすぎ。

#!/usr/bin/python
# -*- coding=sjis -*-

JP_NUMERIC_LETTERS = u'〇一二三四五六七八九'
BASE = len(JP_NUMERIC_LETTERS)

def alabic_to_jp(alabic):
  d, m = divmod(alabic, BASE)
  if d:
    return alabic_to_jp(d) + JP_NUMERIC_LETTERS[m]
  else:
    return JP_NUMERIC_LETTERS[m]

for i, m in enumerate(JP_NUMERIC_LETTERS):
  for j, n in enumerate(JP_NUMERIC_LETTERS):
    if i and j:
      print alabic_to_jp(i*j),
  print

LL Golf Hole 6 - 10進数を2進数に基数変換する (Nested Flatten)

DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def fmt_iter(n, base):
    if n / base:
        for x in fmt(n / base, base):
            yield x
    yield DIGITS[n % base]

def fmt(n, base):
    return ''.join(fmt_iter(n, base))

#for i in range(100):
#    print fmt(i, 2)

漢数字で九九の表 (Nested Flatten)

一行Pythonで343 bytes.

coding指定を使わずに一行で書くのに苦労した…。
SJISのbinaryで無理やり吐かせています。

S,I,R,Z='  ',True,range,ord;A=Z('A');D=Z('K')-A;P,Q,T=R(D),R(I,D),[''.join(map(lambda x,y:chr((Z(x)-
A)*(Z('Q')-A)+Z(y)-A),h,l))for(h,l)in zip(['IF','IO','JP','IE','IG','IN','JF','IL','JK','IO'],['BK',
'IK','DB','OP','OM','MM','IK','OF','EK','LD'])];print'\n'.join([S.join([[([S]+T[I:])[m]+T[n]for m in
P for n in P][i*j]for i in Q])for j in Q])

#coding: utf-8
knums = list(u"〇一二三四五六七八九")
one, ten = int(True), len(knums)
for i in range(one, ten):
    for j in range(one, ten):
        hi = i * j / ten
        print u"%s%s" % (hi and knums[hi] or u'　', knums[i * j % ten]),
    print

π (Nested Flatten)

print math.atan(1)*4 でもいいですな。

DouKaku?

Language detail: Python

Unsolved challenges

codes

Index

Feed

Other

Link

Pathtraq