idekazuki / diary Goto Github PK

def bisect_left(a, x, lo=0, hi=None):
    """Return the index where to insert item x in list a, assuming a is sorted.
    The return value i is such that all e in a[:i] have e < x, and all e in
    a[i:] have e >= x.  So if x already appears in the list, a.insert(x) will
    insert just before the leftmost x already there.
    Optional args lo (default 0) and hi (default len(a)) bound the
    slice of a to be searched.
    """

    if lo < 0:
        raise ValueError('lo must be non-negative')
    if hi is None:
        hi = len(a)
    while lo < hi:
        mid = (lo+hi)//2
        if a[mid] < x: lo = mid+1
        else: hi = mid
    return lo

N = int(input())
B = [[] for _ in range(N)]
for n in range(N - 1):
  tmp = input()
  B[int(tmp)-1].append(n+1)

def salary(taka):
  maxv = 0
  minv = 10e11
  if len(B[taka]) == 0:
    return 1
  else:
    for i in B[taka]:
      tmp = salary(i)
      maxv = max(maxv, tmp)
      minv = min(minv, tmp)
  return maxv + minv + 1

ans = salary(0)
if ans == 1:
  ans = 3
print(ans)

N, W = map(int, input().split())
I = [list(map(int, input().split())) for _ in range(N)]
MAX_V = sum(v for v, _ in I)
dp = [W+1] * (MAX_V + 1)
dp[0] = 0
for v, w in I:
    for j in range(MAX_V, v-1, -1):
        dp[j] = min(dp[j-v] + w, dp[j])
        
for i in range(MAX_V, -1, -1):
  if dp[i] <= W:
    print(i)
    break

def add(x, y):
  return x + y
import functools
add_1 = functools.partial(add, x=1)
print(add_1(3))
>>>4

import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0, 1'

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

fig = plt.figure()

ims = []

for i in range(10):
        rand = np.random.randn(100)     # 100個の乱数を生成
        im = plt.plot(rand)             # 乱数をグラフにする
        ims.append(im)                  # グラフを配列 ims に追加

# 10枚のプロットを 100ms ごとに表示
ani = animation.ArtistAnimation(fig, ims, interval=100)
plt.show()

from typing import Union
x: Union[int, None]
x = None

c = set()
a = ['aa','cc','ba2']
b = ['bb','bb2','cc']
c.union(a,b)
>>{'aa', 'ba2', 'bb', 'bb2', 'cc'}

class AverageMeter(object):
    """Computes and stores the average and current value"""
    def __init__(self):
        self.reset()

    def reset(self):
        self.val = 0
        self.avg = 0
        self.sum = 0
        self.count = 0

    def update(self, val, n=1):
        self.val = val
        self.sum += val * n
        self.count += n
        self.avg = self.sum / self.count

import numpy as np
 
def is_prime(N):
  up = int(np.sqrt(N))
  if not(N % 2): return 'NO' 
  for i in range(3, up + 1, 2):
    if N % i:
      continue
    else:
      return 'NO'
  return 'YES'
 
N = int(input())
print(is_prime(N))

import numbers
import numpy as np
x = np.arange(10)
isinstance(x, numbers.Number)
>>False

isinstance(x[0], numbers.Number)
>>True

[[-1, -1, 0, -1, -1, -1, -1, -1, -1, -1], 
[-1, -1, 0, -1, -1, -1, -1, -1, -1, -1],
 [-1, -1, 0, -1, -1, -1, -1, -1, -1, -1],
 [-1, -1, 0, -1, -1, -1, -1, -1, -1, -1],
 [-1, -1, 0, -1, -1, -1, -1, -1, -1, -1],
 [-1, -1, 0, -1, -1, -1, -1, -1, -1, -1], 
[-1, -1, 0, -1, -1, -1, -1, -1, -1, -1]]

# iterableであるために
# __iter__(iteration/iterator protocol : 反復プロトコルというらしい)を実装する
class Foo():
    def __init__(self):
        self._L = [0,1,2]

    def __iter__(self):
        return FooIterator(self)

# iteratorであるために__iter__, __next__を実装する必要がある
class FooIterator():
    def __init__(self, foo): # fooはiterableなオブジェクト
        self._i = 0
        self._foo = foo

    def __iter__(self):
        return self

    def __next__(self):
        try:
            v = self._foo._L[self._i]
            self._i += 1
            return v
        # StopIteration(RuntimeError)を送出するように実装
        except IndexError:
            raise StopIteration

foo = Foo() #iterableなオブジェクトを生成

# iteratorを直接操作する
## iter関数は__iter__関数を呼び出し、イテレータを取得する。
iter_foo = iter(foo) # iterableオブジェクトを引数に

print(next(iter_foo)) # 0
print(next(iter_foo)) # 1
print(next(iter_foo)) # 2
print(next(iter_foo)) # StopIteration:が送出され、エラー

_single_leading_underscore: “内部でだけ使う” ことを示します。たとえばfrom M import *は、アンダースコアで始まる名前のオブジェクトをインポートしません。
__double_leading_underscore: クラスの属性に名前を付けるときに、名前のマングリング機構を呼び出します (クラスFoobarの__booという名前は_FooBar__booになります。以下も参照してください)

公開されていないメソッドやインスタンス変数にだけ、アンダースコアを先頭に付けてください。
サブクラスと名前が衝突した場合は、Pythonのマングリング機構を呼び出すためにアンダースコアを先頭に二つ付けてください。

* 公開されている(public)属性の先頭にはアンダースコアを付けない
* もしあなたが公開している属性の名前が予約語と衝突する場合は、属性の名前の直後にアンダースコアを追加します。省略語を使ったり、スペルミスをするよりはマシです。
* サブクラス化して使うクラスがあるとします。サブクラスで使って欲しくない属性があった場合、その名前の最後ではなく、先頭にアンダースコアを二つ付けることを検討してみましょう。これによって Python のマングリングアルゴリズムが呼び出され、その属性にはクラス名が付加されます。これはサブクラスにうっかり同名の属性が入ってしまうことによる属性の衝突を避けるのに役立ちます。

#-*- coding:utf-8 -*-
import cv2
import numpy as np


def main():

    # 動画の読み込み
    cap = cv2.VideoCapture("../../EPIC-KITCHENS/videos/test/P01/P01_12.MP4")

    # 動画終了まで繰り返し
    while(cap.isOpened()):

        # フレームを取得
        ret, frame = cap.read()

        # フレームを表示
        cv2.imshow("Flame", frame)

        # qキーが押されたら途中終了
        if cv2.waitKey(10) & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()


if __name__ == "__main__":
    main()

from PIL import ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES = True

from collections import deque
H, W = map(int, input().split())
padding = ['#' for _ in range(W + 2)]
Map = tuple([padding])
Map += tuple(['#'] + list(input()) + ['#'] for _ in range(H))
Map += tuple([padding])
dxy = [(1, 0), (-1, 0), (0, 1), (0, -1)]

done = [[-1 for _ in range(W + 2)] for _ in range(H + 2)]

q = deque()
push, pop = q.append, q.popleft
push((1, 1))
done[1][1] = 0
while q:
  y, x = pop()
  for dy, dx in dxy:
    if Map[y + dy][x + dx] == '.' and done[y + dy][x + dx] == -1:
      push((y + dy, x + dx))
      done[y + dy][x + dx] = done[y][x] + 1
  if done[H][W] != -1:
    break
    
cnt = 0
for i in range(1, H + 1):
  for j in range(1, W + 1):
    if Map[i][j] == '.':
      cnt += 1
ans = cnt - done[H][W] -1

print(ans if done[H][W] != -1 else -1)

name = input()
ans = 'YES'
search = len(name) // 2
for i in range(search):
  if name[i] == name[len(name) - 1 - i]:
    ans = 'YES'
  else:
    ans = 'NO'
    break
print(ans)

name = input()
ans = 'YES' if name == name[::-1] else 'NO'
print(ans)

ans = 'YES' if name == name[::-1] else 'NO'
print(ans)

subprocess.call('mkdir tmp', shell=True)
subprocess.call('ffmpeg -i {} tmp/image_%05d.jpg'.format(video_path),
shell=True)
#なんか処理
result = classify_video('tmp', input_file, class_names, model, opt)

def myfunc1():
 yield 10
 yield 20

generator = myfunc1()
print(next(generator))
print(next(generator))

>>10
  20

def myfunc2(x:int):
 for i in range(x):
  yield i*2

generator = myfunc2(3)
print(next(generator))
print(next(generator))
print(next(generator))
>>0
  2
  4

def myfunc(gen1, gen2):
 yield from gen1
 yield from gen2

generator = myfunc(gen1, gen2)

for i in range(5):
 print(next(generator))

>>10
  20
  0
  2
  4

def calculate_video_results(output_buffer, video_id, test_results, class_names):
    video_outputs = torch.stack(output_buffer)
    average_scores = torch.mean(video_outputs, dim=0)
    sorted_scores, locs = torch.topk(average_scores, k=10)

    video_results = []
    for i in range(sorted_scores.size(0)):
        video_results.append({'label': class_names[locs[i]], 'score': sorted_scores[i]})

    test_results['results'][video_id] = video_results

Returns the k largest elements of the given input tensor along a given dimension.

If dim is not given, the last dimension of the input is chosen.

If largest is False then the k smallest elements are returned.

A namedtuple of (values, indices) is returned, where the indices are the indices of the elements in the original input tensor.

The boolean option sorted if True, will make sure that the returned k elements are themselves sorted

Parameters

        input (Tensor) – the input tensor

        k (int) – the k in “top-k”

        dim (int, optional) – the dimension to sort along

        largest (bool, optional) – controls whether to return largest or smallest elements

        sorted (bool, optional) – controls whether to return the elements in sorted order

        out (tuple, optional) – the output tuple of (Tensor, LongTensor) that can be optionally given to be used as output buffers

Example:


>>> x = torch.arange(1., 6.)
>>> x
tensor([ 1.,  2.,  3.,  4.,  5.])
>>> torch.topk(x, 3)
torch.return_types.topk(values=tensor([5., 4., 3.]), indices=tensor([4, 3, 2]))

python3 main.py --input ./input --video_root ../../UCF-101/Archery/ --output ./output.json --model ./pretrain_data/resnet-18-kinetics.pth --mode score --model_depth 18
loading model ./pretrain_data/resnet-18-kinetics.pth
>>

loading model ./pretrain_data/resnet-18-kinetics.pth
resnet-18
../../UCF-101/Archery/v_Archery_g01_c01.avi
ffmpeg version 2.6.3 Copyright (c) 2000-2015 the FFmpeg developers
  built with gcc 4.8 (Ubuntu 4.8.4-2ubuntu1~14.04)
  configuration: --prefix=/usr/local --enable-shared --disable-static
  libavutil      54. 20.100 / 54. 20.100
  libavcodec     56. 26.100 / 56. 26.100
  libavformat    56. 25.101 / 56. 25.101
  libavdevice    56.  4.100 / 56.  4.100
  libavfilter     5. 11.102 /  5. 11.102
  libswscale      3.  1.101 /  3.  1.101
  libswresample   1.  1.100 /  1.  1.100
Input #0, avi, from '../../UCF-101/Archery/v_Archery_g01_c01.avi':
  Metadata:
    encoder         : MEncoder r34118-4.2.5
  Duration: 00:00:05.24, start: 0.000000, bitrate: 781 kb/s
    Stream #0:0: Video: mpeg4 (Simple Profile) (XVID / 0x44495658), yuv420p, 320x240 [SAR 1:1 DAR 4:3], 669 kb/s, 25 fps, 25 tbr, 25 tbn, 25 tbc
    Stream #0:1: Audio: mp3 (U[0][0][0] / 0x0055), 44100 Hz, stereo, s16p, 99 kb/s
[swscaler @ 0xe3f200] deprecated pixel format used, make sure you did set range correctly
Output #0, image2, to 'tmp/image_%05d.jpg':
  Metadata:
    encoder         : Lavf56.25.101
    Stream #0:0: Video: mjpeg, yuvj420p(pc), 320x240 [SAR 1:1 DAR 4:3], q=2-31, 200 kb/s, 25 fps, 25 tbn, 25 tbc
    Metadata:
      encoder         : Lavc56.26.100 mjpeg
Stream mapping:
  Stream #0:0 -> #0:0 (mpeg4 (native) -> mjpeg (native))
Press [q] to stop, [?] for help
frame=  131 fps= 32 q=24.8 Lsize=N/A time=00:00:05.24 bitrate=N/A    
video:546kB audio:0kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: unknown
/host/space0/ide-k/out_git/video-classification-3d-cnn-pytorch/classify.py:25: UserWarning: volatile was removed and now has no effect. Use `with torch.no_grad():` instead.
  inputs = Variable(inputs, volatile=True)

#coding:utf-8
import json


def main():
    with open('./output.json') as f:
        jsn = json.load(f)
    #読み込んだ形式を表示
    print(type(jsn))
    #整えた書式で全体を表示
    print(json.dumps(jsn, sort_keys=True, indent=4))
    #ラベルのみを抽出
    for jsn_dic in jsn:
        print(len(jsn_dic["clips"]))
        for i in range(len(jsn_dic["clips"])):
            print(jsn_dic["clips"][i]["label"])
if __name__ == "__main__":
    main()

<class 'list'>                                                                                             │  1 [{"video": "v_Archery_g01_c01.avi", "clips": [{"segment": [1, 16], "label": "archery", "scores": [1.7
[                                                                                                          │    758756875991821, 2.1774258613586426, -0.3326228857040405, -0.29544246196746826, -2.281000852584839, 7
    {                                                                                                      │    .768344402313232, 0.3198256194591522, -1.115415334701538, -2.7847046852111816, 0.28276023268699646, -
        "clips": [                                                                                         │    3.1307008266448975, -1.4592198133468628, -0.11600761115550995, 0.8592607975006104, -0.768841564655304
            {                                                                                              │    , -0.8403390049934387, -0.1674695611000061, -0.3636217713356018, 0.06561709940433502, -2.458683490753
                "label": "archery",                                                                        │    174, 1.1174076795578003, 1.9969531297683716, -3.195760488510132, -0.8408206105232239, 1.0247690677642
                "scores": [                                                                                │    822, -0.40334686636924744, -0.3428850769996643, -1.8218177556991577, -1.6184970140457153, 1.839611530
                    1.7758756875991821,
                               .
                               .
                               .
                    1.2808388471603394,
                    -1.083033561706543
                ],
                "segment": [
                    113,
                    128
                ]
            }
        ],
        "video": "v_Archery_g01_c01.avi"
    }
]

import sys 
sys.setrecursionlimit(5000000)
h, w = map(int, input().split())
l = [list(input()) for _ in range(h)]
def dfs(r, c):
  if not(0 <= c < w and 0 <= r < h) or l[r][c] == "#":
    return
  if l[r][c] == "g":
    print("Yes")
    exit()
  l[r][c] = "#"
  dfs(r+1, c)
  dfs(r-1, c)
  dfs(r, c+1)
  dfs(r, c-1)

for i, val in enumerate(l):
  if "s" in val:
    dfs(i, val.index("s"))
    break
print("No")

isinstance(True, int)
>>True
isinstance(True, int)
>>True

bl2 = np.arange(N,dtype=np.int64)[:,None]
print(bl2)
bl3 = np.arange(N,dtype=np.int64)[None,:]
print(bl3)
print(bl2.shape)
print(bl3.shape)
print(bl2 < bl3)
>>[[0]
 [1]
 [2]
 [3]]
[[0 1 2 3]]
(4, 1)
(1, 4)
[[False  True  True  True]
 [False False  True  True]
 [False False False  True]
 [False False False False]]

N, A, B = list(map(int, input().split()))
S = [int(input()) for _ in range(N)]

sub = (max(S) - min(S))
if sub != 0:
  P = B / sub
  Q = A - P * sum(S) / N
  print(P ,Q)
else:
  print(-1)

def grey_to_rgb(frames):
    """
    Convert frame(s) from gray (2D array) to RGB (3D array)
    """
    n_channels = 3
    return np.repeat(np.array(frames)[..., np.newaxis], n_channels, axis=-1)


def stitch_flow_uv_frames(uv_frames, width_axis=2):
    """
    Destack (u, v) frames and concatenate them side by side for display purposes
    """
    u_frames = np.array(uv_frames[::2])
    v_frames = np.array(uv_frames[1::2])
    stacked_frames = np.concatenate((u_frames, v_frames), axis=width_axis)
    return stacked_frames


def clipify_flow(frames, fps=30):
    """
    Destack flow frames, join them side by side and then create an ImageSequenceClip
    for display
    """
    frames = grey_to_rgb(stitch_flow_uv_frames(list(map(np.array, frames))))
    segment_clip = ImageSequenceClip(list(frames), fps=fps)
    return segment_clip

example_segment = flow_train.video_segments[10]
# Note you can also pass an iterable of frame indices to extract, this is useful for
# methods like TSN which only need a few frames
example_flow_frames =  flow_train.load_frames(example_segment, range(0, example_segment.num_frames))
clipify_flow(example_flow_frames).ipython_display()

filename = 'aa_bb_cc'
print(filename[filename.find('_')+1:filename.find('_', 3)])
>>bbb