struct Student {
    first_name: String,
    last_name: String,
    #[allow(unused)]
    full_name: String,
}

impl Student {
    fn new(first_name: &str, middle_initial: &str, last_name: &str) -> Self {
        Self {
            first_name: first_name.into(),
            last_name: last_name.into(),
            full_name: format!("{first_name} {middle_initial} {last_name}"),
        }
    }
}

impl Person for Student {
    fn first_name(&self) -> String {
        self.first_name.clone()
    }

    fn last_name(&self) -> String {
        self.last_name.clone()
    }
}

trait Person {
    fn first_name(&self) -> String;
    fn last_name(&self) -> String;
}

//fn greeter(person: impl Person) -> String { // またはこう
fn greeter<P: Person>(person: P) -> String {
    format!("Hello, {} {}", person.first_name(), person.last_name())
}

fn main() {
    let user = Student::new("Jane", "M.", "User");
    println!("{}", greeter(user));
}

window.addEventListener('keypress', handleKeyDown);

var pressed = "";
var howmany = 0;
document.querySelector('#main').innerHTML = `
<h1>${pressed}<h1>
<h2>現在${howmany}文字入力中です<h2>
<h3>右クリックでファイルにセーブできます<h3>
`
function handleKeyDown (event) {
  if(event.key !== "Enter"){
  if(event.key === "Backspace"){
    pressed = pressed.slice(0, pressed.length - 1)
  }else if (event.key === " "){
    pressed += " "
  
  }else if(/[a-zA-Z0-9]/.test(event.key)){
  pressed += event.key
  }else if(/[,.;:@!"#$%&'-^<>?+*`~=_/]/.test(event.key)){
  pressed += event.key
  }
}
  
  howmany = pressed.length
  document.querySelector('#main').innerHTML = `
<h1>${pressed}<h1>
<h2>現在${howmany}文字入力中です<h2>
`
}

function draw() {
  if (mouseButton === RIGHT && mouseIsPressed === true) {
    var typed = createWriter('typed.txt')
    typed.print(pressed);
    typed.close();
    typed.clear();
    }
}

<?php

const CARDS = [
    '2' => 2
    , '3' => 3
    , '4' => 4
    , '5' => 5
    , '6' => 6
    , '7' => 7
    , '8' => 8
    , '9' => 9
    , '10' => 10
    , 'J' => 11
    , 'Q' => 12
    , 'K' => 13
    , 'A' => 14
];

const HIGH_CARD = 'high card';
const PAIR = 'pair';
const STRAIGHT = 'straight';
const THREE_CARD = 'three card';

const HAND_RANKS = [
    'high card' => 0
    ,'pair' => 1
    ,'straight' => 2
    ,'three card' => 3
];


function showDown (string $card11, string $card12, string $card13, string $card21, string $card22, string $card23): array
{
    $cards = [$card11, $card12, $card13, $card21, $card22, $card23];
    $cardRanks = [];
    // 6枚のカードの文字列から数字部分のみを抽出し、新しい配列$cardNumbersに格納
    // その後、CARDS定数を使って数字ごとのランクに変換
    foreach ($cards as $card) {
        array_push($cardRanks, CARDS[substr($card, 1)]);
    }
    // 3つずつ各プレイヤーの手札として振り分ける
    $playerCardRanks = array_chunk($cardRanks, 3);
    // プレイヤーごとの役をユーザー定義関数checkHandsで決定。
    // $playerCardRanksを2プレイヤー分に分けてからでないと、checkHands関数で2次元配列を扱うことになってしまう上に、配列の引数２つというのも関数を定義しづらい
    $player1Hand = checkHands($playerCardRanks[0]);
    $player2Hand = checkHands($playerCardRanks[1]);
    // 勝敗を決定
    $winner = decideWinner($player1Hand, $player2Hand);
    return [$player1Hand['hand'], $player2Hand['hand'], $winner];
}

function checkHands(array $playerCardRanks): array
{
    $hand = HIGH_CARD;
    if (isThreeCard($playerCardRanks)) {
        $hand = THREE_CARD;
    } elseif (isPair($playerCardRanks)) {
        $hand = PAIR;
    } elseif (isStraight($playerCardRanks)) {
        $hand = STRAIGHT;
    }
    rsort($playerCardRanks);

    // 手札がa,2,3の場合はaを最弱にする
    // aのランク14をカードの種類の数13で割った余りは1なので、それをaのランクとする
    if ($playerCardRanks[1] === $playerCardRanks[2] + 1 && $playerCardRanks[2] === $playerCardRanks[0] % count(CARDS) + 1) {
        $playerCardRanks[0] = $playerCardRanks[0] % count(CARDS);
    }

    return [
        'hand' => $hand
        ,'handRank' => HAND_RANKS[$hand]
        ,'biggestNum' => $playerCardRanks[0]
        ,'middleNum' => $playerCardRanks[1]
        ,'smallestNum' => $playerCardRanks[2]
    ];
}

function isThreeCard(array $playerCardRanks): bool
{
    // 一つ目の値の数がカード全体の枚数に等しいとき（すなわち、全てのカードの値が同じとき）、trueを返す（ボツ案）
    // if (array_count_values($playerCardRanks)[0] === count($playerCardRanks)) {
    //     return true;

    // それぞれのプレイヤーの手札のうち、重複する種類が1種類の（すべて重複する）ときにtrueを返す
    if (count(array_unique($playerCardRanks)) === 1) {
        return true;
    } else {
        return false;
    }

    // ここは無難に、それぞれのカードの値が等しいときでも可
    // if ($playerCardRanks[0] === $playerCardRanks[1] && $playerCardRanks[1] === $playerCardRanks[2]) {
    //     return true;
    // }
}

function isPair(array $playerCardRanks): bool
{
    // if (count(array_count_values($playerCardRanks)) === 2) {
    //     return true; (ボツ案)

    // 重複する値の種類が2の時
    if (count(array_unique($playerCardRanks)) === 2) {
        return true;
    } else {
        return false;
    }
}

function isStraight(array $playerCardRanks): bool
{
    rsort($playerCardRanks);
    $biggestCard = $playerCardRanks[0];
    $middleCard = $playerCardRanks[1];
    $smallestCard = $playerCardRanks[2];
    // echo('biggestCard:' . $biggestCard);

    // 1番大きい数が2番目の数より1大きく、2番目の数が3番目の数より大きい場合
    if ($biggestCard === $middleCard + 1 && $middleCard === $smallestCard + 1) {
        return true;
    // 1番大きい数がA、2番目の数が3、1番小さい数が2の場合を想定している。
    // AのCardRank14をカードの種類の数13で割った余りは1なので、AのCardRankをそれにすり替える。（リングバッファーのアルゴリズムから着想。）
    } elseif ($middleCard === $smallestCard + 1 && $smallestCard === $biggestCard % count(CARDS) + 1) {
        return true;
    } else {
        return false;
    }
}

function decideWinner (array $player1Hand, array $player2Hand): int
{

    // 勝敗を決める要素をまとめる。それぞれの役、1番大きい数、2番目の数、1番小さい数
    $judgementElements = ['handRank', 'biggestNum', 'middleNum', 'smallestNum'];

    // それぞれの要素ごとに大小を比較していって、大小が決まった時点で結果を返す
    // いずれの要素でも決着がつかなかった場合に、0（引き分け）を返す
    foreach ($judgementElements as $judgementElement) {
        if($player1Hand[$judgementElement] > $player2Hand[$judgementElement]) {
            return 1;
        } elseif ($player2Hand[$judgementElement] > $player1Hand[$judgementElement]) {
            return 2;
        }
    }
    return 0;
}

var_dump(showDown('SK', 'D9', 'CJ', 'S10', 'H10', 'D6'));
var_dump(showDown('DK', 'S2', 'HA', 'C4', 'H5', 'S6'));
var_dump(showDown('S9', 'CJ', 'DK', 'C3', 'C3', 'H3'));
var_dump(showDown('H3', 'D4', 'C5', 'HK', 'S10', 'DK'));
var_dump(showDown('S3', 'H3', 'C3', 'D10', 'SK', 'D10'));
var_dump(showDown('C3', 'S3', 'H3', 'CK', 'SJ', 'SQ'));
var_dump(showDown('DJ', 'HK', 'S9', 'CQ', 'D9', 'S10'));
var_dump(showDown('C7', 'S5', 'H3', 'S5', 'S7', 'D3'));
var_dump(showDown('CA', 'DA', 'CK', 'D2', 'D2', 'C3'));
var_dump(showDown('HK', 'DK', 'SA', 'CA', 'SA', 'SK'));
var_dump(showDown('D4', 'D7', 'K7', 'D6', 'K4', 'C6'));
var_dump(showDown('SK', 'D9', 'CJ', 'S10', 'H10', 'D6'));
var_dump(showDown('S4', 'C4', 'S7', 'S4', 'S4', 'C7'));
var_dump(showDown('SA', 'DQ', 'DK', 'CA', 'C2', 'D3'));
var_dump(showDown('SA', 'DK', 'DQ', 'CK', 'CQ', 'DJ'));
var_dump(showDown('H2', 'D3', 'D4', 'HA', 'C2', 'S3'));
var_dump(showDown('S2', 'S3', 'S4', 'C2', 'C3', 'D4'));
var_dump(showDown('S2', 'S2', 'S2', 'DA', 'HA', 'CA'));
var_dump(showDown('CK', 'CK', 'SK', 'SA', 'HA', 'DA'));
var_dump(showDown('D2', 'C2', 'S2', 'C3', 'H3', 'S3'));

#include <iostream>
using namespace std;

int main(void){

    string d, e, f;
    cin >> d >> e >> f;
    cout << d << "と" << e << "と" << f << endl;
}

#------------------------------------------------------------------------------------------
def set_logger():
    #======================================================================================
    # set logger
    #--------------------------------------------------------------------------------------
    # ロガーにファイルハンドラ・コンソールハンドラをセットします
    # プログラムを終了する場合は、ロガーの終了処理（関数：kill_logger）を挟んでください
    # INPUT：なし
    # OUTPUT：なし
    #======================================================================================

    #ロガーを定義
    logger = logging.getLogger(__name__)
    logger.setLevel(DEBUG)

    #出力フォーマット定義
    #20220212 12:00:00 CRITICAL >> Excution has failed.
    formatter = logging.Formatter('[%(asctime)s] %(levelname)s >> %(message)s')

    #コンソール出力用ハンドラ定義
    s_handler = logging.StreamHandler()
    s_handler.setLevel(DEBUG)
    s_handler.setFormatter(formatter)

    #ログファイル出力用ハンドラ定義
    f_handler = logging.FileHandler('.\\ExcelKeyReadLog.log','a+')
    f_handler.setLevel(INFO)
    f_handler.setFormatter(formatter)

    #ハンドラをロガーに登録
    logger.addHandler(s_handler)
    logger.addHandler(f_handler)

    logger.debug('set the logger has completed.')

    #デバッグ：ハンドラ一覧を表示
    print([logging.getLogger(name) for name in logging.root.manager.loggerDict])

    return
#------------------------------------------------------------------------------------------

def kill_logger():

    #======================================================================================
    # kill logger
    #--------------------------------------------------------------------------------------
    # set loggerで起動したロガーを終了します
    # INPUT：なし
    # OUTPUT：なし
    #======================================================================================

    #ロガーを削除
    del logging.Logger.manager.loggerDict[__name__]

    #デバッグ：ハンドラ一覧を表示
    print([logging.getLogger(name) for name in logging.root.manager.loggerDict])
   
    return
#------------------------------------------------------------------------------------------

import pygame.mixer
import schedule
import time
import tkinter as tk  # Tkinterをインポート

fonts = ("", 20)  # フォントの書式とサイズを指定


# 音再生処理
def Sound():
    pygame.mixer.init()  # 初期化
    pygame.mixer.music.load('alerm1.mp3')  # 読み込み
    pygame.mixer.music.play(-1)  # ループ再生（引数を1にすると1回のみ再生）
    input()
    pygame.mixer.music.stop()  # 終了


def Alarm():
    print("時間です")
    print("\007")  # ビープ音
    Sound()
    exit()  # これがないと無限ループになるので注意


class Calculator(tk.Frame):
    # ウィンドウの作成
    def __init__(self, master=None):
        tk.Frame.__init__(self, master)
        self.master.geometry('1024x768')
        self.master.title('アラーム時刻設定')  # ウィンドウタイトルを指定
        self.entry = tk.Entry(self.master, justify='right', font=fonts)  # テキストボックスを作成
        self.creat_widgets()

    def input(self, num):
        def n():
            self.entry.insert(tk.END, num)
            return n

    def schedule_check(self):  # scheduleモジュールにて定期的にタスク状態を確認
        schedule.run_pending()
        self.after(1, self.schedule_check)

    def btn_click(self):
        self.ala = self.entry.get()
        target = ':'
        idx = self.ala.find(target)
        r = self.ala[idx + 1:]
        s = self.ala[:idx]
        setal = f"{s.zfill(2)}:{r.zfill(2)}"
        schedule.every().day.at(setal).do(Alarm)
        print(f"アラーム時刻・・・{setal}")
        self.schedule_check()

    # 1文字削除
    def clear_one(self):
        text = self.entry.get()
        self.entry.delete(0, tk.END)
        self.entry.insert(0, text[:-1])

    def creat_widgets(self):
        Buttons = [
            ['1', '2', '3', '4', '5'],
            ['6', '7', '8', '9', '0']]

        # 各ボタンを配置
        for i, ro in enumerate(Buttons):
            for j, co in enumerate(ro):
                tk.Button(self.master, font=fonts, text=co, width=7, height=2, command=self.input(co)).grid(row=i + 2,
                                                                                                            column=j)

        # テキストボックスを配置
        self.entry.grid(row=0, column=1, ipady=10, columnspan=3, sticky='nsew')

        # 各ボタンの処理
        tk.Button(self.master, text=':', font=fonts, width=1, height=2, command=self.input(':')).grid(row=9, column=0)
        tk.Button(self.master, text='←', font=fonts, width=1, height=2, command=lambda: self.clear_one()).grid(row=9,
                                                                                                           column=1)
        tk.Button(self.master, text='O K', font=fonts, width=20, height=2, command=lambda: self.btn_click()).grid(row=10,
                                                                                                              column=0,
                                                                                                              columnspan=10)


# 実行
calc = Calculator(tk.Tk())
calc.mainloop()

#!/usr/bin/env ruby

# This file loads Spring without using Bundler, in order to be fast.
# It gets overwritten when you run the `spring binstub` command.

unless defined?(Spring)
  require 'rubygems'
  require 'bundler'

  lockfile = Bundler::LockfileParser.new(Bundler.default_lockfile.read)
  spring = lockfile.specs.detect { |spec| spec.name == 'spring' }
  if spring
    Gem.use_paths Gem.dir, Bundler.bundle_path.to_s, *Gem.path
    gem 'spring', spring.version
    require 'spring/binstub'
  end
end

"><xmp>

#include <stdio.h>
#define NUMBER 5
#define FAILED -1
int search(int vc[], int key, int no){
    int i = 0;
    vc[no] = key;
    while(1){
        if(vc[i]==key){
            break;
        }
        i++;
    }
    return(i==no ? FAILED : i);
}

int main(void){
    int i,key,index;
    int vx[NUMBER+1];
    for (int i=0; i<NUMBER; i++) {
        printf("vx[%d]: ", i);
        scanf("%d", &vx[i]);
    }
    printf("探す値:");
    scanf("%d", &key);

    index = search(vx, key, NUMBER);
    
    if(index==FAILED){
        printf("探索失敗");
    }
    else {
        printf("%d is in %d\n", key, index);
    }
    return 0;
}

#include <stdio.h>

int a[11] = {6, 7, 11, 12, 14, 18, 19, 21, 24, 28, 37};
int main(void){
    int key = 11;
    int l = -1;
    int r = sizeof(a)/sizeof(int);
    while (r-l > 1) {
        int m = l + (r - l)/2;
        if (a[m] > key) {
            r = m;
        }
        else {
            l = m;
        }
    }
    printf("%d", r);
    return 0;
}